Jev: What It Is and Where It Applies

What Jev is

Jev is a decision model, not a text model: you send it a state plus typed questions, and it returns typed answers with probabilities that your code can branch on directly. TypeSafe AI calls this class a System One model, after Kahneman's fast, intuitive mode of thinking (see the next section), in contrast to the slow, deliberate generation of an LLM.

It launched on September 15, 2026 from TypeSafe AI, founded by Diogo Almeida, a former OpenAI researcher and co-inventor of RLHF and InstructGPT, with a $40M round led by DCVC. Early access was waitlisted for the first five days; on September 20, 2026 TypeSafe opened it to everyone with no waitlist. The name references William Stanley Jevons and the Jevons paradox: cheaper tokens will mean more tokens consumed, not fewer.

System 1, System 2, and where the models sit

The names come from Daniel Kahneman's Thinking, Fast and Slow (2011): System 1 is the fast, automatic, intuitive mode (recognizing a face, finishing "tips and...", reading a stop sign), System 2 is the slow, effortful, deliberate mode (multiplying 343 by 57, weighing a contract clause). There is no System 3 in Kahneman's framework; the numbers stop at two, and "System One model" is TypeSafe's coinage for a model class, not a step in a series.

The useful reading is that an agent needs both modes, the way a person does. Most steps in a loop are System 1 calls (is this relevant, which tool, how urgent, is this safe), and a few are System 2 (write the fix, plan the migration, explain the tradeoff). Chat LLMs have been doing both jobs; Jev exists to take the first kind back at System 1 speed and cost, leaving the reasoning model for the second.

One caveat on the analogy: Kahneman's System 1 is prone to bias precisely because it is fast, and Jev's failure modes (literal reading, no arithmetic, distractible by irrelevant state) are the machine version of the same tradeoff. Calibrated confidence is what makes it safe to build on: the model can say how sure it is, so code knows when to slow down and escalate.

How it works

One request carries a state and any number of typed questions; Jev ingests the state once and evaluates every question against it in parallel, in isolation, in a single forward pass. Adding questions barely changes response time, and because each question is evaluated independently there is no context rot between them.

Code stays in control; Jev supplies narrow judgments inside the loop.

The three primitives

All three can be mixed in one call. Confidence is a second axis distinct from probability: the answer says what, confidence says whether to act on it.

Training

Jev is trained with Reinforcement Learning for Calibrated Decisions (RLCD) rather than next-token prediction, so the probabilities it returns are meant to be calibrated, not just ranked. It is not fine-tuned per customer; you shape it through the state (your records and reference material) and each question's instructions and criteria, which accept JSON structure. Same weights serve every account.

Limits (Jev 1.13, jev-1.13.0)

Source: TypeSafe docs, Models and Introduction.

Speed and cost

Jev costs $0.042 per million input tokens with output free, and answers in roughly 70 to 500 ms regardless of how many questions ride in the request. That is the whole pitch: decisions that used to cost an LLM round trip now cost about as much as a database query.

Read the multipliers with care: they are TypeSafe's own numbers on classification and routing tasks, where an LLM is overkill by construction. On anything that needs generation or multi-step reasoning Jev does not compete, it is simply the wrong tool. The honest framing is that it collapses the cost of the 80 percent of agent steps that are yes/no or pick-one, and leaves the LLM for the rest.

One more cost lever: rate limits (250k tokens/sec, 1,200 req/min) are being adjusted dynamically during launch demand, so a production integration should assume 429s and retry with backoff.

Design patterns and failure modes

The skill with Jev is decomposition: break a judgment into atomic questions, ask them all in one call, and reassemble the answer in code you control. TypeSafe documents four patterns that cover most systems.

The cascade is the pattern people keep arriving at: Jev classifies and routes cheaply, code handles what it can, a frontier model takes the hard minority. Jev is not a replacement for the LLM; it removes the LLM from the steps that never needed one.

Known failure modes (Jev 1.13, reviewed 2026-09-17)

TypeSafe publishes a jaggedness page for each release. The current list:

