Jev トピック
Jev(TypeSafe AI の System One モデル)についてよく聞かれることへの、短く的を絞った答え。トピックを選んで、playground でライブに試してみてください。
Made with Jev
Everything here is made with Jev — the same typed, calibrated decision that returns one key, a probability for every option, and a confidence score in a single round trip. Open any of them, then build your own.
Using Jev as a judge
LLM-as-a-judge usually means prompting a big model, parsing its reply, and trusting a score it made up. Jev as a judge returns exactly one of your grades, a calibrated probability for each, and a confidence value — in one round trip, with nothing to parse.
Using Jev from TypeScript
TypeSafe AI means the type safety reaches all the way into your TypeScript. You define the options, and Jev returns one of them — never free text, never an invalid label — so the response lines up with your types instead of fighting them.
How to use Jev for computer use
Here's how to wire Jev into a computer-use agent so it vets every action before it clicks: one call returns a typed 'safe?', the action type, and a calibrated confidence — and your loop acts on it in about 70–500ms.
Jev MCP server
The Jev MCP server drops a typed decision tool into any Model Context Protocol client. Instead of the client guessing and parsing, it calls one tool and gets back a locked answer — one of your options, calibrated probabilities, and confidence.
Jev and OpenRouter
OpenRouter is a gateway that forwards your prompt to whichever LLM you name. Jev is a different layer: a typed decision model that picks one option and returns it with calibrated confidence. They solve different problems — and Jev is a great way to decide which OpenRouter model to call.
Jev and Bifrost
Bifrost is an open-source LLM gateway by Maxim AI: one OpenAI-compatible API in front of many providers. Jev is a different layer — a typed decision model that picks one option and returns it with calibrated confidence. They compose cleanly: let Jev decide which model a request deserves, then let Bifrost forward the prompt to it.
Sign up for Jev
Signing up for Jev takes about a minute: create an account, generate a jv_live_ key, and make your first typed decision. You can try it free in the browser before you sign up at all.
Can Jev write a poem?
Short answer: no. Jev doesn't write poems — or essays, code, or any prose. It's TypeSafe AI's System One model, which returns a typed decision, not text. Here's what it does instead, and how you'd actually put Jev to work if a poem is in the picture.
Jev on AWS Bedrock
If you're searching for Jev in the Amazon Bedrock model catalog, the short answer is: it isn't there as a native foundation model. Jev is TypeSafe AI's System One decision model — it doesn't generate a chat completion, it returns a typed answer (one of your options, a probability, a confidence) in a single parallel pass. That doesn't fit Bedrock's InvokeModel contract. But Jev composes cleanly with a Bedrock agent, and that's usually what people actually want.
Jev on Cloudflare
Unlike platforms where Jev is only reachable over plain HTTP, Cloudflare exposes it as a native partner model on Workers AI. Call env.AI.run('typesafe/jev', …) from a Worker and you get a typed answer — one of your options, a probability, a confidence — in a single parallel pass. No waitlist, no separate SDK, and the decision happens at the edge, right where your request already is.
Jev alternatives
If you're looking for a Jev alternative, you almost always want one of two things: open weights you can run yourself, or a cheaper way to make a typed decision. Here are the honest options — the open, self-hostable models in the same lineage, and the 'just use an LLM' route — with a clear read on where each wins and where hosted Jev still does.
Jevgrep
Jevgrep is what a growing set of community CLIs call themselves: semantic code search that finds code by what it does, powered by Jev. You ask in plain English — or pipe in a stack trace — and Jev scores each line or chunk, returning ranked, grep-style file:line hits with calibrated confidence. These are community projects, not TypeSafe and not us.
Jev compaction
Jev compaction is a different way to shrink a coding agent's context window: instead of asking a model to summarize the history, you ask Jev a yes/no question about each old item — keep it or drop it — and delete the ones it judges irrelevant. Nothing that stays is ever rewritten, so there's no lossy summary to corrupt your agent. The tools below are community projects, not TypeSafe and not us.
Decision APIs
A decision API is the opposite of a chatbot: you give it context and a finite set of allowed answers, and it hands back one of them — a classification, a route, an agent's next action — with a probability, in milliseconds instead of seconds. It's a small but fast-growing category, and this page explains what it is, who offers one, and how to make a decision call today.
OpenAI Decisions API
At DevDay on 29 September 2026, OpenAI announced the Decisions API: instead of a paragraph, you define a finite set of answers, send context, and get back one of them with a probability — in about 150 milliseconds. It's built on GPT-6 Luna and it's in limited preview. Here's what's confirmed, how it lines up against Jev, and how to ship a decision call today while you wait for access.
OpenAI Decisions API vs Jev
OpenAI Decisions API vs Jev is the head-to-head that appeared the moment OpenAI announced its Decisions API at DevDay 2026 — because Jev defined this category first. Both take context plus a finite answer space and return one typed answer with a probability. The difference is what's underneath, how they're calibrated, and — right now — which one you can actually call.
OpenAI Dots, and the decision underneath them
OpenAI's Dots are always-on agents that pursue your goals in the background and — per rules you set — either act on their own or pause to ask you. That act-or-ask call is a decision made thousands of times a day. Here's what Dots are, and how to give the agents you build the same gate as one fast typed call with Jev.
Jev on Ollama
If you're looking to 'ollama pull jev', the honest answer is that hosted Jev is a closed, calibrated model with its own endpoint — it isn't an Ollama model. But the thing you actually want — a typed decision model running locally — does exist: Ollaya is the 'Ollama for decision models', and it serves open Jev-like models behind a TypeSafe-compatible API.
Awesome Jev
'Awesome Jev' is what a growing shelf of community lists call their directories of things built on Jev — TypeSafe AI's System One decision model. This is our own source-backed tour: real projects worth opening, the community lists to go deeper, and the tools on this site you can try right now.
JevBench
JevBench is the shorthand for the independent benchmarks that have sprung up to rank Jev-class decision models — you hand the model some state and a bounded rubric, and it returns a typed answer with a probability for each option. Here's what the leaderboards measure, where Jev lands, and why to read the numbers carefully. These are third-party projects — not TypeSafe, and not us.
Is Jev free?
Short answer: Jev is free to try and paid to run at scale. You can make real decisions in the browser playground right now with no account and no card. Calling it from your own code needs a key and is billed per decision — but each one costs well under a cent, and output is free. And if you'd rather pay nothing, open Jev-like models are free to self-host.
Gemini 4 vs Jev
Gemini 4 vs Jev isn't really a head-to-head — they're different kinds of model. Gemini 4 is Google's new frontier generative LLM; Jev is TypeSafe AI's purpose-built decision model. You can make Gemini 4 return a structured decision, but that's not the same as a model built and calibrated for decisions. Here's the honest comparison, including the availability reality as of late 2026.
Jev vs Claude
Jev vs Claude isn't a straight head-to-head — they're built for opposite halves of the problem. Claude is Anthropic's frontier chat LLM: it generates text, reasons, writes code. Jev is TypeSafe AI's decision model: it returns a single typed, calibrated answer and nothing else. The reason people search this comparison at all is Jev's launch claim that it runs orders of magnitude faster than a frontier chat model on decision tasks. Here's what that actually means — and why the honest pattern is to use both.
Decision models
A decision model is a model built to decide, not to write. You give it state and a bounded question, and it returns one typed answer — a class, a position on a scale, or a calibrated yes/no — with a probability for each option, in a single pass. It's a distinct category from generative LLMs, and Jev is the one that defined it.
Jev examples
Here are copy-paste Jev examples for the patterns people actually use — classify, route, score, judge, and gate — each a single call to the decide endpoint that returns a typed answer you branch on. Every snippet uses the real request shape, so you can paste it, add a jv_live_ key, and run it.
What languages does Jev support?
There are two senses of 'languages' here, and the answer differs. As a programming interface, Jev works from any language — it's one HTTPS call. As a natural-language model, it reads your state in many languages, but accuracy is best in English and varies elsewhere, so you treat non-English as something to test and watch the confidence on.
The Jev paper(s)
There isn't one official 'Jev paper' from TypeSafe laying out the architecture and training in full — Jev is a commercial, closed-weight model. But a growing set of independent papers evaluate it, benchmark it, and study the ideas it's built on (System One models and RLCD). Here's what's actually published, and what's still a vendor claim.
Who is the founder of Jev?
Jev is the first model from TypeSafe AI, co-founded by Diogo Almeida — a former OpenAI researcher and one of the co-inventors of RLHF, the training method behind ChatGPT. The same research that made chat useful is why he built a model that decides instead of chats.
shipwithjev
shipwithjev is an independent, community-run directory of things people have built on Jev — TypeSafe AI's System One decision model. It's not run by TypeSafe or by us: it's a hand-sorted catalog at shipwithjev.com, where each build links to the X post, repo or site behind it, and many carry the cost and latency their author reported. Here's what's inside, and how to run the same kind of Jev decision yourself.
Jev on vLLM
If you're searching for 'vllm jev', the honest answer is that hosted Jev (TypeSafe) is a closed, calibrated model with its own endpoint — there are no weights to load into vLLM. But the thing you actually want — a typed decision server you run on your own GPU — exists: OpenJev is a community project that speaks the same /v1/systemone wire format as Jev and serves an open model through vLLM, so your existing Jev SDK works against it by changing one base URL.
Jev's context window
Jev's context window is the budget for one decide call: roughly 64k tokens for your state plus all the questions you ask, with a tighter ~32k ceiling on the state plus any single question. Because Jev returns a small typed value rather than generated text, there's no output side of the budget to manage — the whole window is yours for context.
Clef & Clef-flash vs Jev
Clef and Clef-flash are Cloudflare's open-weight decision models, launched on Workers AI on 1 October 2026. They do the same thing Jev does — take application state plus a schema of typed questions and return a calibrated probability for each option in a single pass, no prose. That makes them the first serious open-weight challengers in the category Jev defined. Here's the honest comparison: what they are, how Cloudflare's own numbers stack up, and when open-weight beats hosted.
Perplexity Decider vs Jev
Perplexity's Decider is pplx-decider-v1-27b — an open-weight decision model behind a new Decisions API that Perplexity launched on 1 October 2026. Like Jev, it takes application state plus typed questions and returns a calibrated probability for each option instead of free-form text. It arrived the same week as Cloudflare's Clef, making it the second serious open-weight challenger in the category Jev defined. Here's the honest comparison — specs, Perplexity's own benchmark claims, and when to pick which.
Microsoft-Decision-1 vs Jev
Microsoft-Decision-1 is the decision-scoring model Satya Nadella unveiled on 9 October 2026 — Microsoft's entry into the category Jev defined. Like Jev, it takes context plus a fixed answer space and returns a structured result with a probability per option — yes/no, a pick from a set, or a score — instead of generated text. It's the biggest vendor yet to ship a decision model, which makes this comparison worth doing honestly: not whether the category is real (Microsoft just validated it), but which model to reach for today.
What is Clef?
Clef is Cloudflare's family of open-weight decision models, launched on Workers AI on 1 October 2026. There are two: Clef, a 27B model tuned for accuracy, and Clef-flash, a 9B model tuned for speed. Both do the same job — take application state plus a schema of typed questions and return a calibrated probability for each option in a single pass, no prose. They're Cloudflare's answer to Jev, the hosted model that opened the category. Here's what Clef is, how to run it, and where it sits next to Jev.
Clef vs Jev
Clef and Jev are the two ends of the decision-model market in late 2026: Cloudflare's open-weight Clef (27B) and Clef-flash (9B) that you self-host or run on Workers AI, versus TypeSafe's hosted, RLCD-calibrated Jev that you reach through a managed API. Both take state plus typed questions and return calibrated probabilities in one pass — so this is an ops-and-calibration decision, not a 'can it decide' one. Here's the honest head-to-head.
Strands Decider 2B vs Jev
Strands Decider 2B is AWS's open-source decision model, released by Strands Labs on 1 October 2026. At ~1.9B parameters it's the small, local end of the category Jev defined: it reads text plus typed questions (yes/no, pick one, or score) and returns each answer with a confidence score in one forward pass — running on your own laptop in about 115ms. Here's the honest comparison with hosted Jev, and when a tiny local model beats a managed API.
Matilda-Jev vs Jev
Matilda-Jev is Maincode's open decision model, published on Hugging Face as matilda-jev-v1 and matilda-jev-v1.5. Like Jev, it's a decision checkpoint, not a text generator: you give it state and a typed question — a choice, a yes/no (noul), or an ordered score — and it reads out the option, in one pass. It accepts text or JSON and optional images, with a 255-option readout. Here's the honest comparison with hosted Jev, and where each fits.
pg-jev — Jev decisions in SQL
pg-jev is a community Postgres extension (by developer realZachi) that brings Jev into your database. You write a normal query with a jev() call in it — WHERE jev(people, 'the name is European') — and Postgres streams each row to a Jev decision model, asks one typed yes/no, and keeps the rows that pass. Here's how it works and how to point it at a hosted Jev endpoint with your own key.
Using Jev in a RAG pipeline
Retrieval gives you candidate chunks ranked by embedding similarity — which isn't the same as relevance. Jev is a fast, typed second pass: for each chunk it returns a calibrated 'does this actually answer the question?' in roughly 70–500ms, so you drop the near-misses before they waste context and dilute the answer.
Jev engineering for coding agents
A coding agent spends most of its tokens on small judgment calls between edits — which skill to load, whether a command is safe to run, whether the task is done. Jev engineering is the practice of pulling those bounded calls out of the big model and handing them to Jev: one typed, calibrated decision in about 70–500ms instead of another paragraph to generate and parse.
Multimodal Jev
Jev went multimodal with jev-1.14.0: a decide call can now carry images alongside your text state, and a new Box question type returns where a described target sits in a picture. It's still a decision model — you get back typed, calibrated values, not a paragraph — only now the context it judges can include what's in an image. These are opt-in preview features: you pick the model and send one header, and nothing changes for your existing text calls.
What is Microsoft-Decision-1?
Microsoft-Decision-1 is the decision-scoring model Microsoft unveiled on 9 October 2026 — its entry into the category Jev opened. Instead of writing text, it takes context plus a fixed set of answers and returns a structured result with a probability per option: a yes/no, a pick from a set, or a score. It's the biggest vendor yet to ship a decision model. Here's what it is, how it's built, where you can run it, and how it compares to Jev.
How does Jev work?
Jev works differently from a chat model. It's TypeSafe AI's System One model: you give it some state and a set of typed questions, and it returns a structured, calibrated answer to each — a pick, a score, or a yes/no — in a single non-autoregressive pass. There's no prose generated token by token, so there's nothing to parse and nothing to hallucinate. Here's the mechanism, step by step.
Jev 1.14
Jev 1.14 — addressable as jev-1.14.0, or via the jev-preview alias — is the TypeSafe AI System One version that opened the vision path. It adds the box question type, accepts image input, and lifts the long-context ceiling, while every existing text decision keeps working unchanged. Here's what changed from 1.13, how to pin the version, and whether you should.
Jev vs ChatGPT and other LLMs
Jev vs ChatGPT is not a fair fight, because the two do different jobs: Jev vs ChatGPT is really typed decisions versus free-flowing text. Where an LLM writes, Jev returns a calibrated answer locked to a type you declare.
Jev vs Laya
Jev vs Laya is the cloud-versus-local question for typed decisions. Jev is a hosted, closed-weight System One model you call over an API; Laya is the open, self-hosted route — an open-weight, Jev-like decision model you run yourself, including Laya-MLX builds that fit in low memory on Apple Silicon. Same shape of job, opposite trade-offs.
Jev engineering for coding agents
A coding agent is mostly a loop of small decisions — which model, which tool, what to keep in context, are we stuck, is this action safe. Doing each in free-text reasoning is slow, inconsistent, and hard to branch on. Jev turns each into a typed, calibrated call the agent can threshold in ~70–500ms, so the model budget goes to writing code, not re-deriving yes/no answers.
The Jev API
The Jev API is a single HTTP endpoint that turns a state plus typed questions into calibrated decisions — a choice, a score, or a yes/no probability — in one round trip. No prose to parse, no schema to validate. This is the whole surface on one page: endpoint, auth, a working call, the response, pricing and limits.
The Jev benchmark, in plain numbers
Every Jev benchmark you will see today is about speed, cost and calibration — not a public accuracy leaderboard. This page explains what the published figures actually mean and how to test them.
What is a System One model?
Jev is TypeSafe AI's first System One model, launched in September 2026. A System One model returns fast, calibrated decisions instead of text.
How the Jev architecture works
The Jev architecture is best understood from the outside in: Jev returns typed, calibrated decisions instead of text. This page describes the observable Jev architecture, since TypeSafe AI has not publicly disclosed the model's internal weights or parameter count.
RLCD: how Jev is trained
RLCD stands for Reinforcement Learning for Calibrated Decisions, the training method behind Jev. Instead of optimising for fluent writing, it optimises for calibration — so when Jev says 80%, it is right about 80% of the time.
What is a noul in Jev?
A noul is Jev's yes/no primitive. Instead of a bare true or false, it returns a single calibrated number from 0 to 1: the probability that the answer is yes.
Using Jev as a classifier
A Jev classifier picks exactly one of your labels and returns it with calibrated probabilities and a confidence value, so there is nothing to parse and no way to get an invalid class back.
Jev models and versions
The Jev models you call are the same System One engine behind one of two names: jev-latest, a moving pointer, or a pinned version like jev-1.13.0 that never shifts under you.
Running Jev locally
You can't download Jev itself — TypeSafe ships it as a hosted, closed-weight API. But the open ecosystem has caught up: independent, Jev-like decision models now run fully on your own machine. Pick your hardware below and get the shortest path to a working local setup.
How to get a Jev API key
Getting a Jev API key takes two minutes. You can get it from TypeSafe directly, or start instantly with our hosted Jev API key that works the moment you sign in.
Diogo Almeida and Jev
Diogo Almeida is a former OpenAI researcher and a co-inventor of the RLHF work behind ChatGPT. Today Diogo Almeida is the mind behind Jev, TypeSafe AI's first System One model.
Is Jev open source?
The short answer: the Jev model itself is a hosted, closed-weight System One model from TypeSafe AI, so there are no weights to download. The tooling around it — an MCP server and client integrations on GitHub — is open, and you reach the model over a simple API.
How much does Jev cost?
A Jev decision costs a small fraction of a cent. You're billed simply by input tokens — $0.25–$0.42 per million (cheaper on larger packs), output free — and pay with prepaid credit, not a subscription: no seat fee, instant access.
Jev as the decision layer for AI agents
An AI agent spends most of its time making small, typed choices: which tool to call, whether an action is safe, which option ranks first. Jev answers those in one fast, calibrated round trip, so your agent loop stops leaning on a slow LLM for every branch.
The Jev playground
The Jev playground is the fastest way to feel what the model does: type a decision, hit run, and get back one typed answer with a probability for every option and a confidence score — in milliseconds, right in your browser.
How to get access to Jev
This site issues a jv_live_ key against a live account instantly, so you can call the model within minutes of signing up — self-serve, no setup.
Using Jev as a trading decision layer
A Jev trading setup does not predict prices — it turns signals you already compute into a typed, calibrated buy / sell / hold decision in milliseconds. Developers wire it into fast loops, including one decision per block on-chain, because Jev answers in roughly 70–500ms with a confidence score attached.