TypeSafe's Jev: An AI Model That Answers in Types, Not Text

Diogo Almeida co-wrote InstructGPT, the human-feedback training recipe that turned GPT-3 into something you could chat with. On 15 September 2026 his startup, TypeSafe AI, released a model that can't write a sentence.

It's called Jev. You hand it some state (a support ticket, a security alert, a game screen described as JSON) plus a list of typed questions. It hands back choices, scores and probabilities. There's no prose, no JSON string to parse, and no retry loop for when the model forgets a closing brace. Input costs $0.042 per million tokens. Output is free.

The launch pitch is loud: "20-200x faster," "40-400x cheaper," and a model that "can't hallucinate." The launch materials are also unusually honest about where those numbers come from, which makes this one worth reading closely. Here's what shipped, what TypeSafe's own evals show once you open the chart, and where a model like this belongs in a real system.

What TypeSafe shipped

From the launch post and the docs:

• Jev is the first of what TypeSafe calls System One models, named after the fast, gut-feel mode of thinking in Daniel Kahneman's Thinking, Fast and Slow.
• It's trained with a method TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD). RLHF rewards answers people prefer. RLCD is meant to reward probabilities that match how often an answer turns out right.
• Input is $0.042 per million tokens, or $42 per billion. Output is free, "too cheap to meter" in TypeSafe's words.
• TypeSafe reports end-to-end responses in 70 to 500 ms.
• Access is API-only, through a waitlist, with a Python SDK (typesafe-sdk) and a TypeScript one (@typesafe-ai/sdk).
• There are no weights and no paper. As RuntimeWire notes, the release describes RLCD at a high level, not in enough detail for anyone to reproduce it.

The Register reports the company has $40 million in funding. Almeida's co-founders are Sasha Sheng, formerly a research engineer at Meta and FAIR, and Erik Gafni, who founded the genomics AI startup Ravel.

One small correction to launch-day framing. Almeida's X post opens with "After co-inventing ChatGPT." The paper trail is co-authorship of the 2022 InstructGPT paper and a spot in OpenAI's ChatGPT credits. That's a strong résumé for an argument about what RLHF gets wrong. It was also a big team.

One call, three kinds of question

Jev has exactly three question types, which the docs call primitives.

You can mix all three in a single request, and every question is judged against the same state. Here's the support-ticket example from the quick start, with a few lines of routing logic added at the end:

from typesafe_sdk import Choice, Noul, TypeSafeClient
 
client = TypeSafeClient()  # reads TYPESAFE_API_KEY, uses jev-latest
 
ticket = (
    "Hi, I've been trying to connect my Stripe account for 3 days "
    "and it keeps failing. I'm losing sales. Please help ASAP."
)
 
response = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={
                "billing": "Payment or subscription issues",
                "technical": "Bugs or integration problems",
                "sales": "Pricing or account questions",
            },
        ),
        "is_urgent": Noul(
            instructions="The message conveys urgency or time-sensitivity",
        ),
    },
)
 
dept = response.answers["department"]
urgent = response.answers["is_urgent"].noul
 
if dept.confidence < 0.5:
    print("send to a person")
elif urgent > 0.9:
    print(f"page the {dept.choice} on-call")
else:
    print(f"queue for {dept.choice}")

For the Stripe ticket, the docs show department coming back like this:

{
  "type": "choice",
  "choice": "technical",
  "probabilities": { "billing": 0.159, "technical": 0.84, "sales": 0.001 },
  "confidence": 0.596
}

and is_urgent at 0.999. So the script above pages the technical on-call.

