What is Jev?

Jev is a new AI model from a startup called TypeSafe AI. It launched into early access in September 2026 and everyone is talking about it because it is deliberately not a chatbot.

TypeSafe calls this a “System One model” — the fast, gut-feeling part of thinking, not the slow, talky part. It’s built for other programs to ask it quick questions, thousands of times a second: which team gets this ticket, is this a spam message, is this tool call dangerous, which agent should go next.

Three things to know before you use it: it’s closed-source and API-only (no downloading the model), it’s US-hosted so don’t send it sensitive data, and it can still pick the wrong answer — it just can’t pick an answer you didn’t offer.

An example: my question

Here is the question that started this page:

Let’s see why, with the four agents drawn as four helpers.

You have four helpers

Imagine four friends in a room. Each one is good at one thing. When a new job comes in, somebody has to decide who gets it.

Jev is a helper who can’t talk

Jev never writes sentences. Jev can only do one thing: you show Jev a message and a list of choices, and Jev points at one choice and tells you how sure it is. That’s it. No chatting, no explaining, no making things up — because Jev literally cannot say anything that isn’t on your list.

That sounds like a small thing. It is exactly the thing an orchestrator needs most, and it happens in a fraction of a second for a fraction of a cent.

Try it: who gets this job?

So is Jev the orchestrator?

Half right. There are two different jobs hiding inside the word “orchestrator”:

So the picture is: your orchestrator is a small loop of normal code. Every time it has to make a fuzzy decision, it asks Jev instead of writing a giant if-else or calling a slow chat model.

How one turn goes

1. A message arrives. Could be from a user, could be output from one of your agents saying “I’m done, here’s what I found.”
2. The boss asks Jev. “Here’s the message. Which of these four should take it next? Also: does it need a human?”
3. Jev points. Tester, 91% sure. Human needed: 4%.
4. The boss hands off. Your code calls the Tester agent with the message. If Jev had been under, say, 60% sure, the boss asks a person instead.
5. Repeat. Tester finishes, its output becomes the next message, back to step 2.

Three kinds of questions Jev can answer

The grown-up version

This is what the boss actually sends to Jev for one turn. Notice the four helpers are just the four keys under criteria.

POST https://api.typesafe.ai/v1/systemone

{
  "state": "Tests in PaymentServiceTest are failing after the refactor. Stack trace attached.",
  "model": "jev-latest",
  "questions": {
    "next_agent": {
      "type": "choice",
      "instructions": "Which agent should handle this next?",
      "criteria": {
        "planner":  "Vague or large request that needs breaking down",
        "builder":  "Clear code change to implement",
        "tester":   "Failing tests, missing coverage, verification",
        "reviewer": "Finished work that needs a quality check"
      }
    },
    "needs_human": {
      "type": "noul",
      "instructions": "Is this too ambiguous or risky for an agent to handle alone?"
    }
  }
}

And what comes back — no prose, just a decision your code can branch on:

{
  "answers": {
    "next_agent": { "choice": "tester", "probabilities": { "tester": 0.91, "builder": 0.06, "reviewer": 0.02, "planner": 0.01 }, "confidence": 0.88 },
    "needs_human": { "noul": 0.04 }
  }
}

Then the boss does the handoff:

if (needsHuman > 0.5 || confidence < 0.6) askAPerson(message);
else agents.get(nextAgent).run(message);

“It uses fewer tokens” — is that true?

Half true, and the half that’s true is the half that mattered. Think of tokens as words you pay for. Every AI model charges for the words you send in and the words it sends back — and the words coming back cost about five times more.

The savings people forget to count

1. No “you are a router” boilerplate. With a chat model you spend 200–500 tokens every call explaining the rules and the JSON schema. With Jev the schema is the request.
2. No retries. Jev can’t return broken JSON or add commentary, so you never re-send the whole prompt because the model wrapped its answer in prose.
3. No thinking tokens. A reasoning model can burn 2,000 tokens deciding between four agents. Jev can’t.

What your orchestrator would pay

The honest caveats

When Jev is the wrong helper