DEV Community

Cover image for TypeSafe AI and Jev: The Model That Answers Questions Instead of Writing Essays
Iniyarajan
Iniyarajan

Posted on

TypeSafe AI and Jev: The Model That Answers Questions Instead of Writing Essays

#machinelearning #python #ai #javascript

The first "System One" model returns typed decisions with probabilities, not text. Here is what that means, how to get it, and what it costs.

TL;DR

  • TypeSafe AI launched Jev on 16 September 2026 with $40M in seed funding.
  • Jev takes a block of state plus typed questions and returns a choice, a score, or a probability. It never returns free text, so it cannot produce a type error or an invented category.
  • Typical latency is around 100 ms. Input is $0.042 per million tokens and output is free.
  • It cannot write, explain, count, or reason. Use it for high-volume bounded decisions and keep an LLM for everything else.
  • Access is waitlisted at typesafe.ai. SDKs exist for JavaScript, Python, and the Vercel AI SDK.

The problem every LLM pipeline has

Picture a support inbox at 2 a.m. Three hundred tickets land at once. Your job is not to reply to them. Your job is to sort them: billing or bug, urgent or not, refund or escalate.

For two years the standard answer has been "send each one to an LLM with a JSON schema and parse the result." It works, mostly. Then one night the model wraps the JSON in markdown fences. Another night it invents a category that was never in the schema. Each ticket takes several seconds and costs a few cents, and you are paying for output tokens the model spends explaining itself.

That is the gap TypeSafe AI decided to close. The company came out of stealth on 16 September 2026 with $40M in seed funding led by DCVC. It was founded by Diogo Almeida, an ex-OpenAI researcher and co-inventor of RLHF, together with Erik Gafni and Sasha Sheng.

Their first model is called Jev, and they call the category a System One model. The name is borrowed from Kahneman: fast, intuitive judgement rather than slow deliberate reasoning. Jev does not write. It decides.

What a System One model actually is

You give Jev two things:

  1. State: a block of context. A ticket, a log line, a user message, a game frame.
  2. Questions: a set of typed questions with the allowed answers defined in advance.

Jev evaluates every question in parallel and returns structured answers with calibrated probabilities and a confidence score. There is no string generation and nothing to parse. Because the answer space is fixed up front, a type error is impossible by construction, and the model cannot hallucinate a category that does not exist.

Three question types are supported:

Type Returns Example question
Noul A probability from 0 to 1 "Is this ticket urgent?"
Choice Selected option plus probabilities for every option plus confidence "Which team handles this: billing, technical, sales, spam?"
Score Position on an ordered scale plus probabilities plus confidence "Severity: cosmetic, workaround exists, blocking"

Choice questions support up to 255 options.

How to get Jev

Access opened on 15 September 2026 and is still gated by a waitlist, though TypeSafe says it is admitting developers "as quickly as we can."

  1. Join the waitlist at typesafe.ai.
  2. Once admitted, create an API key in the console at console.typesafe.ai.
  3. Read the docs at docs.typesafe.ai.
  4. Install an SDK: 
# JavaScript / TypeScript
npm install @typesafe-ai/sdk

# Python
pip install typesafe-sdk

# Or via the Vercel AI SDK (Node 22+)
npm install ai @ai-sdk/typesafe-ai
Enter fullscreen mode Exit fullscreen mode
  1. Export your key: 
export TYPESAFE_API_KEY=your_key_here
Enter fullscreen mode Exit fullscreen mode

Model routes are jev-latest (stable default), jev-preview (advance builds), and pinned versions such as jev-1.13.0.

Rate limits at launch: 250,000 tokens per second and 1,200 requests per minute.

How to use it

The simplest possible call, with no SDK at all:

curl -s https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Order status inquiry",
    "questions": {
      "intent": {
        "type": "choice",
        "instructions": "What does the user want?",
        "criteria": {
          "order_status": "Where is my order",
          "return": "Return or exchange"
        }
      }
    }
  }'
