Jev: Fast, Structured Judgments for AI Agents Without LLM Overhead

What Jev Is

Jev is TypeSafe's first "System One" model, borrowing the "fast thinking" analogy. It takes a structured state — a customer message, a set of UI buttons, or a task description with execution results — and returns a program‑usable judgment: a choice from a fixed set, a weighted score across levels, or a probability (Noul). It does not generate free‑form text or directly operate business systems.

Three primitives cover distinct needs:

Choice — pick one category from a predefined list.

Score — assign a weighted score across ordered levels; a high score does not equal high probability of an event.

Noul — return the probability of "yes" for a binary question, not a boolean.

Unlike general LLMs forced to output structured JSON, Jev drops free‑text generation entirely, optimizing for lower latency and cost.

Ticket Routing Example

A customer writes: "My account was charged twice today, I need service tomorrow, please fix ASAP." Instead of asking an LLM to write a full analysis and reply, two Jev calls suffice:

Choice : which team? Options: Billing, Tech Support, Human Triage, Other/Insufficient Info.

Noul : is the customer urgent?

Both can be asked in one request; they operate independently on the same input. If the next step depends on the first result, separate calls or code orchestration are needed. The article stresses that Jev's classification (e.g., "Billing") does not prove the underlying fact (double charge) — payment logs and business rules must still verify and execute refunds.

Game Agents: Doom and Mario

Doom: Continuous Low‑Latency Decisions

TypeSafe's official Doom demo queries Jev ~10 times per second with a serialized game state (not screenshots). The model decides movement and firing in real time; there is no time for an LLM to write a strategy. The authors note that hand‑crafted game bots may play better — the demo shows continuous response capability, not superhuman skill.

Mario: Transparent Action Probabilities

The community project typesafe-mario reads Mario's position, velocity, nearby enemies, and terrain, then asks Jev to choose from allowed key combinations. The UI displays each action's probability, a Noul judgment for "is jumping forward useful now?", and a Score for current danger level. Choice drives the actual key press; Noul and Score provide observability. In both games, code handles state extraction and button pressing — Jev only supplies the judgment.

Browser Automation: jev‑ultrafast

The open‑source jev-ultrafast (by Browser Use) extracts actionable page elements, lets Jev pick the target and action, and calls a text model only when text input is needed. A demo queries Google Flights for Zurich‑London flights in ~7 seconds (measured after first page load). The article cautions that iframes, canvas, and other complex page structures are not yet covered. Crucially, even when Jev returns "done", the program must independently verify that qualifying flights actually appear on the page — selection ≠ completion.

Integration in a Harness (LangChain)

LangChain's "Building a Harness with Jev" shows two patterns:

Model routing : Jev classifies a task (e.g., "fix typo" vs. "debug distributed transaction") and routes simple tasks to a cheaper model, complex ones to a stronger model. The harness must support mid‑flight model switching if difficulty is underestimated.

Tool risk pre‑check : Jev flags risky operations (file deletion, sensitive data access) but cannot override existing permission gates; a "low risk" label does not bypass approval workflows.

Both patterns add a judgment step; if the original task is very short, the extra round‑trip may increase total latency. The cost of mis‑routing and retries must be accounted for.

Type Safety ≠ Correctness

"Type safe" only guarantees the answer falls within the declared options. A ticket classifier limited to {Billing, Tech Support, Human Triage} will never invent a fourth department, but it can still route a billing issue to Tech Support. Choice and Score return a confidence field reflecting how concentrated the probability mass is — not the probability of being correct. A confidence of 0.9 does not mean 90% accuracy; the model can be confidently wrong.

Therefore, teams must evaluate on their own data: map confidence ranges to error rates, measure the impact of mis‑routing, and decide which buckets to automate. Missing input context or ambiguous category definitions also cause errors — threshold tuning alone is insufficient.

Practical Adoption Guide

TypeSafe publishes pricing at $0.042 per million input tokens (output free) and 70–500 ms latency (measured from US West Coast, as of 2026‑09‑21). The article provides a decision table:

Clear conditions, computable result → plain code / SQL / rules.

Existing classifier works acceptably → keep it, measure swap benefit.

Needs language understanding, fixed answer set, high frequency → try Jev.

Complex analysis, code generation, long‑form text → stay with general LLMs.

Recommended rollout: start with ticket routing. Run historical tickets (including ambiguous, multi‑department, incomplete ones) through rules, current model, and Jev. Compare error rates, human handoffs, and total time/cost including retries. Deploy in shadow mode first — log Jev's suggestion without changing actual routing. After confirming gain, gradually enable auto‑dispatch with fallback to the original flow on timeout, service unavailability, or low confidence.

References

TypeSafe: Introducing System One Models & Jev —

https://typesafe.ai/blog/introducing-system-one-models-and-jev

TypeSafe: Introduction — https://docs.typesafe.ai/introduction TypeSafe: Choice, Score, Noul — https://docs.typesafe.ai/primitives/choice, https://docs.typesafe.ai/primitives/score, https://docs.typesafe.ai/primitives/noul TypeSafe: Confidence — https://docs.typesafe.ai/confidence Browser Use: jev‑ultrafast — https://github.com/browser-use/jev-ultrafast LangChain: Building a Harness with Jev — https://www.langchain.com/blog/building-a-harness-with-jev TypeSafe Mario —

https://github.com/fhshaik/typesafe-mario