Jev: when your agent needs a decision, not a paragraph

Most of the steps your agent takes aren’t writing. They’re picking from a closed list. And you pay for them as if you’d asked for an essay.

Look at a real trace. Which team gets the ticket. Which tool to call. Is the input safe. Should this go to a human. None of these needs a paragraph. Yet we send them to an LLM that writes token after token, parse whatever comes back, and act surprised when it invents a tool that doesn’t exist.

On September 15, 2026, TypeSafe AI released Jev, a model that returns only that: a decision with a probability. Pricing is $42 per billion input tokens, and output is free. In the demo on their homepage the same task takes 0.114 seconds and costs $0.000081, versus 8.566 seconds and $0.013880 on a regular LLM. And Vercel wrote that Jev took off on AI Gateway faster than any model that has ever been there.

Jev is a function call that returns a probability, not a chatbot

The person behind it is Diogo Almeida. At OpenAI he worked on the methods that got language models to follow instructions and hold a conversation, the research that led to ChatGPT. After two years in stealth he called what he built a “System One Model”, after Kahneman’s fast, intuitive thinking. The training method is called RLCD, Reinforcement Learning for Calibrated Decisions.

The contract is simple. You send state (an email, a log line, a ticket, JSON) and a list of typed questions. There are three kinds: a choice among options you defined, a score on a rubric, and yes/no. Every answer comes back with a calibrated probability. No explanation, no paragraph.

What it isn’t:

• It isn’t a smaller LLM. It gave up text generation entirely.
• It isn’t JSON mode. With structured outputs the model still produces a string you parse, and it can put the name of a tool that doesn’t exist inside perfectly valid JSON.
• “Can’t hallucinate” doesn’t mean “always right.” Beam put it best: Jev can pick the wrong option. It can’t return something outside the list, something broken, or something that doesn’t match the schema.

Almeida put it this way in the launch post:

While Jev gives up string generation, it’s optimized for structured outputs and can’t hallucinate.

— Diogo Almeida, founder of TypeSafe, Sept 15, 2026

Inside: one forward pass, then a split

A regular LLM is autoregressive. It produces a token, feeds it back in, and produces another. Jev answers in a single forward pass.

So what’s actually happening in there? Arcturus Labs assume Jev is very close to a regular LLM. It runs one step, takes the probability distribution over every possible token, and keeps only the ones that stand for your options. nobodywho went a step further and on September 22 published “Jev in 25 Lines of Python”: a local Qwen3-0.6B, an email asking for a password on a non-company sign-in page, three options. The result: Phishing 0.885, Spam 0.084, Legitimate 0.031. Their line: “There. That’s Jev.”

They’re half right. The mechanism is old, and what TypeSafe is selling is two things the 25 lines don’t have:

• Calibration. A raw softmax tells you nothing about hit rate. According to Ollaya’s comparison, even Ollama documents that the probabilities of the decision models they run aren’t calibrated. RLCD is supposed to make sure a 0.9 is actually right 90% of the time.
• Parallelism. Up to 256 questions in one request, and up to 255 options per question.

The numbers, on their workflows

$42 per billion is $0.042 per million input tokens. TypeSafe claim that’s 238x cheaper on input than Claude Fable 5.1, and that on their tasks Jev is 193.6x faster and 444.6x cheaper. Their numbers, on their workflows.

Do the math on your own load. 100,000 tickets a day at 800 tokens each is 80 million tokens. On Jev that’s $3.36 a day.

The best public example isn’t TypeSafe’s at all. Christian Mathiesen from Frigade had Jev play Pokémon Red all the way to the Hall of Fame: 37 hours 40 minutes, 16,150 decisions, about 39.2 million input tokens, and roughly $1.65 in total. A median of 0.4 seconds per decision. That’s about a cent per hundred decisions. Still, the whole team wiped 16 times, and it took 15 attempts at the Elite Four. The model isn’t a genius. It’s just cheap enough to be wrong a lot.

That said, MindStudio pointed out that every launch demo, Minecraft, a drone, driving, runs inside a simulator. We haven’t seen anything on real hardware yet.

