TypeSafe AI Unveils Jev: A System 1 Model Delivering Typed, Calibrated Decisions Rather Than Plain Text

If you build software that needs to make judgment calls — routing tickets, scoring content, approving tool calls — Jev from TypeSafe AI is worth your attention. It's a new kind of model designed to answer structured questions with typed, probability-backed answers that your code can act on directly. This article explains what Jev is, how its API works, what it costs, and which claims you should treat with caution.

The ChatGPT moment in 2022 taught AI to converse with people. One of the people behind that breakthrough now believes the next shift is AI that converses with software rather than humans. That's the bet behind TypeSafe AI's new release, Jev. It's built on transformer technology, but it isn't a large language model. It produces no text. Instead, you send it a state plus typed questions, and it replies with typed decisions complete with probabilities your code can branch on.

Is it available? Yes — as a hosted API in early access, gated behind a waitlist. TypeSafe has not released model weights, revealed a parameter count, or offered a self-hosting option.

What Is a "System One" Model?

The name nods to Daniel Kahneman's distinction between quick intuition and deliberate reasoning. The TypeSafe team argues that RLHF tuned today's models to satisfy human preferences. That produced chatbots — along with overconfidence and mode collapse. Those flaws are exactly why humans still need to stay in the loop.

Jev runs on a different stack entirely: a new (undisclosed) architecture, a parallel sampler, and a training method called Reinforcement Learning for Calibrated Decisions, or RLCD.

How the Jev API Works

A single endpoint handles all requests: `POST https://api.typesafe.ai/v1/systemone`. The request body includes a `state`, a `model`, and a map of questions. The documentation defines three question types:

| Type | What it does | Returns |
|------|-------------|---------|
| Choice | Pick one option from a list | choice, probabilities, confidence |
| Score | Rate against ordered levels | score, probabilities, confidence |
| Noul | Is this statement true? | noul, a probability from 0 to 1 |

Questions run in parallel and independently against the same state. According to TypeSafe, adding questions barely affects response time. A single Choice question supports up to 255 options.

Here's a quick Python example:

```python
from typesafe_sdk import Choice, Noul, TypeSafeClient

client = TypeSafeClient() # reads TYPESAFE_API_KEY
r = client.system_one(
state=ticket,
questions={
"department": Choice(
instructions="Which team should handle this",
criteria={"billing": "Payment issues", "technical": "Bugs"},
),
"is_urgent": Noul(instructions="The message conveys urgency"),
},
)
print(r.answers["department"].choice, r.answers["is_urgent"].noul)
```

Install the SDK with `pip install typesafe-sdk` (Python 3.10 or later). A JavaScript SDK is available as `@typesafe-ai/sdk`. The quickstart also documents cURL usage and an agent skill for Claude Code.

Confidence Is the Product

Every Choice and Score answer includes a confidence value between 0 and 1, derived from the shape of the probability distribution. In the docs' example, "billing" wins with 0.84 — but confidence sits at only 0.596, because "technical" still holds 0.159.

The documentation recommends three paths: act automatically on high confidence, review the middle band, and route low-confidence cases to a human. Thresholds should be set according to how costly a wrong decision would be.

Pricing, Speed, and the Benchmark Fine Print

Jev costs $42 per billion input tokens. TypeSafe pegs existing LLMs at $0.20 to $10 per 1M input tokens. In its recorded demo, Jev finished in 0.114 seconds for $0.000081, while GPT-5.6 Terra took 8.566 seconds and cost $0.013880.

The team claims Jev is 193.6x faster and 444.6x cheaper. These numbers come from TypeSafe's own workflow evals, so a few caveats apply:

• The reference answers are an average of GPT-6 Astra and Fable 5.1.
• TypeSafe's own capabilities team wrote the test workflows.
• The company expects real-world gains to land toward the high end.
• TypeSafe acknowledges it cannot prove the price isn't subsidized.
• "Zero hallucinations" refers only to guaranteed schema matching — the 0% figure is not empirical, and answers can still be wrong.

What Developers Are Building with Jev

Community projects appeared within days of launch. A few standouts:

• Command safety: Vercel CEO Guillermo Rauch reported Jev up to 18x faster than GPT Luna at p95, and more accurate — though his post noted the fx reviewer still ran on Luna. Engineer Pranit Sharma shared the benchmark.
• Email triage: Bryo AI CTO Nikhil Mudholkar found Gemini slightly more accurate, but 10 to 20 times more expensive.
• Browser agents: Browser Use's jev-ultrafast ran a Zürich-to-London Google Flights search in 7.1 seconds.
• Phone agents: Droidrun's mobile-jev drove Uber on a real Android phone, completing 9 actions in about 21 seconds — though no booking was made.
• Video scoring: jevmeter scores every sentence of a debate for roughly $0.05.
• Live typing: Steve Krouse's Typewriter updates 16 judgments in real time as you type.
• Games: Jev completed StarCraft's first combat mission and powers the guards in heist-one.
• Agent guardrails: jev-guard rates each tool call as deny, ask, or allow.
• Data and homes: pg-jev adds natural-language filters to Postgres; HA-Jev turns answers into Home Assistant entities.

Key Takeaways

• Jev outputs typed decisions with probabilities, not strings.
• Its three primitives (Choice, Score, Noul) can share a single request.
• Input costs $0.042 per 1M tokens; output tokens are free.
• TypeSafe reports 70ms to 500ms end-to-end response times.
• The headline benchmarks are vendor-run, so test on your own data before committing.

If your product needs fast, cheap, structured judgments with honest uncertainty signals, Jev's early-access API is one of the more interesting options to evaluate. Just verify its speed and cost claims against your own workloads first.

Meta description: Jev by TypeSafe AI returns typed decisions with probabilities instead of text. Learn how its API works, what it costs, and which benchmark claims need scrutiny.

Tags: Jev, TypeSafe AI, AI API, RLCD, developer tools

Featured image: Abstract, friendly illustration of a glowing decision tree branching into probability nodes, with no people or logos.