# AI use cases for Any Jev (nokia-applied-research/AnyJev)

Repo: [nokia-applied-research/AnyJev](https://github.com/nokia-applied-research/AnyJev) | Use cases: 3 | Page: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/

AnyJev is a Python library that turns an LLM into a decision model: you give it a state and a typed question, and it returns an answer with a probability over the options, read from the model's next-token distribution.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Route support tickets to one option with a probability: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/route-tickets-with-tacit-decisions/
- Route tickets on an open LLM with no training or labels: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/route-tickets-training-free-on-any-llm/
- Share one decision endpoint with a capped reasoning budget: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/share-decision-endpoint-with-escalation-cap/

## How to route support tickets to one option with a probability with Any Jev

Repo: [nokia-applied-research/AnyJev](https://github.com/nokia-applied-research/AnyJev) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Send a customer message to one of several queues and get the probability for each queue in one call.

**Who it is for:** A support or operations engineer who wants a Python service to sort incoming customer messages into fixed categories and needs a confidence value for each sort.

**The problem:** Free-text model replies are hard to parse and give no usable confidence, so routing rules end up brittle.

**The outcome:** Each message gets one chosen option, a probability per option, and a route field showing whether the decision came from a single forward pass or from reasoning.

### Steps

1. Create a Python environment and run `pip install "anyjev[hf]"`. (inferred, check the README)
2. Load the model in Python with `Tacit.from_pretrained("morriszjm/Tacit-9B")`.
3. Call `tacit.decide(state=<customer message>, question="What does the customer want?", options=[<your queue names>])` on one message. (inferred, check the README)
4. Read `d["answer"]`, `d["probs"]` and `d["route"]` from the returned result.
5. Use `decide_batch([...])` with a list of decision dicts to process a queue of messages.

### Prompt to paste into your agent

```text
Using the repo AnyJev (nokia-applied-research/AnyJev), load morriszjm/Tacit-9B with Tacit.from_pretrained and call decide on <customer message> with the options <queue list>. Expected output: the chosen option, a probability per option, and the route value. Verify that the probabilities sum to about 1 before routing the ticket.
```

### Caveat

The Tacit checkpoints are published on Hugging Face and need a GPU for the 9B model, so check hardware before you plan the rollout.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/route-tickets-with-tacit-decisions/

## How to route tickets on an open LLM with no training or labels with Any Jev

Repo: [nokia-applied-research/AnyJev](https://github.com/nokia-applied-research/AnyJev) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Use the Decider at level L0 to get stable option probabilities from any open causal LM.

**Who it is for:** A developer with an open LLM already downloaded who needs a routing or classification step and has no labeled data to train on.

**The problem:** Raw label logits change when the options are reordered and carry the model's bias toward some labels, so the probabilities are not trustworthy.

**The outcome:** A Decision with a distribution over the options and a level value of L0, which downstream code can require before acting.

### Steps

1. Run `pip install anyjev` in a Python environment with the backend you need. (inferred, check the README)
2. Create the backend with `HFBackend("Qwen/Qwen3-8B")` and build a Decider with `Decider(backend)`.
3. Define a choice question with `Question.choice("Which team should handle this?", ["billing", "technical", "sales", "other"], name="route")`. (inferred, check the README)
4. Call `d.decide(<ticket text>, [route])["route"]` and read `r.distribution` and `r.level`. (inferred, check the README)
5. Optionally enable the rotation budget with `Decider(backend, adaptive_shifts=True, canonical_order=True)` and calibrate it on a few hundred unlabelled tickets using `calibrate_adaptive`.

### Prompt to paste into your agent

```text
Using the repo AnyJev (nokia-applied-research/AnyJev), build a Decider on Qwen/Qwen3-8B with HFBackend and route the ticket <ticket text> using a choice question over <option list>. Expected output: a distribution over the options and the level L0. Verify that the distribution is returned for every option and that the level is L0 before acting on the result.
```

### Caveat

The README's accuracy and automation figures come from BANKING77 with Qwen3-8B, so measure on your own tickets before trusting the threshold.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/route-tickets-training-free-on-any-llm/

## How to share one decision endpoint with a capped reasoning budget with Any Jev

Repo: [nokia-applied-research/AnyJev](https://github.com/nokia-applied-research/AnyJev) | Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Run a local HTTP gateway so several clients get decisions and share one cap on reasoning escalations.

**Who it is for:** A platform engineer who wants several internal tools to call the same decision model and needs a single limit on how often the expensive reasoning path runs.

**The problem:** Each client calling the model directly would escalate hard decisions to reasoning without any shared limit, which makes cost and latency unpredictable.

**The outcome:** A local gateway answers POST /v1/decide requests and GET /v1/stats reports the escalation share, with at most the configured share of recent decisions sent to reasoning.

### Steps

1. Run `pip install "anyjev[client]"` and start the model server with `vllm serve morriszjm/Tacit-9B --host 127.0.0.1 --port 8000`. (inferred, check the README)
2. Start the gateway with `python -m anyjev.serve --model morriszjm/Tacit-9B --upstream http://127.0.0.1:8000 --adaptive --port 8100`.
3. Send one decision with `curl -s 127.0.0.1:8100/v1/decide -H 'Content-Type: application/json' -d '{"state": "Customer: my package has not arrived.", "question": "What does the customer want?", "options": ["track_order", "refund"]}'`. (inferred, check the README)
4. Check the escalation share through `GET /v1/stats` and adjust `max_cot_share` and `cot_window` if the share is too high.
5. Keep the gateway on 127.0.0.1 or put it behind your own authentication, because the gateway has none of its own.

### Prompt to paste into your agent

```text
Using the repo AnyJev (nokia-applied-research/AnyJev), start the vLLM server for morriszjm/Tacit-9B and the anyjev.serve gateway on port 8100, then POST the decision <state text> with options <option list> to /v1/decide. Expected output: a JSON decision with answer, probs and route fields. Verify that GET /v1/stats returns an escalation share at or below the configured cap.
```

### Caveat

The gateway has no authentication of its own and listens on 127.0.0.1, so exposing it to other machines needs your own access control.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/nokia-applied-research-anyjev/share-decision-endpoint-with-escalation-cap/