Enter fullscreen mode Exit fullscreen mode

The same thing in JavaScript, asking two questions at once:

import { choice, score, TypeSafeClient } from '@typesafe-ai/sdk'

const client = new TypeSafeClient()

const { answers, model, usage } = await client.systemOne({
  state: { ticket: 'Export button crashes in Safari' },
  questions: {
    category: choice('What kind of ticket?', {
      bug_report: 'Something is broken',
      feature_request: 'Asks for a new feature',
      billing: 'Payment issues',
      other: null,
    }),
    severity: score('How severe?', [
      'Cosmetic issue',
      'Broken feature, workaround exists',
      'Blocking issue',
    ]),
  },
})

console.log(answers.category.choice)   // "bug_report"
console.log(answers.severity.score)    // 1
Enter fullscreen mode Exit fullscreen mode

And in Python:

from typesafe_sdk import Choice, TypeSafeClient

client = TypeSafeClient()

response = client.system_one(
    state="I was charged twice. Please refund.",
    questions={
        "department": Choice(
            instructions="Which team handles this?",
            criteria={
                "billing": "Charges, invoices, refunds",
                "technical": "Bugs and problems",
            },
        ),
    },
)
print(response.answers["department"].choice)   # "billing"
Enter fullscreen mode Exit fullscreen mode

Three habits TypeSafe recommends:

  • Fan out. Ask every independent question in one call. Each extra question costs only its own tokens, and they are all evaluated in parallel.
  • Gate on confidence. High confidence: act automatically. Medium: ask the user to confirm. Low: hand to a human.
  • Compose in code. Split a multi-factor judgement into several Scores and weight them in your own logic rather than asking one giant question.

Sample "prompts"

Jev does not take prompts in the chat sense. It takes state plus typed questions. Here are five patterns that map cleanly onto it.

1. Support ticket routing

state: "App freezes when I open the camera on iPhone 15. Started after last update."
questions:
  department  (choice): billing | technical | sales | spam
  urgency     (score):  low | medium | high | critical
  needs_human (noul):   "Does this need a human reply within the hour?"
Enter fullscreen mode Exit fullscreen mode

2. Content moderation guardrail

state: <user comment>
questions:
  is_spam        (noul): "Is this comment spam or promotional?"
  is_harassment  (noul): "Does this target another user?"
  action         (choice): allow | hide | flag_for_review
Enter fullscreen mode Exit fullscreen mode

3. Lead scoring in a CRM

state: { company: "...", message: "...", pages_visited: [...] }
questions:
  intent    (choice): browsing | comparing | ready_to_buy
  fit       (score):  poor | ok | strong
  follow_up (choice): none | email | call_today
Enter fullscreen mode Exit fullscreen mode

4. Agent tool selection

state: <last user turn + available tools>
questions:
  next_tool (choice): search_web | read_file | run_code | ask_user | finish
  is_done   (noul):   "Has the user's request been fully satisfied?"
Enter fullscreen mode Exit fullscreen mode

5. Game or robotics control loop

TypeSafe demoed Jev playing Doom. The state is the current frame description and the question is a Choice over the available inputs, evaluated every tick. Latency in the 100 ms range is what makes this feasible.

Isn't this just structured outputs?

This is the first question every developer asks, and it is a fair one. JSON mode, tool calling, Zod schemas with the Vercel AI SDK, and libraries like Instructor all constrain an LLM's output to a shape you define. So what is different?

LLM with structured outputs Jev
How the answer is produced Generated token by token, then validated against your schema Evaluated directly over the fixed answer space, no generation
Type safety Enforced by a grammar or a retry loop after the fact Guaranteed by construction
Probabilities Not exposed, or only as raw logprobs you post-process yourself Returned for every option, plus a separate calibrated confidence
Multiple questions Sequential, or one large schema the model fills in order All questions evaluated in parallel in one call
Latency Seconds Tens to hundreds of milliseconds
Can explain itself Yes No

