Start With the Right Mental Model
TypeSafe shipped Jev on September 15, 2026, and the pitch sounds contradictory: it's an AI model that generates no text. Call it a System One Model — a deliberate nod to Kahneman. Where a reasoning LLM is slow, expensive System Two, Jev is fast, cheap pattern recognition.
The official numbers frame the gap: a single decision costs $0.000081 and completes in 0.114 seconds. A typical LLM doing the same classification runs $0.01388 and takes 8.566 seconds. That's two orders of magnitude on cost and roughly 80x on speed.
Before reading further, audit your pipeline for high-frequency judgment calls: triage this ticket, route this email, approve this tool call. If those exist, Jev belongs on your shortlist. If every step needs long-form generation, it doesn't.
The Workflow: Typed Answers, Not Prose
The API surface is deliberately small. You send two things: a state (free text or arbitrarily nested JSON — a ticket, an order, an account record) and a list of questions about that state.
What comes back is not prose. Every question returns a typed answer with a probability distribution and an overall confidence score. Your code branches on a number with an if statement — there is no output parsing step and no malformed-JSON failure mode. That's what "type-safe" buys you.
The full loop has four stages: state in, questions evaluated in parallel, typed answers with confidence out, and your software routing on thresholds. Above the bar, execute automatically; below it, escalate to a human. Adding more questions to the same state adds almost no latency, so it's normal to ask three or four at once.
One worked example from the official docs: a support ticket whose state includes ticket.message ("Stripe payment callback failing for 3 days"), the order record, and refund policy text. Three questions run in parallel — is this urgent, which team should own it, how frustrated is the customer — and all three answers land in one round trip.
Designing Questions: Three Types, One Rule
Jev supports three question types, and the craft is in how you write the criteria.
Noul (yes/no judgment) returns the probability that a statement is true. Use it for urgency, compliance, risk flags. The cardinal sin is asking "Is this urgent?" — urgency is undefined, so the probability is noise. Bake the standard into the criteria instead: production-impacting, older than 24 hours, or involving money. The more specific the criteria, the more trustworthy the probability.
Choice (multiple choice) returns a probability per option plus confidence. This is your routing primitive: billing, account, or technical? You get a distribution like billing 0.8 and account 0.15. Take the argmax, or route to a human when the top two options are statistically close.
Score (scale) returns a score, a distribution, and confidence. Frustration rated 0–2 might come back as 1.04 with a 0.94 spread. Read the distribution shape, not just the mean — a bimodal spread is telling you something a single number hides.
Three habits worth forming: write criteria like a policy document, saturate each state with parallel questions, and treat distributions as first-class output.
The Pricing Math
On OpenRouter, typesafe/jev-1.13 costs $0.042 per million input tokens; output is free. That works out to roughly 240 single-question decisions per penny.
Context matters more than the raw number. Community benchmarks: pull-request review at about $1 per 70,000 decisions — 1,000 PRs for 7 cents versus $14.50 on Claude Opus. A browser agent completed a full flight-booking flow in 7 seconds. A Doom-playing agent made 10 decisions per second.
The economic shift is architectural. When marginal judgment cost approaches zero, you stop sampling and caching and start evaluating every event. That unlocks products that were previously priced out of existence — per-event scoring, per-tool-call safety checks, per-message triage.
One caution: free output and cheap input smell like subsidized pricing. Model your long-term costs at a 5–10x price increase before you architect anything load-bearing around it.
Four Integration Paths
Cloudflare Workers AI (model ID typesafe/jev, 32K context) fits teams already on the CF edge who want low latency. The official ticket-demo runs here: urgency 0.95, routing to billing at 0.8, frustration 1.04/0.94 — and a separate login-issue state routed to account at 1.0 confidence.
OpenRouter (typesafe/jev-1.13, with a jev-latest alias that tracks the newest version) is the fastest way to validate. One HTTP request, no infrastructure lock-in, and easy side-by-side cost comparisons against your current LLM.
LangChain via the langchain-typesafe package is the richest integration, with three middleware modes:
TypeSafeClassifier— the baseline classifier. State can be plain text, structured data, or LangChain message objects. Drop it into an existing chain as a judgment node.ModelRouterMiddleware— difficulty-based routing that sends each request to the cheapest model capable of handling it. Trivial calls go to Jev; genuine reasoning escalates to an LLM. This is the most direct cost-saving pattern.AutoModeMiddleware— a guardrail inspired by the safety layers in Claude, Codex, and Cursor. Before high-risk tools like bash execute, Jev rates the danger and blocks if it exceeds threshold. The one-line summary: use a System One model to insure your System Two model.
The official console at console.typesafe.ai is in early access — useful for prototyping criteria in a UI before writing code.
Suggested path: prototype on OpenRouter, then pick Workers AI or LangChain for production depending on your deployment shape. The LangChain middleware trio is currently the most complete integration surface.
A Three-Step Rollout
Step 1: Verify calibration before trusting anything. Take 100–500 historical tickets (or equivalent real judgments from your domain), label them by hand, and run a regression test against Jev. Don't just measure average accuracy — check whether the probabilities are honest. When the model says 0.9, is it right about 90% of the time? There's no published paper, parameter count, or ablation study to lean on, so this test is the only evidence that counts.
Step 2: Start in low-risk territory. Email triage, ticket routing, content tagging — places where a wrong call costs seconds of human time, not dollars. Real traffic here teaches you how Jev's confidence feels in practice, and you tighten thresholds as evidence accumulates.
Step 3: Add agent guardrails last. Once calibration data and low-risk experience are in hand, attach AutoModeMiddleware to dangerous tools so every bash execution passes a risk check first. Reversing the order — guardrails before calibration — is installing ABS on a car with untested brakes.
Limitations and Gotchas
- It will be wrong sometimes. Probabilistic output demands thresholds and a human fallback. There is no 100% automation mode.
- "Zero hallucination" means type-safe, not correct. The output format is always parseable; the judgment inside it can still be wrong. Keep those two claims separate.
- 32K context ceiling. Long documents need chunking or summarization first, and judgment quality is sensitive to how information-dense your state is.
- No image input. Text and JSON only; multimodal needs need another tool.
- Math reasoning is roughly GPT-4 level. Deep reasoning still belongs with a System Two model.
- Pricing may be subsidized. Stress-test your unit economics at higher prices.
- No published paper or ablations. Official benchmarks are a starting point, never a substitute for validation on your own data.
- The ecosystem is young. SDKs and best practices are still moving; keep your own wrapper thin so you can swap providers cheaply.
The closing thought: Jev's value isn't replacing your LLM. It's converting the judgment steps that were too expensive for an LLM and too rigid for hand-written rules into a programmable probability function. Validate calibration on your own data first — then scale.