Build Ultra-Fast AI Agents Powered by Jev

Jev is TypeSafe AI's System One model. Instead of generating text, it evaluates a state — a paragraph, a JSON object, or a list of strings — against a map of typed questions and returns one structured answer per question in a single parallel pass. It is not a chat model and it does not write prose; it decides. Jev Agent is an independent platform built around that model, and it is currently in early access. This page covers what the model does, why its design fits the fast inner loop of an AI agent, and the agent architectures you can build on it.

TypeSafe reports Jev's end-to-end latency at 70–500ms and prices it at $0.042 per million input tokens with output free, in its System One announcement. That combination is what makes it practical to call on every step of an agent loop, instead of reserving a large model for steps that do not need one.

Why Jev Fits the Decision Loop of AI Agents

Daniel Kahneman split human thinking into System 1, fast and automatic, and System 2, slow and deliberate. Most production agents lean on a single System 2 model for every step, even the steps that only need a fast pick-one or yes/no answer: was this ticket urgent, which tool should run next, did the last action succeed. That mismatch is expensive and slow. TypeSafe Jev models close it by running as System 1, non-generative inference: instead of writing a token at a time, they read a state and answer a fixed set of questions in one pass, attaching a confidence value to each answer.

TypeSafe built it as a different kind of AI: Jev returns a typed decision instead of generated text, so there is no output schema to validate and no free-form string to parse. Its documented interface accepts text-only input and answers three kinds of Choice, Score, Noul questions: a Choice picks one label from a closed set, a Score returns a number in a range, and a Noul returns the probability that a statement about the state is true. Once you have access, an agent loop can call the Jev AI API for the classification and routing steps in each iteration, and save a larger System 2 model for the steps that genuinely need open-ended reasoning.

What You Can Build with Jev

Try Jev in the Playground

Run four illustrative samples right on this page before you request access, each built from a common agent scenario: routing a support ticket, scoring incident urgency, deciding a refund, and triaging a queue. Each sample is hand-written to follow the request and response shape of TypeSafe's published examples — not recorded from Jev — and shows the typed answer, the probability attached to each Choice option, and the confidence value that comes with it.

{
  "model": "jev-latest",
  "state": "Help! My payouts have been failing for 3 days.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "billing": "Payments, invoicing, refunds",
        "technical": "Bugs, outages, integrations",
        "sales": "Pricing, upgrades, new accounts"
      }
    }
  }
}

Jev vs a Traditional LLM Agent

TypeSafe reports these latency and price figures in its System One announcement, and The Rundown AI puts the overall cost advantage at 40–400x cheaper than frontier LLMs. Neither tool replaces the other: the table above is about picking the right tool for each step of a loop, not choosing one model for an entire agent.

Pricing, Benchmarks and How Jev Works

TypeSafe benchmarks show System One running up to 200x faster than LLM inference on System One-shaped queries, inside a documented 40–200x range with a 193.6x result on its own demo workflow, per the System One announcement. For where each figure comes from, what the cost comparison assumes and what TypeSafe has not published yet, Inspect Jev Performance Benchmarks.

If you want to price your own token volume before you commit to a plan, View Jev Pricing Plans and run the numbers through the calculator there — it uses Jev Agent's own plan and pack rates, not TypeSafe's $0.042 list price. And if you are wondering how a non-generative model produces a typed decision at all, rather than a paragraph of text, What is the Jev Model? explains how System One works, from the state it reads to the answer it returns.