TypeSafe AI's Jev for Marketers: The First Model That Returns Decisions Instead of Text (and 5 Jobs It Earns Today)

Last Tuesday I was staring at a Make.com scenario that routed 12,000 support emails a day through Claude. Each email took about 4 seconds to classify, cost roughly $0.01, and produced one of three labels: billing, technical, or sales. That's a $120/day bill to ask a model the same shape of question a 200-line if/elif block could answer — if we trusted ourselves to write the rules. We don't. So we paid for intelligence.

Then TypeSafe AI released Jev, and the bill for that one scenario dropped to about $2.40/day. The call now takes 180 milliseconds. And the model doing it cannot write a single word.

That's the whole pitch. Jev returns typed decisions with calibrated probabilities — a Choice among up to 255 options, a Score on a 0–100 scale, or a Noul (a calibrated yes/no). No prose, no JSON string, no parsing, no try/except for malformed output. You can't get an off-schema value back, because the schema is the API.

What Jev actually is

TypeSafe AI is a San Francisco startup founded by Diogo Almeida, one of the co-inventors of RLHF at OpenAI, alongside Erik Gafni and Sasha Sheng. They raised a $40M seed round led by DCVC and shipped Jev on September 15, 2026, after two years in stealth. The company calls Jev a System One Model — borrowing Kahneman's "fast thinking" framing — and contrasts it explicitly with chat-tuned LLMs trained on RLHF (Reinforcement Learning from Human Feedback, 用人类反馈做强化学习) or RLVR (Reinforcement Learning from Verifiable Rewards, 用可验证奖励做强化学习).

Jev is trained instead with RLCD (Reinforcement Learning for Calibrated Decisions, 校准决策强化学习) — a method that targets epistemically honest probabilities. When Jev says it's 70% confident, the goal is that ~70% of those predictions are actually correct. That's the property a routing system can actually use: it can act when the probability is high, escalate when it isn't, and never have to parse a string.

Three primitives cover most marketing decisions:

• Choice — pick one option from a list you define (route to billing / technical / sales)
• Score — return a number on a defined scale (lead quality 0–100, brand-safety risk 0–10)
• Noul — calibrated boolean probability ("is this comment toxic?", "does this CTA match the offer?")

You send Jev unstructured state — text, JSON, an array — plus your list of questions. Jev returns the answer to every question in a single parallel pass. End-to-end latency is 70–500ms vs. the 3–329 seconds TypeSafe cites for frontier models, and pricing is $0.042 per million input tokens with output tokens free.

The headline numbers, with their asterisks

TypeSafe claims 40–200× faster and ~444× cheaper than frontier LLMs on "System One shaped" queries. On its own four workflow evaluations, the company reports a 193.6× speedup and 444.6× cost reduction.

Three caveats matter before you rebuild your stack around those numbers:

1. The workflows were written by TypeSafe's own capabilities team. "Accuracy" in those evals means agreement with a reference answer (the average output of GPT-6 Astra and Claude Fable 5.1). The numbers are favorable by construction.
2. TypeSafe admits pricing may be subsidized. "We can't yet prove the prices aren't a launch promo," the launch post says. Treat the cost story as a floor you'll renegotiate later, not a permanent ceiling.
3. "Can't hallucinate" means schema-valid, not semantically correct. A well-typed billing routing decision can still be the wrong department. Schema guarantees stop the parser; they don't stop the routing.

On the published eval chart Jev sits at roughly 68% accuracy — level with GPT-5.6 Terra and Sonnet 5 at a small fraction of their cost. The most accurate configurations, OpenAI's Sol and Anthropic's Opus 5 in workflow mode, still score several points higher. Jev's win isn't accuracy; it's accuracy-per-dollar on bounded decisions.

The 5 marketing jobs it earns today

These are the places I'd route through Jev before paying for an LLM round-trip:

1. Support-ticket / inbound email routing. Same job as my Make.com scenario above. Replace the Claude step with Jev; classify at 180ms with a probability distribution per department. Pair the lowest-confidence slice with an LLM escalation path.
2. Lead quality scoring across CRM. Feed the lead record + a 5-question scoring rubric. Jev returns 0–100 per dimension (fit, intent, recency) with confidence. Use the confidence to decide whether sales touches it today, next week, or never — and pass the marginal leads to a Gemini-based scorer for a second opinion.
3. UGC and ad-comment moderation triage. Define safe / review / remove plus a toxicity_score 0–10. Route safe straight to publish, review to a human queue, remove straight to suppression. This is the job the Vercel engineer Pranit Sharma replaced with Jev inside a real production system (5–18× faster than ChatGPT Luna 5.6, with higher accuracy).
4. A/B-test winner selection. After 48 hours, send Jev the two variants' metrics plus a defined shipping question (ship_a / ship_b / wait). Pair this with the 75-ads-in-a-day creative matrix so each test gets an automated verdict.
5. Real-time model router. When a customer message lands, ask Jev needs_chat_agent / needs_drafting / self_serve_kb. If self_serve_kb with confidence ≥ 0.85, send the KB article and skip the LLM entirely. If needs_chat_agent, route to your Lindy AI or ChatGPT Work agent. This is the cheapest way I've seen to cut an LLM bill without dropping quality on the messages that actually need it.

The unifying pattern: Jev works where the decision shape is bounded and the cost of being wrong is recoverable. It does not work where you need prose, judgment with context, or persuasion.

What to keep on your regular LLMs

Three jobs don't move to Jev:

• Brand-voice copy. No strings, no voice. Use Claude Sonnet 5 or Opus 5.
• Customer replies and CRM narrative. Anything a human will read.
• Strategy synthesis. Long-context reasoning still belongs on Fable 5.1 or GPT-6 Astra.

Routing principle

Treat Jev as a decision co-processor, not a replacement model. Push every step in your marketing pipeline that ends in a routing label, a score, or a yes/no through Jev first. Push every step that ends in prose, conversation, or synthesis back to your regular OpenRouter rotation. Wire Jev as the front door of your OpenClaw or n8n agents, and let it decide which downstream model — if any — actually gets called.

Watch-items for the next 60 days

• Pricing durability. TypeSafe says they can't prove the prices aren't a launch subsidy yet. If the input price moves from $0.042 to $0.42/MTok, half the value-prop evaporates.
• CJK accuracy. TypeSafe's docs flag that English is the primary training language and that "other languages, including CJK scripts, are handled but not equally well." For any Chinese or Japanese workflow, run a 200-question calibration test before trusting the confidence scores.
• Independent benchmarks. Today the only public evals come from inside TypeSafe. Wait for an external head-to-head (Mike Taylor's Every hands-on is the first independent signal) before betting a critical path on it.
• LangChain integration shipped Sept 18. If you're already on LangChain, the langchain-typesafe package drops Jev into existing agent harnesses as a guardrail layer — useful, not transformative on its own.

Jev is now in early access behind a waitlist. The interface is one endpoint (POST /v1/systemone), the model field is jev-1.13.0, and the same company that brought you RLHF for ChatGPT is now betting that the next big AI market is machine-to-machine decisions, priced like electricity. If your routing logic lives in prompts today, this is the model that lets you move it into code — at a cost where you stop thinking about whether to call it.