Software needs decisions, not chat: testing TypeSafe's Jev inside Empryo

Your coding agent makes dozens of small calls every turn. Which skill should it load for this request? Which search result is the one that matters? Did that API call fail because of a rate limit you can retry, or a bad parameter you can't? Does this click need your approval?

Most agents answer those questions in one of two ways. They ask a large model and pay in seconds and dollars. Or they match text patterns and hope the patterns hold.

On September 15, TypeSafe AI launched Jev, a model built for a third way. Jev doesn't write text at all. You give it a state and a list of typed questions. It returns a choice, a probability for each option, and a confidence score, usually in 70 to 300 milliseconds, at $0.042 per million input tokens.

I wired Jev into Empryo at five decision points and tested eight possible jobs on real coding sessions. This post covers what I built, how it compared with frontier models, and where plain code still did better.

What a decision model doesLink to this section

A large language model predicts the next token. That's the right design for prose, explanations and code. But most of the small steps inside an agent don't need prose. They need a decision: pick one option from a list, answer yes or no, or say how sure you are.

Jev skips the text. TypeSafe calls this a "System One" model, after the fast, intuitive kind of thinking. You send an input state, such as a request, a list of search results or an error payload, plus structured questions. Jev answers all of them at once and returns calibrated probabilities. Because it produces no text, there are no output tokens to pay for.

A search-ranking request looks like this:

{
  "state": { "request": "find files calculating token cost" },
  "questions": {
    "target_file": {
      "type": "choice",
      "instructions": "Which file should the agent inspect first to find token cost calculations?",
      "criteria": {
        "billing/cost-alerts": "export function costAlerts(n)",
        "billing/cost-calc":   "export function costCalc(n)",
        "ui/cost-panel":       "export function CostPanel()"
      }
    }
  }
}

{
  "answers": {
    "target_file": {
      "choice": "billing/cost-calc",
      "confidence": 0.81,
      "probabilities": {
        "billing/cost-calc": 0.71,
        "ui/cost-panel": 0.17,
        "billing/cost-alerts": 0.12
      }
    }
  },
  "usage": { "input_tokens": 404, "output_tokens": 0 }
}

That answer took 266 milliseconds and cost $0.000017.

Five places Jev helps inside EmpryoLink to this section

I added Jev to five spots where a quick judgment about meaning helps the agent move faster.

Each one has its own switch, and all of them are off by default. With them off, Empryo behaves exactly as it did before.

Computer use without a frontier model on every clickLink to this section

The common assumption is that driving a user interface needs a large model on every step: take a screenshot, reason about it, stream a reply.

In practice, most interface steps aren't hard reasoning problems. They're choices from a list of on-screen elements: which button to click, which menu to open, which field to focus. Jev makes those choices in a few hundred milliseconds and reports how confident it is. If confidence drops below your threshold, or a field needs free-form text, the pilot hands control back to your main model.

The approval guard works alongside it. It checks whether the next click could trigger a payment, a deletion, a send or a security change. It can only add an approval prompt, never remove one. So the worst case is an extra question, not a missing safeguard.

Failure triage: Jev vs. frontier modelsLink to this section

When a model provider returns an error, the agent has to choose: retry, or stop the turn. Retrying a rate limit saves the session. Retrying a malformed request just burns time and money.

I tested Jev and several frontier models on 102 real provider failures from my own session logs. The correct answer for each came from the provider's documented error types.

Jev got all 102 right with a median of 273 milliseconds. That matched the best frontier models at about a fifth of their latency and a small fraction of their cost.

The test also exposed a bug in my own code. I looked at the four cases where Jev beat Empryo's built-in pattern check. The pattern for HTTP status 429 was also matching the digits 429 inside tool version names such as text_editor_20250429. Once I made the pattern match 429 only as a whole number, the free built-in check scored 102 of 102 too. The decision model ended up useful as a reference for testing ordinary code.

Where plain code still winsLink to this section

I tried Jev on eight jobs and dropped three after measuring them.

Here is why:

1. Ordering individual grep lines. Letting Jev rank single matching lines dropped top-3 accuracy from 78.6% to 74.1%. One line of code carries too little meaning on its own. Where the match sits in the line was a better signal.
2. Deciding pass or fail in a review loop. If a model calls a failing report a pass, the loop stops on broken code. Jev agreed with human reviewers on 12 of 20 unclear cases. For checking correctness, that isn't good enough.
3. Predicting the next tool call. Counting keywords in the prompt beat both Jev (26% vs. 15%) and the frontier models. Early in a task, the prompt usually doesn't say which tools will be needed. That only becomes clear after the agent reads some files.

The pattern held every time. A decision model helps when it has to understand what words mean and the words don't match exactly. When an index, a graph or a simple rule already captures the answer, plain code is faster, cheaper and more reliable.

How the integration behavesLink to this section

I built the integration around three rules:

• Off unless you turn it on. Every feature defaults to off. Without a key, Empryo makes no TypeSafe calls and nothing changes.
• A bad key stops being called. If your key is rejected or out of credit (HTTP 401, 402 or 403), Empryo pauses TypeSafe calls for 30 minutes and uses its built-in logic instead. A run of outages pauses it for a shorter time. The agent never hangs or retries in a loop on a broken key.
• Every decision is visible. Each Jev call shows up in the chat with its cost, and it appears in your usage totals under its own model name. It's never hidden inside another number.

Turning Jev onLink to this section

You need a TypeSafe API key. Then turn on the decisions you want Jev to handle.

/typesafe

export TYPESAFE_API_KEY=apikey_...
empryo --headless --events "find where token cost is computed"

{
  "typesafe": {
    "enabled": true,
    "rerank": true,
    "rerankMode": "apply",
    "skillSuggestion": true,
    "errorTriage": true,
    "computerUseGuard": true,
    "pilot": false
  }
}

SummaryLink to this section

Large language models are excellent at writing code and reasoning through design. Using them for every small decision inside an agent is slow and expensive.

Decision models like Jev offer another option: typed answers with honest confidence, in milliseconds, for almost nothing. Use them where the agent has to judge meaning. Keep plain code where a rule already works. The agent gets faster and cheaper, and you can still see every decision it made.