Look at the two numbers on department. Technical gets 84%, but confidence is only 0.596, because billing still holds 16%. Confidence is a single number computed from how spread out the probabilities are (Noul answers don't get one). That second number is what the whole design rests on. TypeSafe's argument is that chat models asked for a confidence score "tend to be overconfident and inconsistent," and a system that can't tell you when it's unsure can't be left to run alone.

Why it's fast: Jev gives up strings

An LLM writes its answer one token at a time, and each token waits for the one before it. Ask for a JSON object with five fields and you pay, in time and money, for every brace and quote mark. Then your code parses the output, validates it, and retries when it's broken. We built exactly that loop in getting structured JSON out of an LLM.

Jev removes the middle of that pipeline. The possible answers are declared before the model runs, so there's nothing to write out. TypeSafe says all questions are scored in parallel in one pass, which is why the docs claim adding questions "barely changes the response time."

The price of that speed is everything strings were good for. Jev can't explain itself, write a reply, or produce code. A single Choice tops out at 255 options.

What TypeSafe's evals actually show

The homepage headline is "193.6x Faster, 444.6x Cheaper." The launch post itself says those figures are "on the higher end of real world gains." The more useful data sits on the workflow evals site, where TypeSafe ran four business workflows through Jev and a set of LLMs: security alert triage, agent trace review, invoice processing and customer service.

Averaged across all four, per case:

Jev isn't the most accurate model on its own chart. Sol and Opus 5 beat it by five or six points. What Jev does is tie GPT-5.6 Terra and Claude Sonnet 5 for a tiny fraction of the cost. Against Terra that works out to roughly 75x cheaper and 25x faster. Still a huge gap, and a much smaller one than 444x.

The gap also swings a lot by task. On customer service Jev scored 76.0%, ahead of Opus 5 at 72.4% and close to Sol at 78.3%. On invoice processing it scored 61.8% while Sol hit 79.1%. If the decision is whether to pay a vendor, seventeen points matters far more than the inference bill.

And "agreement" doesn't mean "correct." The reference answers are the average of GPT-6 Astra and Claude Fable 5.1 at high reasoning, not labels checked by people. TypeSafe staff built the workflows. Latency was measured "from our laptops on the West Coast." On pricing, TypeSafe writes that it "can't prove it isn't subsidized."

Every one of those caveats comes from TypeSafe's own launch post, which is more than most model launches offer. When we covered GPT-6 Astra, the equivalent fine print had to be dug out of a system card. The first outside hands-on so far, from Every's head of evals Mike Taylor, had Jev judge everything he'd written in 0.7 seconds. Taylor still wrote that how well it does the job "is still an open question."

Run the Jevons math at your own volume

The name is a nod to William Stanley Jevons. In The Coal Question (1865) he pointed out that more efficient steam engines made Britain burn more coal overall. "It is wholly a confusion of ideas to suppose that the economical use of fuel is equivalent to a diminished consumption. The very contrary is the truth."

TypeSafe's version, from its FAQ: "Every order of magnitude drop in the cost of intelligence unlocks orders of magnitude more use cases." The quickest way to feel that is to plug in a volume you'd actually have. Change cases_per_day and run it:

At 50,000 cases a day, Terra runs about $45,600 a month and Jev about $600. At the first price you check the tickets that matter. At the second you can afford to check every tool call your agent makes, every log line, every row in the warehouse. That's the bet in the name, and it's the same curve we tracked in the 2026 LLM price war. TypeSafe's Doom demo puts a number on it: ten decisions a second comes to about $7 an hour.

The Register adds a fair caveat. The bet assumes demand for machine judgment is as open-ended as demand for energy, and that isn't settled yet.

"Can't hallucinate" means something narrower than it sounds

Read the claim precisely and it holds up. Jev can't return an option you didn't declare, invent a field, or hand your code a string where it expected a float. The output space is fixed before the model runs, so a type error really is off the table.

What it can do is pick the wrong option. The docs say so directly. Calibration "is measured across groups of predictions," and it "does not guarantee that an individual answer is correct."

That points at the easiest mistake to make with a typed model. When the right answer isn't in your list, the probability still has to land somewhere.

Where I'd use it, and where I wouldn't

Once it's out of early access, I'd try Jev anywhere an LLM is currently doing classification at volume:

• Ticket and alert triage, where a wrong route costs a few minutes.
• Checks wrapped around an agent. Did this tool call match what the user asked for? Is this trace going in circles? At these prices you can ask on every step.
• Tagging millions of rows of text you would never send to Opus.
• Anything user-facing where 10 seconds breaks the feature and 400 ms doesn't.

I wouldn't use it where a decision needs a reason attached. Jev gives you 0.84, not an explanation, so audits, appeals and "why was my claim denied" all need something else. I also wouldn't let it approve payments on its own after a 61.8% invoice score.

The setup that makes sense is a cascade, which is also what TypeSafe's docs push. Jev answers first. Code acts when confidence is high, and everything else moves up a level.

Set those thresholds per action, not once for the whole system. The docs' own example sends anything under 0.5 to a person and asks for 0.9 before moving money, while showing someone a balance screen needs far less.

What to do this week

If you run a high-volume classification path, join the waitlist and build that labelled test set now. Then you can judge Jev on your own data the day you get a key.

Whether or not you ever call Jev, copy the architecture. Break the one big "handle this ticket" prompt into small typed questions, keep the policy in code, and gate every action on confidence. TypeSafe's chart shows every model getting better when you do that.

And give every list of options a way out.

Sources: TypeSafe's launch post, docs and workflow evals, Diogo Almeida's launch post on X, The Register for funding and pricing comparisons, RuntimeWire on the founders and missing paper, Every for the first hands-on, and Anthony Maio's skeptical read on calibration and schema design.