Last updated: October 7, 2026
TypeSafe Jev is a System One decision model you drop into an agent harness to answer closed questions with probabilities, so your code can route, gate, compact, and verify without asking a chat model to write a paragraph about it.
TypeSafe launched Jev on September 15, 2026. Founder Diogo Almeida helped build the RLHF stack behind InstructGPT and ChatGPT, then shipped a flagship model that cannot write a sentence. FOMA covered the launch the week it shipped. This page is not another "what is Jev" explainer. You already have (or are building) an agent loop. The question is what Jev does inside that loop.
What can you do with Jev in an agent harness?
An agent harness is the boring machinery around the LLM: ingress, tools, memory, safety, egress. Most of those steps are judgments with a small answer space. Chat models keep answering them with essays. Jev answers them with typed decisions your code can threshold.
Per the System One docs and API, every question is one of three primitives:
Choice: pick one option from a set you define (up to 255). You get the winner, a full probability distribution, and confidence.
Score: rate against ordered levels (at least two, up to 10). You get a probability-weighted score that can land between levels, plus confidence.
Noul: yes/no. You get a probability from 0 to 1 that the answer is yes.
You send a state (string, JSON, or text array) plus a map of questions to POST https://api.typesafe.ai/v1/systemone. Sampling is parallel across questions, not one token at a time. TypeSafe's launch post quotes end-to-end latency of 70ms to 500ms, input at $0.042 per million tokens, and free output. The models page for Jev 1.13 (jev-1.13.0) lists a 64k token request budget and 32k for state plus the longest question. Text only. No images yet.
That shape is the product: unstructured agent state in, typed probabilistic decisions out. Your generative model still writes, plans, and calls tools. Jev owns the fuzzy branch.
Where does Jev sit in the agent loop?
Think of the harness as a chain of gates. Each gate is a closed question. Here is how builders actually wire it, mapped to the primitives:
Ingress / model router → Choice. Commit the request to Fast vs Deep LLM (or cheap vs expensive, local vs frontier). One call, one option set, no "let me think about which model…" essay.
Pre-execution / safety gate → Noul or Choice. Halt for human approval if the planned action looks risky (delete, spend money, leave the sandbox). Noul for a single risk check; Choice when you need auto-allow / ask-human / hard-deny.
Data ingestion / injection filter → Noul. Drop or sanitize payload text that looks like a prompt injection before it enters the context window. State is data; TypeSafe's jaggedness page is blunt that adversarial framing can move answers, so write precise criteria and test edge cases.
Runtime maintenance / context compactor → Noul. Ask whether the transcript is bloated enough to trigger a summarization sweep. If yes, your code runs the summarizer (a generative model). Jev only fires the gate.
Egress / output verifier → Score. Rate the draft against a rubric (grounded, complete, on-policy). Re-run the loop if the score fails your threshold; ship if it clears.
Those five are the lifecycle Adir keeps pointing at: router, safety, filter, compact, verify. Tool selection sits next to the router. Give Choice a list of allowed tools for this turn (search, shell, browser, none) and let probabilities drive which one your harness exposes. High confidence and a clear winner: call it. Low confidence: ask the human or fall back to a smaller tool set.
You can fan several of these into one System One request against the same state. That is the whole point of parallel sampling. A ticket-router demo in the quickstart already mixes Choice + Score + Noul on one message. An agent step does the same: route model, gate risk, pick tool, score the last output, in a single round trip.
How do you use TypeSafe Jev for agent decisions?
The quickstart is short on purpose.
Get an API key from the TypeSafe dashboard.
Call POST /v1/systemone with jev-latest or a pinned jev-1.13.0.
Put the current harness state in state: user goal, last tool result, policy snippets, transcript slice.
Ask only the closed questions your code can act on.
Branch on probability and confidence. Do not ask Jev to explain itself.
Official clients: Python typesafe-sdk and JavaScript @typesafe-ai/sdk. There is an agent skill at github.com/typesafe-ai/skills for Claude Code, Codex, and friends. Weights are not open. SDKs and skills shipped; a downloadable Jev checkpoint did not.
Keep the state thin. The jaggedness docs say accuracy falls when you dump irrelevant junk into state. Filter in code first. Keep math, counting, and date arithmetic out of the model. Do not chain Choices to fake generation. If you need a paragraph, call a real LLM.
What are other people doing with decision models?
A week after launch, FOMA noted the sequel: Jev never open-sourced, the launch video pulled 36 million views, and the internet shipped clones anyway (Laya, OpenJev, Bespoke Nimble, Kev-0.5B on a MacBook), with Braintrust wiring Jev into evals at roughly 400x cheaper scoring. The category landed even when the proprietary model stayed behind TypeSafe's API.
OpenAI later shipped a similar product shape. The Decisions API on GPT-6 Luna (POST /v1/decisions) takes shared input plus typed questions (predicate, choice, score) and returns probabilities. FOMA flagged it around DevDay as the same idea Jev already shipped: judgment without a blank page. OpenAI's docs put Decisions at about 10x faster than the Responses API, with pricing at $0.10 per million input tokens and no output charge on that endpoint. Decisions also accepts images. Jev, as of the models page, is text only. Same category. Different vendor, price, and modality.
TypeSafe's own workflow evals claim 193.6x faster / 444.6x cheaper against an average of GPT-6 Astra and Claude Fable 5.1, with bias caveats attached. Treat those as vendor receipts, not an independent bake-off. The useful signal for harness builders is the shape: many independent questions, fine-grained probabilities, discrete branching in your code.
When should you not use TypeSafe Jev?
Skip it when the answer space is open.
Generation: drafts, emails, code patches, chain-of-thought explanations. Jev is not trained to write. The jaggedness page says forcing generation by chaining choices is slow and bad.
Open-ended planning: inventing a multi-step plan you have not enumerated. Choice needs the options in advance. If you do not know the option set, you need a generative model (or a planner that proposes options, then Jev ranks them).
Exact math, counting, date ordering: keep that in code. Jev is not a calculator.
Image / audio / video judgments: not supported on Jev 1.13. Use OpenAI Decisions or a vision model for that lane.
Huge unfiltered transcripts: filter first. Context rot is real on this model class.
Use it when the call sits inside software and the answer is closed: classify, route, score, guardrail, re-rank, verify a citation against a source, gate a tool call, decide whether to compact. Pair it with a real LLM. Do not ask it to write your emails.
FOMA's take: the agent race keeps shipping bigger chat models into loops that mostly need a traffic light. Jev is the rare launch that makes every classify/route/score hop feel like infrastructure. If you already built the harness, that is the missing piece. What is FOMA.