Jev: The 9-Step Blueprint for Building a Faster Decision Brain for AI Agents

Your AI agent can write an entire report. How much are you paying it to decide which button to click?

Probably more than you think. Most agents still call a full-size language model for decisions with only a few valid answers: which tool to run, where to route a task, or whether to retry, stop, or ask for review. Repeat that judgment thousands of times, and the cost and latency add up.

Jev, built by TypeSafe, is designed for those decisions. Give it the current state and the allowed answers. It returns a typed decision with probabilities and confidence that your code can use.

Before following the direct-API setup below, head to https://typesafe.ai/ and click Join Waitlist

I applied and got access about an hour later. That was my experience; approval times can vary. Apply first, then use the guide to pick a decision worth testing while you wait.

The next nine steps cover the setup commands, a working router, token costs, failure cases, and four things developers have already built with Jev.

Start with a decision your agent already makes repeatedly. By Step 04, you'll have the code to test it.

01. Find the decisions hiding inside your agent

Read your agent loop and circle every model call whose answer comes from a bounded set.

Good Jev-shaped questions:

• Route: research, write, review, or stop?
• Classify: billing, technical, sales, or spam?
• Score: irrelevant, useful, or critical?
• Gate: safe to continue, yes or no?
• Match: which candidate best fits this request?

Use a generative model when the answer is open: writing, explaining, planning, summarizing, or generating code. Use ordinary code when an exact rule already solves the problem.

Suppose an agent receives this job:

Research three browser agents, draft a briefing, and save it for review.

Research and writing remain generative work. Jev can judge whether the evidence is sufficient, which worker should act next, and whether the draft is ready for review. The filesystem must confirm that the file was actually saved.

That division keeps every component on a job it can verify.

Before adding Jev, run a three-part test:

1. Can you list every acceptable answer before the call?
2. Could a careful person make the judgment quickly from the supplied state?
3. Can the application detect or recover from a wrong answer?

Three yeses make a strong candidate. If the first answer is no, the task probably needs generation. If the third is no, keep a human at the decision point.

02. Learn the contract: state in, decisions out

Jev behaves more like a function than a chatbot:

1state + typed questions
2        ↓
3answers + probabilities + confidence
4
5It has three question primitives.

Choice

Selects one option from a list you define: a team, tool, workflow, risk class, or next action. The response includes the selected option, every option's probability, and confidence.

Score

Places the state on an ordered scale you describe: low/medium/high urgency or weak/partial/strong evidence. Each level needs a concrete description.

Noul

Returns the probability that a yes-or-no statement is true. Examples: “The user explicitly approved publishing” or “The message contains a phishing signal.”

One request can contain many questions. They all inspect the same state and run independently. A route, risk score, and approval signal can arrive together.

One question cannot read another question's answer. If decision B depends on decision A or on a newly fetched result, your code must make another call.

03. Type-safe can still be wrong

If the only routes are research, write, and review, Jev cannot return malformed prose or invent a fourth route. It can still choose the wrong valid route.

That is the limit behind the “zero hallucinations” slogan. The output can be structurally valid and semantically wrong.

Confidence needs the same caution. For Choice and Score, it describes how concentrated the returned distribution is. A 95/3/2 split is more decisive than 36/34/30. It does not promise 95% accuracy on your data.

Set thresholds from labeled examples and the cost of being wrong:

• A newsletter tag may auto-apply at 0.65.

• A support ticket may route at 0.80.

• A money transfer still needs deterministic checks and human approval.

Run Jev in shadow mode first. Record its answer without allowing it to act. Compare it with human labels, measure false positives, and test whether low confidence predicts errors.

Do this per route. An overall accuracy number can hide a classifier that handles routine support tickets well but repeatedly sends security incidents to the wrong queue. Track a confusion matrix, the share of decisions escalated to humans, and the cost of each failure type. A threshold should reflect consequences rather than make a dashboard look clean.

Type safety protects the shape of the answer. Your evaluation protects the system.

04. Connect Jev and build one real router

Try a decision in the TypeSafe Playground, then create an API key in key settings. Keep the key outside source files.

macOS / Linux

1mkdir jev-router && cd jev-router
2python3 -m venv .venv
3source .venv/bin/activate
4pip install typesafe-sdk
5export TYPESAFE_API_KEY="YOUR_KEY_HERE"

