Jev, Playable — PlayPlain

EP 01

Write vs decide — the same question, two machines

Ask both the same question: "Is this email urgent?" The LLM streams tokens — a sentence of reasoning, then finally a "yes." Jev never writes a word: it emits a typed decision {urgent: true, p: 0.91} the instant you hit run. Press the button and watch the two clocks. The LLM's answer is buried in prose you have to parse; Jev's is already a boolean your code can branch on.

✓ good case: a yes/no/route/score decision — Jev returns a typed value in ~70ms✗ wrong tool: "write me the reply email" — Jev can't; that needs an LLM

press "ask both"

The LLM has to generate ~40 tokens before the answer appears; Jev does one forward pass and returns the class + confidence. Same decision, ~200× the latency gap.

Text is a terrible container for a decision. Most "AI calls" inside real apps aren't asking for prose — they're asking "which bucket?", "how urgent?", "should the agent stop?". Wrapping that in a paragraph of generated text is the tax LLMs quietly charge on every hidden decision.

EP 02

How it works — one pass, not a loop

Here's the whole trick. An LLM is a loop: it predicts one token, sticks it on the end, feeds the whole thing back in, and predicts the next — dozens of sequential passes to spell out an answer. Jev is not autoregressive. TypeSafe's architecture uses a parallel sampler that reads off the entire answer in a single forward pass — no token-by-token decoding loop at all. That one structural change is where ~200× of the speed comes from. Press run and watch the LLM crank its loop while Jev answers in one shot.

✓ the key idea: a decision is a point on a probability distribution — you can just read it, no need to "write" toward it✗ the LLM tax: 40 sequential forward passes to say a word Jev outputs in 1

press run

Three output types, all typed. Jev only ever returns one of three schema-locked shapes — Choice (pick one of N, each with a probability), Score (a number in a range, with a probability), or Null (a single 0–1 probability, i.e. a calibrated yes/no). It literally cannot emit free text — which is also why it can't hallucinate a paragraph or drift off-schema.

Why the probability is trustworthy: RLCD. Normal chat models are tuned with RLHF — optimized for what humans like, which quietly rewards confident-sounding prose and overconfidence. Jev is trained with Reinforcement Learning for Calibrated Decisions (RLCD): it's rewarded for being calibrated, so its 0.90 means "right ~90% of the time," not "sounds sure." Confidence comes from the shape of the output distribution (sharp vs spread), not a made-up certainty score.

No writing means no loop, no loop means it's fast, and typed-only means it can't hallucinate. Jev turns "call a model" into something closer to a function call: unstructured state in → a typed, calibrated decision out, in one pass. (Note: TypeSafe hasn't published the full architecture, and the 200×/400× figures are their own workflow evals — treat them as the high end.)

EP 03

The 400× bill — decisions at scale

A decision that's cheap once is a budget when you run it a million times a day: every email classified, every message triaged, every agent step evaluated. Drag the volume. Watch the LLM bar climb into real money while the Jev bar barely leaves the floor.

✓ good case: high-volume, behind-the-scenes decisions — 400× cheaper turns a cost center into a rounding error✗ bad case: a few dozen calls a day — the savings are real but nobody notices

decisions / day 10,000 —

Cost is a capability. When a decision drops from cents to thousandths of a cent, you stop rationing it — you classify everything, evaluate every agent step, score every row. The 400× isn't just cheaper; it changes which products are even buildable.

EP 04

Calibrated confidence — a number you can trust

An LLM saying "I'm 90% sure" is just more generated text — it means nothing. Jev returns a real probability, and it's calibrated: of all the times it says 0.90, about 90% actually turn out right. Drag the confidence threshold. Below it, Jev auto-answers; above it, it flags for a human. A trustworthy number lets you set that line on purpose.

✓ good case: threshold at 0.85 — auto-handle the confident 80%, escalate only the genuinely uncertain 20%✗ bad case: trusting an LLM's "95%" — it's a word, not a measurement

auto-answer threshold 0.85 —

Calibration is what makes a decision model deployable. Text confidence is theater; a calibrated probability is a dial. It's the difference between "the model seems sure" and "auto-approve above 0.9, human-review below" — a rule you can actually put in production and audit.

EP 05

The router — Jev up front, the LLM in reserve

The real pattern isn't Jev instead of the LLM — it's Jev in front of it. A stream of tasks arrives. Jev instantly handles the easy, confident majority for a fraction of a cent; only the hard, low-confidence tail gets escalated to a slow, expensive LLM. Drag how confident Jev has to be before it dares decide alone, and watch throughput and cost move against each other.

✓ good case: Jev clears 90% cheaply, LLM handles the 10% that actually needs a brain✗ bad case: set the bar so high Jev escalates everything — you've paid for Jev and still run the full LLM bill

Jev's confidence bar 0.80 —

System One in front, System Two behind. Jev doesn't replace the LLM — it protects it. Fast, cheap, calibrated decisions handle the flood; the expensive reasoning model is saved for the few cases that earn it. That's the whole design of the "decision layer" everyone rushed to add the week Jev shipped.