TypeSafe AI's Jev answers your code with typed decisions and a confidence score, in milliseconds, for $42 per billion tokens. What it is, the code, and the fine print.
· 5 min read
TypeSafe AI is a San Francisco AI lab that released Jev, which it calls the first public "System One Model". Instead of writing text like a chatbot, Jev answers questions your code asks with a typed decision and a confidence score, in 70 to 500 milliseconds, for $42 per billion input tokens. It's built for the small decisions inside software: route this message, is it urgent, is that AI answer correct.
I read the launch post, the docs and the home page. Jev is invite-only for now, so I haven't run it myself yet: everything below is what TypeSafe publishes, with their own caveats included.
The name comes from the idea of fast, intuitive thinking ("System One") versus slow, deliberate reasoning. In the launch post, founder Diogo Almeida, who worked at OpenAI on the methods behind ChatGPT, describes it as "a new class of frontier models built to make fast, structured decisions that software can use directly."
His one-line summary: "Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out."
| Chat models (LLMs) | System One + Jev |
|---|
A San Francisco AI lab, founded by Diogo Almeida, that builds 'System One Models': AI models that give software typed decisions with confidence scores instead of generated text. Its first public model is Jev, launched on 15 September 2026.
No. Jev doesn't generate text. You send it text and questions with predefined answer types (Choice, Score, Noul) and it returns the answers with probabilities and a confidence.
TypeSafe lists $0.042 per million input tokens ($42 per billion) with output free. The company says it can't yet prove the price isn't subsidized and expects it to go down.
Yes. 'Zero hallucinations' refers to type safety: the answer is always one of the allowed values. The answer itself can still be wrong, which is what the confidence score is for.
Written by
Full Stack Developer & Web Marketer · Marrakech, Morocco
I build modern, scalable web applications end to end, from frontend to backend, with a focus on performance, clean code and user experience.
| Output | Free text, to parse and validate | Typed values defined in advance |
| Confidence | Often overconfident, even when asked | A confidence with every answer |
| Speed (their figures) | 3 to 329 seconds end to end | 70 to 500 ms end to end |
| Input price | $0.20 to $10 per million tokens | $0.042 per million tokens |
| Output price | About 5× the input price | Free ("too cheap to meter") |
| Trained with | RLHF / RLVR | RLCD: Reinforcement Learning for Calibrated Decisions |
You send a piece of text (the "state") and a set of questions. Each question has a type that fixes what the answer can be:
This is the Python example from the quickstart (install with pip install typesafe-sdk, key from the TypeSafe console):
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
client = TypeSafeClient()
ticket = "Hi, I've been trying to connect my Stripe account for 3 days and the integration 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",
},
),
"frustration": Score(
instructions="How frustrated the customer appears",
criteria=[
"Calm, just stating facts",
"Frustrated but civil",
"Very angry, strong language",
],
),
"is_urgent": Noul(
instructions="The message conveys urgency or time-sensitivity",
),
},
)
print(response.answers["department"].choice) # "technical"
print(response.answers["frustration"].score) # 1.0
print(response.answers["is_urgent"].noul) # 1.0
A chat model that's right 95% of the time is hard to automate with if it doesn't tell you when it's in the other 5%. TypeSafe's pitch is that Jev's confidence is calibrated: "higher confidence means higher accuracy". So your code, not the model, draws the line: above your threshold it acts on its own, below it a person takes a look.
The home page headline is "193.6x Faster, 444.6x Cheaper", with a side-by-side run: $0.000081 and 0.114 s for Jev against $0.013880 and 8.566 s for an LLM. It also says Jev's input price is "238x Lower" than Claude Fable 5.1's (Fable is $10 per million input tokens; Jev $0.042).
To TypeSafe's credit, the launch post spells out the limits of these claims:
The launch post lists "smart if-statements" inside workflows, map-reducing over big data, real-time features, and checking other AI output ("score, judge, verify, guardrail"). Translated to the projects I build:
For anything that needs writing (a reply, a summary, code), you still need a chat model: Jev "gives up string generation" by design. The interesting setup is both together, with Jev making the fast yes/no and routing decisions around the slower model.
Jev launched in early access, and the home page now says "TypeSafe is invite-only again", with a waitlist. Existing users can log in to the console and the Playground. The docs, including a guide for coding agents, are public at docs.typesafe.ai.
I'll test it on a real routing workflow once I get access and write up the results. Meanwhile, if you want AI inside your platform, like a CRM that sorts its own messages or a support inbox that knows what's urgent, tell me about your project. More AI notes: September's developer news and what WebMCP is.