Jev is a new model from TypeSafe AI, and it doesn’t write code or prose. You give it a piece of program state, declare the questions you need answered, and it returns typed answers with calibrated probabilities. TypeSafe calls it a System One Model. It landed on Vercel AI Gateway on September 16, 2026, which is why it’s suddenly in every feed.
For a team running several coding agents, the interesting part isn’t the model. It’s where a decision model sits in the stack. Your agents generate the work. The hard problem, as we’ve argued in why human review is the bottleneck, is deciding what to do with the output of five runs at once: which needs a human, which can merge, which is stuck. Jev is built for exactly that kind of question. This post explains what it is, what it’s not, and where it fits above your agents.
What Jev is
A System One Model is a model that returns decisions instead of text. TypeSafe’s launch post puts it as “unstructured state in, typed probabilistic decisions out.” Three properties matter.
The output shape is declared before the call. You define each question’s type up front, and the model can only answer inside it. There is no text to parse and no schema mismatch to catch.
Every answer carries a probability. A yes/no question returns 0.97, not true. A choice returns the full distribution across the options. TypeSafe trained it with a method it calls Reinforcement Learning for Calibrated Decisions, and the claim is that a higher confidence means a higher accuracy, so you can set a threshold: automate above it, send the rest to a person.
All questions are answered in parallel, in one request. That is why TypeSafe quotes end-to-end times of 70ms to 500ms. Those are the vendor’s numbers, not an independent benchmark, but the architecture explains them: nothing is generated token by token.
The three question types
Jev’s API exposes three primitives. Each is a JSON object under a key you choose, all evaluated against the same state.
Noul is a yes/no probability. {"type": "noul", "instructions": "Does this run need a human before merge?"} returns {"noul": 0.91}. You threshold it in code.
Choice picks one option from a named set of up to 255. You pass criteria mapping option names to descriptions, and the answer carries the pick, the full distribution, and a confidence figure.
Score places the state on an ordered rubric of 2 to 10 levels. The answer is a probability-weighted position, so a bug can score 1.3 between “workaround exists” and “blocking”.
Through the Vercel AI SDK the yes/no type is called boolean and the field is probability; against TypeSafe’s own endpoint it’s noul. Same idea, different key.
Where a decision model fits above your agents
Here is the mental model we use. Models produce tokens. Coding agents (Claude Code, Codex, Gemini CLI, OpenCode) turn tokens into changes on a Computer. The management layer decides who works on what and what happens to the result. Jev belongs to that top layer, not the middle one. It is not an agent and it cannot edit a file. It is a fast, typed answer to a management question.
Three questions come up on every board that runs agents in parallel, and each maps to a Jev primitive.
Which Assignee should take this Task? A Choice over your Agents, with criteria describing what each is good at. The state is the Task title, description, and linked repository. This is the triage step we described in AI backlog management and triage, done as one 100ms call instead of a person reading forty tickets.
Does this run need a human before it merges? A Noul over the run’s diff summary, test results, and touched paths. Above 0.85, hold it for review; below 0.15, let the approval gate pass it through; in between, flag it. The point is not to remove the reviewer. It is to make sure the reviewer’s afternoon goes to the runs that need it.
How risky is this change? A Score from “cosmetic” to “touches auth or payments,” applied to the same state. That number sorts the review queue, which is most of what tracking work completed by coding agents is for.
The community got here first. In the week after launch, developers shipped a staged code-review workflow built on Jev, a Claude Code plugin that replaces compaction summaries with Jev decisions about which tool calls to keep, and a “software factory foreman” that routes work with it. Every one of them is a decision layer above an agent, which is the pattern that matters.
An honest decision rule
Use Jev when the question has a fixed set of answers and you need a probability with it: routing, severity, “needs review,” “is stuck,” “is this PR description honest.” Those are the questions a board asks a hundred times a day.
Don’t use Jev when the question needs judgment that isn’t in the state. “Is this the right architecture” is not a Choice. “Will the customer accept this” is not a Score. A probability on those is a number that looks like a decision. Keep a person, or a language model that can explain its reasoning, on that side of the line.
And do not let a probability replace the review gate. A 0.96 on “safe to merge” is a strong signal to put the run at the top of a human’s queue, not a reason to skip the human. The boundary Sharkly draws is that automation stops where team judgment is required, and a decision model doesn’t move that line. It makes the queue on the human side of it shorter and better ordered.
Calling it
Direct: POST https://api.typesafe.ai/v1/systemone with a Bearer key from console.typesafe.ai, model jev-latest (currently jev-1.13.0). Through Vercel AI Gateway: model typesafe-ai/jev via experimental_evaluate in AI SDK 7, and note the Gateway docs say evaluation is available through the AI SDK only, not the OpenAI-compatible endpoints.
A triage call that answers all three questions at once:
{
"model": "jev-latest",
"state": { "task": "Fix double charge on retry", "diff_summary": "touches billing/retry.ts, adds idempotency key", "tests": "42 passed" },
"questions": {
"assignee": { "type": "choice", "instructions": "Which Agent should take this?",
"criteria": { "codex": "backend and payments", "claude_code": "refactors and tests", "gemini_cli": "frontend" } },
"needs_review": { "type": "noul", "instructions": "Does this change need a human before merge?" },
"risk": { "type": "score", "instructions": "How risky is this change?",
"criteria": ["cosmetic", "logic change with tests", "touches auth, billing, or data"] }
}
}
Pricing per TypeSafe’s models page: $0.042 per million input tokens, output not charged, 64k tokens per request with 32k for the state, text only. At that price the triage call above costs a fraction of a cent, which is what makes running it on every Task and every run plausible.
How this relates to Sharkly
Sharkly does not call Jev for you, and it isn’t a decision model. It’s the shared task, Computer, context, and review layer around the agents you already run. What a model like Jev gives you is a cheap, typed way to make the routing and review decisions that layer surfaces: which Assignee, which queue, how urgent. Wire it into an Automation that creates a Task and picks the Agent, or run it on a completed run’s output before the result reaches a reviewer. Either way the decision lands somewhere a person can see it, which is the part that has to stay true whatever the probability says.
If you’re running more than one agent and the review queue is the thing that hurts, getting started with Sharkly covers the board, Computers, and review flow that a decision model plugs into.
FAQ
Is Jev a coding agent?
No. It can’t generate code or edit a file. It answers declared questions about state you give it, with a probability. Agents produce the work; Jev helps decide what to do with it.
Can it replace code review?
No, and it shouldn’t. It can rank the review queue and pull the clear cases out of it. The decision to merge stays with a person, which is the boundary this whole workflow depends on.
What does calibrated mean?
If Jev says 0.9, it should be right about 90% of the time on that kind of question. Test that on your own runs before trusting a threshold: a few dozen labeled diffs is enough to see whether the number means what it says.
Do I need Vercel to use it?
No. The direct API works with a Bearer key. The Gateway is a convenience if you’re already on the AI SDK.