The adversarial-content line matters for security use: a process name or command line crafted to argue for its own benign classification can move the answer, so criteria need to be explicit and the model should not be the only gate.

Applications

Every good Jev use case has the same shape: a bounded decision, made often, where speed or volume made an LLM impractical. TypeSafe's use-case map lists ten decision shapes, condensed to eight rows below (search, retrieval, and ranking share one); the community builds from the first week map onto the same list.

Decision shapes (from TypeSafe's use-case map)

Source: Example use cases.

Harness engineering (the dominant early use)

Agents run in a loop: an LLM decides, a tool executes, something evaluates the result, repeat. Most of those evaluations are classifications, and Jev takes them out of the LLM's hands. Examples shipped in the first week:

Business workflows

Project note: bookkeeping reconciliation (QBO and Mercury)

Field note from an Agentic Studio Labs bookkeeping pipeline (QuickBooks Online plus Mercury): Jev fits one step, matching, and at the pipeline's current volume it would not change the result. It is worth running only as a low-stakes comparison test alongside the security-monitoring evaluation.

Where it fits: matching questions that can run in parallel with only the low-confidence answers escalated.

Why it is marginal today:

• At small-business volume, most matches resolve exactly on amount, date, and customer name; the few leftovers can be judged by the agent or by a person in seconds.
• Using Jev means sending client names and amounts to another vendor, a data-sharing cost with no offsetting gain at this volume.
• Categorization, owner-transfer handling, and close readiness already work through the approval-gated agent and the JSONL audit trail; nothing there is bottlenecked on decision speed or cost.

If tested: run deposit-to-invoice matching through Jev next to the exact-match code on the same month and compare agreement, confidence on the disagreements, and whether any low-confidence answer was actually wrong. Keep the bank connector read-only, keep every ledger write approval-gated, and keep amounts and dates matched in code; Jev reads dates as text.

Sources: TypeSafe docs: Introduction, Introducing System One Models and Jev.

Real-time and machine-native

The thread running through all three tables: code owns the loop, Jev owns the judgment call inside it, and confidence decides whether the judgment is trusted or escalated.

Project note: macOS process-monitoring agent

Field note from an Agentic Studio Labs endpoint agent under evaluation. The agent design already matches Jev's shape: an ES NOTIFY path (detect, not block), raw events and per-user baselines kept locally in SQLite, and compressed metadata or delta packets sent out for judgment. Each packet is the state; each of the three use cases becomes a small set of typed questions asked in one call.

Jev sits between deterministic rules and the expensive tier; confidence gating decides which way an event goes.

What the docs say to watch for in this workload:

• Filter before sending. Accuracy drops with irrelevant state, so the delta packet should carry only the fields each question needs, not the raw event stream.
• Do the arithmetic locally. Rate spikes, time windows, and counts belong in the agent; Jev reads them as semantic facts once computed ("3x the user's hourly baseline").
• Prefer semantic over numeric representations. Send "unsigned binary in /tmp launched by a browser" rather than raw paths and hashes alone.
• Treat state as untrusted. A process argument written to look benign can move a classification. Keep the model as one signal, keep allow/deny logic in code, and test injection cases.
• Pin the model version once thresholds are tuned; jev-latest can move.
• Latency budget: 70 to 500 ms per call fits a detection path, not an inline blocking path, which matches the NOTIFY decision. Batching several events into one state with per-event questions is cheaper than one call per event.

Open question: whether per-user baselines can be summarized small enough to fit the 32k state budget alongside the event, or whether the agent should send only the deviation summary.

Getting started

Access is open to everyone as of September 20, 2026, no waitlist (announcement); keys come from console.typesafe.ai. Everything hits one endpoint, POST https://api.typesafe.ai/v1/systemone, and the SDKs wrap it.

Swift has no official SDK; the HTTP API is a single JSON POST, so a thin URLSession wrapper covers the macOS agent. Keep the questions and threshold constants in one file so they are the thing a reviewer reads.

A sensible first experiment: export a few hundred real events from the SQLite store, write three or four questions, and measure calibration against your own labels before wiring anything into the agent.