Somewhere in your codebase right now, there’s a GPT call that exists to answer one yes/no question. Is this message spam? Should this ticket route to billing or support? Is the user angry? You’re paying frontier-model prices for answers that come back as a single word.
TypeSafe, a startup founded by OpenAI alumnus Diogo Almeida, just built a model that refuses to do anything else. It’s called Jev. It reads up to 64K tokens of text and answers questions you define: yes/no, a multiple-choice pick, or a score from 0 to 10. That’s it. No prose, no code, no conversation. On TypeSafe’s internal datasets it matched GPT-5.6 Terra and Claude Sonnet 5 at 67 percent accuracy while costing roughly $0.0007 per example. Terra charges $0.06 for the same job. Sonnet charges $0.12.
Do that math on a pipeline that classifies two million support tickets a month. The line item stops being a line item.
What Jev is, and what it refuses to be
Under the hood, Jev is a transformer, but it’s not autoregressive. It doesn’t generate. It decides. It was trained with a method TypeSafe calls reinforcement learning for calibrated decisions, which means its confidence scores are tuned to match how often it’s actually right. When Jev says “85 percent confident,” that number means something.
The pricing twist
Input costs $0.042 per million tokens. Output is free. And you can ask many questions about the same text in parallel, paying for the text once. So a single support ticket can be scored for urgency, sentiment, topic, and escalation risk in one pass, with every answer costing nothing extra.
One restriction to keep in mind: yes/no, multiple choice, or 0-10. If your workflow needs an open-ended summary or a rewritten paragraph, Jev is the wrong tool and will happily ignore your request.
The numbers, and the asterisk attached to them
The comparison, on TypeSafe’s own data:
| Model | Accuracy | Cost per example |
|---|---|---|
| GPT-5.6 Terra | ~67% | $0.06 |
| Claude Sonnet 5 | ~67% | $0.12 |
| Jev | ~67% | $0.0007 |
Roughly 85 to 171 times cheaper for the same stated accuracy, with a claimed 193.6x speed edge.
Now the asterisk. Every one of those numbers comes from TypeSafe’s internal datasets. The company skipped public benchmarks, citing benchmark saturation and benchmark-gaming. That’s a defensible reason and also a very convenient one. Until independent evaluations exist, treat the 100x claims as directional. I’d want to see Jev tested on my own labeled data before ripping out anything in production, and at these prices that test costs almost nothing to run.
The audit matters more than the model
Jev is interesting. The reason it can exist at all is more interesting.
Most agent pipelines grew by accretion. Someone needed to filter spam, so they added a GPT call. Someone needed to pick between three tools, another GPT call. Is this lead sales-ready? GPT call. Nobody chose frontier models for these jobs out of a need for frontier intelligence. They chose them because it was Saturday and the model was already in the codebase.
A chunk of what we call “LLM workloads” were always classification jobs wearing a generative costume. Strip the costume and the bill drops by two orders of magnitude.
The usual suspects
Walk your own pipeline and count the calls that return a single token, a label, or a number. Those are candidates:
- Spam and abuse triage on user-generated content
- Jailbreak and prompt-injection detection before a call reaches an expensive model
- Routing: which tool, which department, which model tier
- Lead scoring and intent detection
- Satisfaction or sentiment scoring at scale
A calibrated decision is all these jobs need. Generative horsepower is wasted on them.
Before and after on a lead-scoring flow
Take a standard inbound lead flow. Every form submission gets an LLM call: “Given this message, is this a qualified lead? Answer yes or no.” At Sonnet pricing ($0.12 per example, being generous about token counts), 50,000 submissions a month costs $6,000. With Terra at $0.06, $3,000.
Same flow through Jev: 50,000 submissions at $0.0007 is $35. Plus you can batch the secondary questions, “what’s the intent, what’s the budget band, is this urgent,” into the same pass for free.
The engineering cost is a weekend. The interface is an API call. The risk is contained: keep the LLM path behind a feature flag, run both for two weeks, compare the confusion matrices, then cut over.
You won’t be alone in this
The ecosystem noticed within days. Vercel and Cloudflare both shipped Jev integrations, swapping it in for LLM calls in tool selection and routing. Open imitators arrived almost immediately: Laya, multilingual, claiming higher accuracy. Bespoke Nimble, a fine-tuned Qwen-3.5-9B. Kev, which reconstructs Jev’s architecture on Qwen 3.5 in three sizes.
When copies show up that fast, the category is real even if the pioneer’s numbers aren’t fully verified yet. TypeSafe’s manifesto is “Build prod, not god,” and that line is a decent summary of the whole shift: stop renting a general-purpose genius for questions a specialist can answer in one bit.
What to do this week
- Pull your last month of LLM API logs. Group calls by what they return. Anything that returns a label, boolean, or small number goes on a list.
- Count the spend on that list. If it’s under $50 a month, ignore this whole post. If it’s $500 or more, keep going.
- Pick the single highest-volume call. Export 500 real examples with their expected answers.
- Run them through Jev and one clone (Kev, since it’s open). Compare accuracy against your current model’s actual outputs, not its marketing.
- If accuracy holds within a couple of points, flag the swap and run both in parallel for two weeks. Cut over when the confusion matrices match.
The verification step is the whole game. TypeSafe evaluated only on its own data, the clones are weeks old, and your traffic is weirder than anyone’s benchmark. That’s the actual news here: the cost of finding out whether the savings are real just dropped to pocket change.