Adding a decision layer without waiting for early access

The pattern itself doesn’t depend on Jev. Four steps:

1. Isolate the agent steps whose answer is closed in advance: routing, tool selection, safety gate, “hand off to a human?”.
2. Define the options in code, not inside the prompt.
3. Set a threshold. Above it the code acts on its own, below it you escalate.
4. Store the probability of every decision, so you can measure calibration later.

Here’s the nobodywho version, wrapped in a function with a threshold. It runs on a laptop with uv run decide.py:

# /// script
# requires-python = ">=3.12"
# dependencies = ["huggingface-hub", "llama-cpp-python", "numpy"]
# ///
import numpy as np
from llama_cpp import Llama

model = Llama.from_pretrained(
    repo_id="Qwen/Qwen3-0.6B-GGUF",
    filename="Qwen3-0.6B-Q8_0.gguf",
    n_ctx=512, logits_all=True, verbose=False,
)

def decide(state, choices, threshold=0.8):
    labels = [chr(ord("A") + i) for i in range(len(choices))]
    options = "\n".join(f"{l}. {c}" for l, c in zip(labels, choices))
    prompt = (
        "<|im_start|>system\nChoose one option.<|im_end|>\n"
        f"<|im_start|>user\n{state}\n\n{options}<|im_end|>\n"
        "<|im_start|>assistant\n<think>\n\n</think>\n\n"
    )
    model.reset()
    model.eval(model.tokenize(prompt.encode(), add_bos=False, special=True))
    logits = model.scores[model.n_tokens - 1]
    ids = [model.tokenize(l.encode(), add_bos=False)[0] for l in labels]
    z = np.asarray([logits[i] for i in ids])
    p = np.exp(z - np.logaddexp.reduce(z))
    best = int(p.argmax())
    action = "act" if p[best] >= threshold else "escalate"
    return choices[best], round(float(p[best]), 3), action

print(decide(
    "Email: Payroll asks for your password on a non-company sign-in page.",
    ["Legitimate", "Spam", "Phishing"],
))

To be clear, the 0.8 here is a guess. On raw Qwen3-0.6B, a 0.885 doesn’t mean it’s right 88.5% of the time. That’s why step 4 is the whole point.

Where it breaks

• Calibration isn’t perfect. Arcturus Labs showed in a September 16 post that Jev’s probabilities aren’t always right. Even with Jev you’ll have to check on your own data.
• Closed answer spaces only. Need a reply to a customer, a summary, or code? That’s still an LLM.
• Vendor dependency. Early access at a single company is a risk. On September 25 Ollaya shipped, “Ollama for decision models”: 15 families of open models and the same endpoints as TypeSafe (/v1/systemone). In their tests winnow:e4b scored 0.722 on typed decisions, versus 0.738 for hosted Jev, at 89ms on an RTX 4090.
• The moat. Arcturus argue that OpenAI have been using their LLMs as implicit classifiers for years, and that TypeSafe’s real moat is the training data. If OpenAI reproduce the training, they can build this capability into their own models and agents, and Jev won’t be able to compete with that.

My take: I don’t buy 238x as the number that should matter to you. For most teams the routing bill isn’t the problem. The problem is the tool that got invented at 3 a.m., and what I take from Jev is the shape: an answer that’s closed in advance, with a number you can put a threshold on.

What to try this week

• Open a production agent trace and count how many steps are a choice from a list. Beam claim it’s most of them. Check whether that’s true for you.
• Pick one step, say ticket routing, and hand-label 200 examples.
• Run decide.py or an Ollaya model on them. Measure accuracy, and split the probabilities into 0.1-wide buckets. In each bucket, the hit rate should be close to the probability. That’s the ECE Ollaya publish for every model.
• Set the threshold from the data: what share falls to escalate, and what the accuracy is above it.
• Only then ask for Jev early access and run the same 200 examples.

If 0.9 isn’t right 90% of the time for you, you don’t have a decision model. You have a pretty softmax.