(TL;DR: I got early access to a new kind of model that only answers with structured decisions — boolean, choice, score. I loaded $5, hammered the API for four hours, and couldn't even spend $1. Every call came back in under 100ms. This post is my test results, where I'd actually use it, and one healthcare scenario I can't stop thinking about.)

The hook: $5, four hours, $0.83 gone

A few weeks ago I got an invite to the early access of Jev, the first model from a startup called TypeSafe AI. The founder, Diogo Almeida, is the former OpenAI researcher who helped build ChatGPT and co-invented RLHF, the training technique behind pretty much every chat model you use today. Two years after leaving OpenAI, his team (with co-founders Erik Gafni and Sasha Sheng) shipped something that is deliberately not a chatbot.

Jev was announced on Sep 15, 2026 as the first "System One Model." I've been playing with it since, and the numbers from my own testing are honestly a bit absurd:

  • Cost: I charged $5 and aggressively called the API for ~4 hours of testing. I failed to spend even $1. Official pricing is $0.042 per million input tokens, and output tokens are free.
  • Speed: I built a test that classifies ~1,000-character texts across 13 content-safety categories (profanity, hate speech, spam, etc.). Even including network latency from Europe to their US servers, every single response came back in under 100ms. For reference, the LLM I'd normally use for this takes 2–5 seconds.
  • Accuracy: On the same classification set, Jev's answers matched GPT and Gemini labels more than 90% of the time. (For the disagreements, see the caveats section — the confidence scores are what make this usable.)

To be clear about sourcing: TypeSafe's own marketing claims "193.6x faster, 444.6x cheaper" on their workflow benchmarks. Treat vendor numbers as vendor numbers. But the three data points above are mine, measured from my laptop, and they roughly agree with the marketing.

What Jev actually is: decisions, not strings

Every LLM you know — GPT, Claude, Gemini — is autoregressive: it predicts the next token, then the next, then the next. That's great for writing essays and code. It's terrible when what you actually need is a decision, because you pay (in latency and money) for all that text generation, and then you still have to parse and validate the output, and sometimes it hallucinates anyway.

Jev takes the opposite bet. It doesn't generate text at all. You send it some state (text, usually) plus a set of structured questions, and it responds only in predefined types:

  • Boolean — true or false
  • Choice — one option from a list you define
  • Score — a number quantifying confidence or priority

And here's the part I think is the real innovation: every answer comes with a calibrated confidence score. Not "the model seems sure" — an actual probability, trained (via what they call RLCD, Reinforcement Learning for Calibrated Decisions) so that when it says 95%, it's right ~95% of the time. That's what lets you build automation rules like "act automatically above 0.9, escalate to a human below."

Because the output space is defined in advance, the model can't hallucinate in the classic sense — it can't go off-script, invent a tool call, or start apologizing. It can still be wrong (it's a classifier, not an oracle), but a wrong answer inside your schema with an honest confidence number is a very different failure mode from a fluent, confident, made-up paragraph. The name is a deliberate nod to Kahneman's Thinking, Fast and Slow: this is System 1 — fast, intuitive judgment — built as a first-class primitive instead of a consolation prize.

Where I'd actually use it: the router pattern

The pattern I keep coming back to: use Jev as the ultra-cheap decision layer at the front of a pipeline, and only invoke heavy LLMs when the decision says it's worth it.

Concrete example from my own backyard. When a pull request comes in, the first question isn't "review this code" — it's "does this even need a full review?" A typo fix or a doc tweak doesn't. Today, that initial triage is itself done by an LLM prompt: it works, but you're paying text-generation prices and 2–5 seconds of latency for what is fundamentally a boolean. Replace it with a Jev call and you get the pass/escalate decision in milliseconds, for effectively zero cost. Same story for ticket triage, lead routing, or deciding which of three support queues a customer email belongs in.

This isn't hypothetical — Vercel swapped an OpenAI model for Jev in a safety classifier and got results 5–18x faster and more accurate, and there's already a LangChain integration. The mental shift is simply: AI as a smart if statement, not a chatbot.

The scenario I can't stop thinking about: healthcare

I work in healthcare software, where the reasons companies can't just bolt an LLM onto a product are latency, cost, and above all hallucination. A model that writes plausible-sounding free text about a patient is a compliance incident waiting to happen. What we actually need in most clinical workflows is not prose — it's structured flags mapped to rules we control.

So here's a thought experiment (and to be explicit: this is a hypothetical, not something we've shipped — real deployment would need a full data-protection review, since it currently means sending input text to a US-hosted API).

A patient writes: "My stomach killed me after taking cold medicine. I also broke out in hives when I took aspirin once."

A chat LLM answers with empathy and a paragraph about NSAID sensitivity — slow, expensive, and flirting with unapproved medical advice.

A decision model instead returns, in under 100ms, against a schema we defined:

digestive_vulnerability: TRUE
nsaid_caution:           TRUE
drug_allergy:            aspirin
allergy_symptom:         hives

No generated text, no advice, nothing off-script. From there, our code — not the AI — maps those flags to prescription-checking logic or UI warnings. The intelligence is a tiny, auditable, typed surface; the risky "what should we tell the patient" logic stays deterministic and inside our system. For regulated domains, that inversion feels like the right shape.

Caveats, honestly

  • It can still be wrong. Zero hallucination means zero off-schema output, not zero errors. The confidence score is your mitigation, not a guarantee — you still set thresholds and escalation paths.
  • No generation. If your task needs text — drafts, summaries, code — Jev is the wrong tool by design. It's a front-end router, not a replacement for LLMs.
  • Scale limits. Choice questions support a cardinality up to 255 options; beyond that you're doing multi-stage scoring.
  • Early days, single vendor. One company, one model, weeks after launch. Long-term pricing sustainability is unproven (they claim it'll get cheaper, not more expensive). Build it behind an interface you can swap out.
  • Data governance. Public API means your input text leaves your perimeter. Fine for code review triage; not fine for patient data without a compliant setup.

Closing thought

Testing Jev recalibrated how I think about where AI belongs in a stack. The interesting question is no longer "which model writes the best text" but how sharply you can slice a decision out of your workflow and hand just that sliver to a model — with the rest staying boring, deterministic code.

Fittingly, the model is named after William Stanley Jevons, the economist behind the Jevons paradox: when a resource gets dramatically cheaper, we don't use less of it — we use it everywhere. If decisions really do become this cheap and this fast, the future looks less like a handful of giant chatbots and more like intelligence sprinkled into every if statement in your codebase.

That's a future I'd like to build toward. Now excuse me while I go try to spend the remaining $4.17.

I Loaded $5 and Couldn't Spend It: Hands-On with Jev, the AI That Refuses to Write Text