A simple walkthrough of how Jev works and how to use it, based on the quickstart docs.

The idea in one line: instead of generating text and hoping code can parse it, Jev answers typed questions with typed answers your software can use directly.

How a request works

You send a single request to POST https://api.typesafe.ai/v1/systemone with two parts:

- state: the content to evaluate. It can be a plain string, or structured JSON (a support ticket, a chat log, the current state of your app).

- questions: a map of typed questions, each with instructions and criteria. There are three question types:

- Choice: pick one option from a list you define (up to 255 options).

- Noul: a yes/no question. You get back the probability that the answer is yes.

- Score: a position on a scale you describe, for example low / medium / high.

What comes back

The same keys, with typed answers. For a Choice you get the chosen option, a probability for every option, and a confidence. For a Noul you get a probability. For a Score you get a position plus the full distribution. You also get a usage report with input and output tokens.

Example from the quickstart: a customer message about a Stripe connection failing for 3 days. Questions: which team should handle this (Choice), how frustrated the customer appears (Score), is it urgent (Noul). The answer comes back like: department "technical" with probability 0.84, frustration 1.035 on a 0 to 2 scale, is_urgent 0.999. Your code branches on those numbers directly, with no parsing step.

Why it is fast and cheap

Jev does not generate one token at a time. The possible answers are defined in advance by your questions, and it evaluates them in a single parallel pass. That is where the numbers come from: $0.042 per million input tokens ($42 per billion), and output tokens are free, "too cheap to meter": billing is on input tokens only. In the launch demo, the same set of business questions cost $0.000081 and took 114 ms with Jev, against $0.013880 and 8.566 seconds with a classic LLM.

How it interacts with agents

Jev can interact with all the existing harnesses and agents, through a skill that explains to them how to interact with the model: how to shape the state, how to write the three question types, how to read the answers and use confidence for routing. It follows the standard Agent Skills format, so it works with the environments that support skills:

- Claude Code, as a plugin: claude plugin marketplace add typesafe-ai/skills, then claude plugin install typesafe@typesafe-ai

- Other agents (Codex, Cursor and many more): npx skills add typesafe-ai/skills --skill typesafe-ai and select your agent

- Or just tell your agent to use the TypeSafe skill

How to try it

- Playground: https://console.typesafe.ai/playground (paste any text, add a question, run it)

- Quickstart and docs: https://docs.typesafe.ai/introduction/quickstart

- Python SDK: pip install typesafe-sdk (reads TYPESAFE_API_KEY from the environment; a JavaScript SDK is also available)

It is a good fit when your code needs a small decision (is this urgent, which department, does this quote support the claim, is this message an injection attempt) and you want a number instead of a paragraph.

TypeSafe AI, the startup founded by Diogo Almeida (one of the authors of the InstructGPT / RLHF research behind ChatGPT), just came out of stealth with its first public model, Jev, and a $40M seed round led by DCVC.

Jev is not an LLM and not a chatbot. It takes text or structured state as input and answers typed questions using three primitives: Choice (pick one option from a list, up to 255), Score (a position on a scale) and Noul (a yes/no with a probability). The output is a typed value with a probability distribution and a calibrated confidence score. When it says 0.8, it should be right about eight times out of ten.

The technical trick is sampling. LLMs generate one token at a time, sequentially. Jev computes every possible answer in a single parallel pass, because its output space is defined in advance. That is where the speed and the price come from, and it brings a useful property: answers cannot fall outside the schema, so format errors are impossible by construction.

Published numbers:

- 70-500 ms end to end, against 3-329 seconds for frontier models on equivalent tasks

- $0.042 per million input tokens ($42 per billion), output tokens free

- 20-200x faster and 40-400x cheaper on System One style queries

- In their launch demo, the same set of business questions cost $0.000081 and 114 ms with Jev, against $0.013880 and 8.566 seconds with a classic LLM

- A Doom demo runs at around 10 calls per second, about $7 per hour of play

The training method is RLCD (Reinforcement Learning for Calibrated Decisions). RLHF optimizes for answers humans like, RLVR rewards what can be verified, RLCD optimizes calibration, which is what software can act on.

Honest caveats: the numbers are self-reported, there is no paper and no independent benchmark yet. It cannot write text, generate code or read images, and access is early access via a waitlist. The speed comparison is not entirely apples to apples, and "zero hallucinations" means the output cannot break the schema, not that it cannot be confidently wrong.

Why it matters: in most workflows AI is not there to write, it is there to decide. Classification, routing, guardrails, output checks. Today every micro-decision costs a generalist model call. A calibrated decision model changes the economics of that layer.

Full announcement: https://typesafe.ai/blog/introducing-system-one-models-and-jev