Windows PowerShell

1mkdir jev-router; cd jev-router
2py -3.12 -m venv .venv
3.\.venv\Scripts\Activate.ps1
4pip install typesafe-sdk
5$env:TYPESAFE_API_KEY="YOUR_KEY_HERE"

Create router.py:

1import json
2from pathlib import Path
3
4from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
5
6state = {
7    "request": "Compare three browser agents and draft a briefing",
8    "sources_found": 3,
9    "draft_exists": False,
10    "explicit_publish_approval": False,
11}
12
13with TypeSafeClient(model="jev-1.13.0") as client:
14    result = client.system_one(
15        state=state,
16        questions={
17            "next_worker": Choice(
18                instructions="Which worker should act next?",
19                criteria={
20                    "research": "Evidence is missing or weak",
21                    "write": "Evidence is sufficient and no draft exists",
22                    "review": "A draft exists or the request is unclear",
23                },
24            ),
25            "evidence": Score(
26                instructions="How well does the evidence support the briefing?",
27                criteria=["Insufficient", "Useful but incomplete", "Sufficient"],
28            ),
29            "may_publish": Noul(
30                instructions="The state contains explicit human approval to publish"
31            ),
32        },
33    )
34
35route = result.answers["next_worker"]
36destination = route.choice if route.confidence >= 0.80 else "human_review"
37
38handoff = {"destination": destination, "confidence": route.confidence}
39Path("handoff.json").write_text(json.dumps(handoff, indent=2))
40print(handoff)

The client reads TYPESAFE_API_KEY from the environment. It uses the moving jev-latest alias by default; pin the version you evaluated when stable thresholds matter.

The model supplies a judgment. Your application owns the threshold, queue, fallback, and consequences.

05. Ask independent questions together

Sending the same ticket five times for five independent questions wastes input tokens and round trips. Send one state with all five questions.

TypeSafe's public cookbook tested 13 questions over one document. A batched request was reported as 10× faster and 12.2× cheaper than sequential calls, with the same answers.

1ONE STATE
2  ├─ Choice: which team?
3  ├─ Score: how urgent?
4  ├─ Noul: refund requested?
5  └─ Noul: human review required?
6             ↓
7CODE USES THE RELEVANT ANSWERS

Speculative questions are fine when they share the same state. Your code can ignore a bug-severity score if the request turns out to be billing.

Jev reads the state again on every request. Remove irrelevant history before reaching for the 64k-token limit.

06. Keep code in charge of execution

Strong Jev integrations rebuild the action menu from what the system can do right now.

A browser agent can observe the page, list visible controls, and let Jev choose an action and target. Browser code performs the click and checks the next page state.

1observe → build allowlist → decide → execute → verify → observe again

Apply the same pattern elsewhere:

• Offer only tools allowed for this user.

• Remove completed or unavailable actions.

• Attach stable IDs to candidates.

• Rebuild choices after every state change.

• Send uncertainty and timeouts to a fallback.

For a large menu, filter obvious mismatches in code, Score the remaining candidates, and use Choice on the shortlist. Stable candidate IDs matter more than elegant labels: the model chooses an ID, while your application resolves it to the current tool or page element. After any click, write, or tool call, discard the old menu and observe again.

Every loop also needs maximum actions, a spending limit, persisted progress, duplicate protection, a kill switch, and human approval before irreversible actions.

Confidence cannot prove that a refund was issued or a file was saved. Inspect the real system.

07. Calculate the bill before repeating the headline

Jev 1.13 costs $0.042 per million input tokens on TypeSafe's direct API. Output tokens are unbilled.

At 1,000 input tokens per decision:

110,000 decisions × 1,000 tokens = 10M input tokens
210M × $0.042 / 1M            = $0.42

For 10,000 calls with 1,000 input and 50 output tokens each, public prices visible on September 20 produce this estimate:

Model

Input / 1M

Output / 1M

Workload cost

Jev 1.13 direct

$0.042

$0

$0.42

GPT-5.6 Luna

$0.20

$1.20

$2.60

Gemini 3.8 Flash

$0.75

$3.75

$9.38

Claude Fable 5.1

$10.00

$50.00

$125.00

GPT-6 Astra

$10.00

$50.00

$125.00

