Jev for Agents: How Jev Powers Real AI Agents

Jev is TypeSafe AI's first System One Model

TypeSafe describes Jev as its first public System One Model: a model optimized for automation tasks such as classification, routing, scoring, verification and choosing between a predefined set of actions. (TypeSafe AI)

That makes Jev especially interesting for AI agents. An LLM can handle planning, reasoning and generation, while Jev handles the repeated decisions inside the loop:

The builds above show this pattern in practice across browser agents, coding agents, model routers, tool selection, computer use and agent guardrails.

For a closer look at a proposed coding-agent harness, read the Jev Engineering for Coding Agents PDF guide. It separates the independent PDF's design ideas from official Jev documentation and measured results.

Is Jev an LLM?

Not in the conventional sense.

Traditional LLMs are optimized to generate strings: explanations, code, chat responses and other sequences of tokens. Jev gives up general string generation and instead produces type-safe structured values with probabilities and confidence scores.

TypeSafe summarizes the distinction as unstructured state going in and typed probabilistic decisions coming out. (TypeSafe AI)

A simple way to think about the difference is:

This does not mean Jev replaces an LLM everywhere. Many of the most interesting Jev agent architectures combine both.

• The LLM: Handles open-ended intelligence & high-level synthesis.
• Jev: Handles bounded, repeated decision points.
• Code: Executes the result deterministically.

How Jev works: state in, typed decisions out

A Jev call starts with state.

That state might be: the current DOM of a browser, a coding task, a list of available MCP tools, an email, a pull request, a proposed agent action, or the current state of a workflow.

The developer also defines the decisions Jev is allowed to make.

For example:

State: The user asked to find a flight to London.
Available actions:
- search
- click
- type
- go_back
- finish

Jev:
search   → 0.91
click    → 0.04
type     → 0.02
go_back  → 0.01
finish   → 0.02

The browser automation framework performs the action. Then the next state is sent back into the loop.

Jev decides. Code and tools act.

Where Jev fits inside an AI agent

A common pattern in production systems: the LLM handles open-ended planning and synthesis, Jev handles repeated bounded decisions and verification, and deterministic software executes actions.

Why TypeSafe built Jev

TypeSafe AI is the company behind Jev.

TypeSafe introduced Jev publicly on September 15, 2026 as its first System One Model. The company says it built a new model architecture, parallel sampling system and training approach called Reinforcement Learning for Calibrated Decisions (RLCD), with the goal of making AI intelligence easier to compose directly into software. (TypeSafe AI)

The idea is different from simply asking a chatbot to return JSON.

RLCD: Reinforcement Learning for Calibrated Decisions

With Jev, the possible output types are defined in advance, and the model returns probabilities that software can use when deciding whether to act automatically, retry, route elsewhere or ask for human review. TypeSafe describes this as “machine-native intelligence” designed for automation. (TypeSafe AI)

JevForAgents is independent from TypeSafe AI. We collect real implementations, demos, GitHub projects and developer reports to understand how Jev is actually being used inside agent systems.

Jev API

Jev is available through TypeSafe's API. The current API exposes System One requests that can ask yes/no questions, select choices, evaluate scores and return structured results. (Typesafe API)

Jev with existing agents

A typical agent integration follows four steps:

1. 1. Collect application state

   Gather the DOM, log output, user prompt, or active context.

2. 2. Define the allowed decision

   Enumerate valid action choices, boolean checks, or scoring scales.

3. 3. Send both to Jev

   Obtain deterministic typed results and calibrated probabilities in 70–250ms.

4. 4. Let software act on the returned probabilities

   Execute tools, trigger fallback logic, route requests, or ask for human review.

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "DOM: <button id=\"book-ticket\">Book Now</button> | User: \"reserve 2 seats\"",
    "questions": {
      "next_action": {
        "type": "choice",
        "instructions": "Which browser action fulfills the user intent?",
        "options": ["CLICK_BOOK", "SCROLL_DOWN", "ASK_CLARIFICATION"]
      }
    }
  }'

{
  "answers": {
    "next_action": {
      "selected": "CLICK_BOOK",
      "probabilities": {
        "CLICK_BOOK": 0.942,
        "SCROLL_DOWN": 0.041,
        "ASK_CLARIFICATION": 0.017
      },
      "confidence": 0.942
    }
  },
  "latency_ms": 84,
  "type_error": false
}

The important design question is not simply:

“Can Jev do this?”

It is:

“Is this a repeated, bounded decision that does not require a full generative model?”

If yes, it is a strong candidate for experimentation.