Structured outputs make an essay-writer fill in a form. Jev skips the essay. The practical result is that you get calibrated probabilities for free, which is what lets you build confidence gates and escalation paths without extra prompting or a second model call.

Difference in output

This is the heart of it. Here is what a frontier LLM gives you for the billing ticket:

Based on the message, this appears to be a **billing** issue since the
customer mentions being charged twice and requests a refund. I would
route this to the billing team.

{"department": "billing"}
Enter fullscreen mode Exit fullscreen mode

You now have to strip the prose, find the JSON, parse it, validate that "billing" is a real option, and hope nothing changed between runs.

Here is what Jev gives you:

{
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.84, "technical": 0.15 },
      "confidence": 0.6
    }
  },
  "model": "jev-1.13.0",
  "usage": { "input_tokens": 210, "output_tokens": 31 }
}
Enter fullscreen mode Exit fullscreen mode

Three things to notice:

  • The answer is already typed. choice can only ever be one of the keys you defined.
  • You get the whole distribution, not just the winner. That 0.15 on "technical" is useful signal for routing a copy to a second queue.
  • You get a separate confidence score. Probabilities tell you which option; confidence tells you whether to trust the call at all.

What you do not get is a reason. Jev cannot explain itself, write a reply, summarise, count, do arithmetic, compare dates, or look at images. If you need any of that, you still need an LLM. TypeSafe is explicit that the intended pattern is hybrid: let Jev make the cheap, fast, bounded decisions and escalate low-confidence or open-ended cases to a text model.

There is also an accuracy trade-off. On TypeSafe's own benchmark, Jev scores 67.8% against 74.1% for the top-tier reasoning model they compared against. Roughly six points behind, in exchange for the speed and cost below.

Difference in cost

Launch pricing:

Jev
Input tokens $0.042 per million
Output tokens Free
End-to-end latency 70 to 500 ms, typically around 100 ms

Compared against frontier LLMs on a single classification case, using the numbers DataCamp reported:

Model Cost per case Latency per case
Jev $0.0004 0.4 s
GPT-5.6 Terra $0.0304 10.1 s
Claude Opus 5 $0.1761 37.8 s

At those numbers, a million routed tickets cost about $400 on Jev versus about $30,000 on GPT-5.6 Terra. Tom's Hardware summarised TypeSafe's headline claim as 193x faster and 445x cheaper. Your mileage will vary with state size, and the comparison is against full reasoning models rather than a small classifier, so read it as an order-of-magnitude story rather than a precise benchmark.

One honest caveat from TypeSafe themselves: they cannot yet prove the pricing is not subsidised. A $40M seed round buys a lot of runway, and it is reasonable to expect the number to move once the waitlist opens fully.

Should you care?

If your AI usage is mostly "read this thing and pick one of N labels," yes. That workload is enormous, it is currently overserved by generation models, and it is where the margin is going to get squeezed first.

If your AI usage is mostly writing, reasoning, or anything that needs a rationale, Jev is not your model. But it might be the thing that decides which of your expensive models to call, and that alone can cut a bill in half.

The Doom demo is the tell. Nobody needs an essay every 16 milliseconds. Sometimes you just need the model to press the right button.

Sources

📘 Go Deeper: Building AI Agents: A Practical Developer's Guide

185 pages covering autonomous systems, RAG, multi-agent workflows, and production deployment, with complete code examples. Jev-style decision models slot straight into the routing and tool-selection patterns covered in the book.

Get the ebook →

Enjoyed this article?

I write daily about AI tools, AI agents, and iOS development with AI, practical tips you can use right away.

  • Follow me on Dev.to for daily articles
  • Follow me on Medium for more stories
  • Connect on Twitter/X for quick tips

If this helped you, drop a like and share it with a fellow developer!

Top comments (0)