This is cost arithmetic, not a quality benchmark. These models do different jobs.

The public seven-second flight demo reported 90,558 Jev input tokens: about $0.00380. A text helper brought the reported model total to roughly $0.00387. Browser infrastructure was outside that number, and the demo found flights rather than purchasing one.

On September 19, an independent builder reported $0.00003 for Jev versus $0.0134 for GPT-6 Astra across 14 decisions, with Jev 9.5× faster. It is one author's test, not a general benchmark.

Track cost per completed, verified task. One wrong route can cost more than thousands of cheap decisions.

08. Know where Jev breaks

TypeSafe's own model card lists clear weaknesses.

Do not use Jev for exact arithmetic, counting, dates, or time calculations. Compute those in code. Do not use it to write, summarize, plan, or generate arbitrary text.

Large amounts of irrelevant state can reduce accuracy. Untrusted content can still manipulate a semantic judgment, so keep hard permissions in code and restrict the available actions.

Avoid one vague “quality” score. Ask observable questions instead:

• Does the answer address the request?
• Does it use the supplied evidence?
• Does it contradict a known fact?
• Does it contain an untrusted instruction?

Jev is text-only, works best in English, and runs as a hosted API. TypeSafe says requests and responses are not used for training; zero-data retention is an enterprise option. Check the legal terms for your deployment.

The current weights, training data, and full RLCD recipe are not public enough for an outside team to reproduce the model. That does not make Jev unusable, but it changes the evaluation burden: vendor benchmark tables cannot substitute for a test set drawn from your own traffic. If state cannot leave your infrastructure, a local classifier or deterministic rules may be the better answer even when Jev is cheaper.

The boundary is practical:

Job

Best tool

Exact limits, arithmetic, permissions

Code

Route, rank, score, yes/no judgment

Jev

Write, explain, research, generate

LLM

Irreversible action

Human approval + verification

09. What developers have already released with Jev

The newest demos place Jev inside existing products and keep the final action elsewhere. Four patterns are already worth stealing.

Detect slop while the user scrolls

Bilgil placed Jev in the browser and used it to score existing content in real time instead of asking a larger model to rewrite every post.

https://x.com/RBilgil/status/2100976648552169805

The use case fits Jev: the output is a bounded judgment, not new prose. Accuracy and false-positive data are still missing.

How to repeat it: extract the visible text, ask for a Score or Noul decision, and keep the original post untouched.

Choose a UI instead of generating one

Chris Tate combined \json-render\ with Jev. Jev selects from known components and actions; the renderer builds the interface.

https://x.com/ctatedev/status/2101022101750571357

The demo passed one million views. That makes it an excellent proof of interest, though its latency claim is not a published cross-workload benchmark.

How to repeat it: give Jev component IDs and allowed actions, then let deterministic code render the selected tree.

Start a Mac action before the sentence ends

Instant Rice built a voice workflow that begins opening an application before the speaker finishes speaking.

https://x.com/instantricecook/status/2100814590300889426

Fast intent classification is useful here because the action space is small. Operating-system permissions and confirmations must still protect destructive steps.

How to repeat it: stream the transcript, expose only reversible actions at first, and require confirmation before anything destructive.

Match 700 leads to the right message

Romàn used Jev to compare 700 leads with outreach messages, score the matches, return confidence, and flag mismatches.

https://x.com/romanbuildsaas/status/2100891604735099103

The author reported processing the batch in 40 seconds for $0.09. That proves the workflow is cheap enough to test at useful scale; whether the scores improve replies or revenue still needs an A/B test.

How to repeat it: define the traits of a strong match, score every lead against a closed set of messages, and send low-confidence pairs to review.

• Four products, four completely different surfaces: a feed, a generated interface, a voice-controlled desktop, and an outreach pipeline. The shared move is smaller than the demos make it look. Each builder found one repeated judgment, closed the answer space, and let ordinary code handle the consequence.
• That is where Jev becomes useful. Not as the agent, the writer, or the product - as the fast decision layer between state and action.

The rule that survives the hype

Frontier models still research, plan, explain, and generate. Jev handles bounded decisions between those steps.

Start with one repeated decision. Give it a closed answer space. Run it in shadow mode, measure errors, add a fallback, and enable the lowest-risk branch first.

Then replace the next expensive yes/no, route, rank, or score.