An agent wants to delete a batch of production files. The language model drafts a plan in seconds, then stalls on one quiet question: is this safe to run? Most stacks answer with more generated text, which is slow, pricey and hard to audit. The LLM proposes, Jev decides pattern answers it differently, and it is quietly reshaping AI agent design.
Each brain gets one job in this split. The LLM proposes a plan, because drafting open-ended text is what it does best. Then Jev answers narrow questions about that plan, one typed call at a time. Your code acts on the replies, so consequences stay with software.
A widely shared open-source harness compressed the idea into one sentence, and builders repeated it all launch week. This guide unpacks the LLM proposes, Jev decides pattern, from its one-sentence origin to its honest limits. Then it covers the tooling, the audit trail and a first build you can ship.
In this guide
- The 30-second answer
- What you’ll learn
- One sentence from an open-source harness
- Why agents need a decision checkpoint
- The anatomy of the LLM proposes, Jev decides pattern
- The audit trail advantage
- Building the pattern with today’s tools
- Where the LLM proposes, Jev decides pattern does not fit
- Frequently asked questions
- The bottom line
The 30-second answer
Here is the short version. Jev is a System One model from TypeSafe AI, released on September 15, 2026. It assigns probabilities to predefined answer options and cannot answer outside them. So an LLM workflow can hand it a state and a typed question, then get a typed answer back instantly.
Why does the split matter? Because judgment calls outnumber writing tasks in most software. Every request gets sorted, scored or screened, often thousands of times a day.
Running those through a poetry engine is the mismatch, and the LLM proposes, Jev decides pattern is the fix.
The receipt habit is the second half. Because Jev’s answers arrive typed, your code can log the question, the odds and the action without parsing anything. Over a week, those logs become the evidence trail every agent project is missing.
Key takeaways
- The LLM proposes, Jev decides, and your code acts: three roles, three receipts.
- Jev is non-generative, so it picks from options you defined and shows a probability for each.
- A decision checkpoint before risky tool calls catches unsafe actions before they run.
- Every step leaves a receipt, so the audit trail builds itself while the agent works.
- Reported results show similar intelligence on System One tasks at a fraction of the cost.
- The pattern fits guardrails, routing and triage, never writing or open-ended planning.
What you’ll learn
The route through this guide
- The one-sentence origin of the pattern, from an open-source harness
- Why agents need a decision checkpoint before risky tools run
- The anatomy of the pattern: three roles, cleanly divided
- How the audit trail advantage plays out in real deployments
- Which SDKs and wrappers build it today
- Where the pattern does not fit, and what to use instead
One sentence from an open-source harness
The pattern entered the mainstream as a single line of documentation. A widely shared open-source GitHub harness described its own loop like this:
An LLM proposes, Jev answers narrow questions, code decides, every step leaves a receipt.
Why did one line travel that far? Because it names a failure everyone had felt. Agents improvised judgments that deserved evidence, and nobody could say afterwards what the model believed.
Read it as a job description for three workers. The LLM drafts, because writing plans is generative work. Judgment over fixed options is not writing, so Jev handles it instead. Your code acts, because software rather than prose should touch production systems.
The project’s GitHub description stays just as plain. Jev takes program state plus typed questions and returns constrained answers with probabilities. It is designed for software decisions, not conversations. That is the LLM proposes, Jev decides contract in one breath.
Question design is the quiet skill here. A good checkpoint question names the state, the options and the fallback before anyone writes code. A vague one produces confident nonsense at conveyor speed, which is worse than no checkpoint at all.
The ecosystem even ships help for the asking side. One open-source tool, jev-bridge, teaches an agent to design Jev questions and send them. So the hardest step, writing questions worth asking, gets easier too.
Why agents need a decision checkpoint
Agents fail in a predictable way. They propose boldly, then act on their own proposal without a second opinion. Because the same model writes the plan and approves it, one confident mistake travels straight to production. The LLM proposes, Jev decides pattern breaks that loop.
LangChain turned the idea into infrastructure in September 2026. Its AutoModeMiddleware uses Jev to check every tool call for risky decisions before the tool executes. So an agent that wants to send money or delete data passes a typed checkpoint first. Our guide to LangChain AutoModeMiddleware walks through the full setup.
The stakes explain the urgency. Tool calls touch payments, emails, files and databases. Screening each one with a frontier model works, but the bill grows with every agent step. When a checkpoint costs a fraction of a cent, guarding everything finally makes sense.
Guardrails also change team psychology. Engineers stop rationing agent ambition when a checkpoint catches the wild proposals early. Product owners stop vetoing autonomy, because every risky step carries a record. The agent gets more room, and the humans get receipts.
None of this requires the agent to slow down. Checkpoints run in milliseconds, so users rarely notice them. The trade is simple: a tiny wait in exchange for decisions you can defend. Most teams take that trade the second time an agent misfires.
A checkpoint question stays deliberately small. Options such as safe, unsafe or needs review cover most tool calls, while a score can grade blast radius instead. Because the options are typed, the answer plugs straight into an if statement.
The anatomy of the LLM proposes, Jev decides pattern
Three roles carry the pattern, and each stays in its lane. The language model contributes intent, drafting and suggested next moves. Jev contributes judgment under fixed options, one typed call at a time. Your code contributes action, thresholds and logging.
Three roles, one pipeline
| Role | Job | Why it matters |
|---|---|---|
| The LLM | Proposes plans, drafts text and suggests tools | Open-ended drafting is its home turf |
| Jev | Answers narrow questions with typed options and probabilities | Judgment becomes instant, cheap and auditable |
| Your code | Acts on replies, sets thresholds and logs everything | Software, not prose, should touch production |
LLM proposes, Jev decides, code acts
The split works because each role is weak where the others are strong. An LLM improvises beautifully and cannot guarantee an answer shape. Jev guarantees the shape, yet it cannot write a word. Code knows nothing about language and everything about consequences.
Jev’s constraints are the feature, not a bug. It assigns probabilities to predefined answer options and cannot answer outside them. When nothing fits, it returns Noul, the typed empty answer, and your code picks the fallback. That honesty is what makes the pattern safe to wire into production.
Names matter less than boundaries. Some teams call it a Jev harness, while others say guardrail or checkpoint. The harness label fits a loop around a whole agent, and the checkpoint label fits one guarded call. Either way, the roles stay identical.
The audit trail advantage
Ask a compliance team what blocks agent projects, and the answer is rarely intelligence. It is proof. The audit trail advantage of this pattern is that evidence arrives automatically. Every decision ships with options, probabilities and an outcome.
The receipts pay off in reviews as well. An auditor can sample any decision and see the exact options the model weighed. A reviewer can spot a drifting threshold before it becomes an incident. In other words, the pattern makes trust a property you can inspect rather than a promise you must repeat.
Regulated teams noticed this first. Payment release, data deletion and customer messages all became checkpoint candidates early on. The pattern did not invent governance; it finally gave governance a cheap place to stand.
Enterprise examples arrived within weeks of launch. A public SAP community sample demonstrates guarded payment release, with a JEV checkpoint before the release payment block. If the checkpoint flags doubt, the payment never runs. That is the shape auditors have asked for since agents went mainstream.
Debugging gets the same gift. When an agent misfires, you replay the narrow questions it asked and the odds it received. Instead of guessing what the model meant, you read what it believed. In short, the audit trail turns AI behavior from folklore into logs.
Building the pattern with today’s tools
Nothing here needs exotic infrastructure. The official JavaScript and TypeScript SDK installs from npm as @typesafe-ai/sdk and runs on Node.js 20 or later. Its client.systemOne() call infers return types from your question definitions. The official Python client adds typed questions, model pinning and test seams, which keep behavior stable while you iterate.
Community options round out the picture. .NET wrappers such as TypeSafeAI.Net and Jev.Net serve Windows-heavy shops. An Apify actor exposes a Jev bulk classifier with JavaScript examples. Because the interfaces stay typed, swapping between them rarely touches your decision logic.
LangChain’s middleware gives the pattern a guardrail home. Because AutoModeMiddleware already checks every tool call, adding Jev turns the checkpoint into a default rather than a project. Their writeup also shows model selection, where Jev picks which model handles a request before generation starts.
The SDK exposes Jev through a TypeSafeClassifier wrapper, so the checkpoint slots into existing chains. Their article shows two worked examples. One picks which model should handle a request, while the other judges whether a tool call is safe. Both are the pattern in miniature.
Pinning deserves one more note. Because the SDKs are young, defaults can shift between releases. The Python client’s model pinning exists for exactly that reason. Pin the version you tested, and treat upgrades as you would any production dependency.
Test seams round out the stability story. Because the Python client ships with them, you can fake Jev replies inside unit tests. That is a small thing until the day an option change would have rerouted payments.
- Pick one tool call your agent makes that deserves a second opinion.
- Define the checkpoint question with fixed options, including what Noul should mean.
- Wire it through the SDK and pin the model version you tested against.
- Set a confidence threshold below which your code asks a human instead.
- Log the question, the odds and the action, then review the receipts weekly.
Start smaller than feels reasonable. Community advice for first tests says to limit yourself to one task, and the harness philosophy agrees. Write down what the checkpoint must catch before you look at any code. A checkpoint you trust on one tool call beats five you hope about.
Where the LLM proposes, Jev decides pattern does not fit
Honest limits keep the pattern useful. The LLM workflow still owns anything open-ended: drafting the plan, summarizing research and writing the reply. Jev cannot do those jobs, because it is non-generative and answers only from your options. If a task has no natural option set, the pattern has nothing to decide.
Question quality is the second limit. Narrow questions with sloppy options produce confident answers to the wrong question. Treat question design the way you treat schema design, so options get reviewed whenever the workflow changes.
The evidence base is young as well. Multipliers like 40 to 200 times faster come from launch-week reporting, and independent benchmarks are still accumulating. Build one checkpoint, measure it on your own traffic, and let receipts rather than hype decide the rollout. Even so, the LLM proposes, Jev decides pattern earns its keep wherever judgments repeat.
Volume cuts the other way too. If you make three judgment calls a day, the setup cost of any model outweighs the savings. The pattern shines when the same narrow question repeats by the thousand. Under that bar, a plain if statement remains the best AI.
Two of our guides pair well here. The AI router pattern is the companion design for cost. It sends easy calls to Jev, while hard ones still go to a frontier model. For the wider category shift, our System One models overview tracks where the market is heading.
Frequently asked questions
What does the LLM proposes, Jev decides pattern actually mean?
It is a division of labor for AI agents. The language model proposes a plan or a tool call, while Jev answers narrow questions from fixed options. Your code then acts on the typed answers, so no single model owns the whole decision.
Do I still need a large language model?
Yes, for anything open-ended. The LLM drafts plans, writes text and handles ambiguity, while Jev handles judgment calls with predefined answers. The pattern needs both, because neither covers the other’s job.
Where did the pattern come from?
A widely shared open-source harness described it in one sentence. The line reads: an LLM proposes, Jev answers narrow questions, code decides, every step leaves a receipt. LangChain then shipped the idea as a tool-safety checkpoint in its middleware. Enterprise samples, such as a guarded payment flow in the SAP community, followed quickly.
Is Jev reliable enough for production decisions?
Jev returns a probability with every answer, so your code can route uncertain cases to humans. Treat the confidence value as a signal, and calibrate thresholds against your own replay results. Early deployments, including tool-safety checks in LangChain’s middleware, suggest the design holds up for narrow questions.
Does the pattern work without writing code?
Not really, and that is by design. Code decides in this pattern, which means thresholds, fallbacks and logs live in your application. No-code stacks can approximate the flow, but the receipts get weaker.
What does Jev cost inside this pattern?
Full pricing tiers have not been published, so hedge with launch-week reporting. One developer reported about 10,000 decisions for $0.42 while running LangChain’s tool-safety middleware. Check TypeSafe AI’s current documentation before you budget a rollout.
The bottom line
The LLM proposes, Jev decides pattern sticks because it fixes a real failure mode. Agents were improvising judgments that deserved evidence. Now the drafts come from a language model, and the verdicts come from a System One model. The action stays with code that leaves receipts.
The pattern asks for modest things: one question, one threshold, one log.
Start with one risky tool call and one typed question this week. Keep the LLM for drafting, Jev for the checkpoint, and your code for everything consequential. If you are weighing platforms first, our build vs buy AI agents breakdown is a fair starting point. For the full model background, our Jev System One model guide is the place to begin.
Sources
- TypeSafe AI, Jev product overview and SDK documentation — typesafe.ai
- LangChain blog, Jev integration and AutoModeMiddleware tool-safety walkthrough — langchain.com
- Widely shared open-source GitHub harness for the propose-decide-act pattern — github.com
- Public SAP community sample, guarded payment release with a Jev checkpoint — sap.com
- npm, @typesafe-ai/sdk package page for the JavaScript and TypeScript client — npmjs.com