Jev : 200x Faster, 400x Cheaper Than Generative Agent Loops

My agent stack spends most of its money answering questions with five possible answers. Is this ticket urgent? Which model should handle this request? Is this shell command destructive?

None of those decisions require a paragraph, yet they all go to a generative model that writes one anyway.

Tool calling and structured outputs fixed the parsing problem, but they did not fix the generation problem. The model still emits tokens sequentially, even when the answer is a single word. Put that inside a standard agent loop, and the latency and waste compound:

while not done:
    action = llm(context)
    result = run_tool(action)
    context += result

Every pass through that loop calls a model to choose a tool, judge a result, detect risk, or decide if the task is finished. You pay for the input, wait for the sequential generation, and pay more for the output. Then your code parses the result, validates the shape, and retries when it fails.

For a bounded decision with five possible answers, we are paying generative prices for a classification.

What is Jev?

TypeSafe AI recently released Jev, and the reaction was outsized for a model that fundamentally cannot produce “chat.” But that constraint is the point: token-by-token generation is the wrong interface for a bounded decision.

Jev is a system one class of AI models, that takes two inputs: the state (text or JSON describing the situation) and the questions you want answered about that state. Every question declares its answer shape in advance, using one of three primitives.

Choice picks one option from a list you define and returns a probability for every option.

Score places the input on an ordered scale you define.

Noul answers a yes-or-no question by returning the probability that it is true.

{
  "model": "jev-latest",
  "state": "The deploy failed twice and customers are seeing 500s.",
  "questions": {
    "urgent": {
      "type": "noul",
      "instructions": "Does this need attention right now?"
    },
    "owner": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "engineering": "Product failures and outages",
        "billing": "Charges, invoices, and refunds"
      }
    }
  }
}

Jev evaluates every question in the request in parallel. There is no paragraph to interpret, no sequential generation to wait for, and no fabricated third team for the model to invent.

RLCD vs. RLHF: Why Calibration Matters

Standard models are trained with RLHF (Reinforcement Learning from Human Feedback), which optimizes for conversational output a person prefers to read. Persuasiveness and confidence are rewarded. Calibration is not the objective, making overconfidence a predictable side effect.

TypeSafe trains Jev with RLCD (Reinforcement Learning for Calibrated Decisions). It pairs each decision with a confidence estimate and optimizes for whether that estimate matches observed correctness. If Jev reports 90% confidence across a set of answers, roughly 90% of those answers should be right. RLCD fits automated pipelines where the confidence score itself is a variable consumed by your code.

The Probability Distribution is the Feature

Suppose Jev routes a ticket to billing. The output isn’t just a text string; it is a calibrated distribution:

{
  "choice": "billing",
  "probabilities": {
    "billing": 0.56,
    "technical": 0.42,
    "sales": 0.02
  },
  "confidence": 0.17
}

The label tells you what won, but the distribution tells you how close the race was. Here, billing won by only 14 points, with an overall confidence of just 0.17. Routing that ticket automatically based solely on the winning label would be reckless.

This structural reliability shifts the definition of “hallucination”. Jev cannot break the declared output schema, it cannot invent a legal category if you only defined three. It can still confidently choose the wrong valid option, but type safety guarantees your downstream code will not break trying to parse it.

The Four Patterns of Typed Decisions

Because Jev evaluates concurrently and outputs calibrated probabilities, it enables four distinct architectural patterns that compose into highly resilient pipelines:

Intent routing

A fast classifier reads the request and returns a category, difficulty rating, and confidence values. Low-confidence assessments route to a human. Routine requests bypass models entirely and go to deterministic code. Unrecognized categories trigger an explicit fallback.

Speculative fan-out

Waiting to ask a follow up question costs an extra network exchange. Speculative fan out submits every candidate question in one request, computes them concurrently, keeps the branch that applies, and discards the rest.

# Evaluated concurrently in a single network call
if category.choice == "bug_report":
    if bug_severity.score > 1.5 and bug_repro.noul > 0.6:
        route_to_engineering()

Confidence-gated routing

The pattern most teams will adopt first. You read the chosen option and the confidence together, ensuring the risk tier catches a confident wrong branch rather than relying on the model to catch itself.

action = response.answers["intent"]

if action.confidence < 0.6:
    route_to_support_agent(account_id)
elif action.choice == "approve_transfer":
    # Strict comparison for high-stakes actions
    if action.confidence > 0.85:
        approve_transfer(account_id)
    else:
        ask_user_to_confirm("Just to confirm: you want to approve this transfer?")

The threshold is determined by the consequence of the action in your system, not a global constant.

Composite scoring

For decisions depending on several factors, holistic LLM judgments often hide tradeoffs. Composite scoring defines a separate question per factor with its own evidence ladder. It scores them independently, normalizes each to the unit interval, multiplies by role-specific coefficients, and sums them. When a shortlist looks wrong, you tune the math in your code rather than rewriting a prompt.

Control Flow Belongs in Code

Read together, these four patterns describe exactly where a generative model should stop and typed decisions should begin. Classification picks the branch. Fan-out removes the second round trip. Confidence decides whether code or a person acts. Composite scoring keeps multi-factor judgment in weights you can actually review.

In all four patterns, the model supplies the judgment, but the code strictly owns the control flow.

By decoupling decision-making from sequential token generation, TypeSafe AI claims Jev is 193.6x faster and 444.6x cheaper than standard agent loops. When you stop paying generative prices for classification tasks, building reliable, high-speed automated pipelines finally makes economic sense.

What will you build with Jev?

Sources

• TypeSafe AI documentation
• Introducing System One Models & Jev
• Building a harness with Jev