On September 15, 2026, a startup called TypeSafe AI emerged from two years of stealth with a model that takes a bet most AI companies refuse to make: Jev does not generate text at all.

While every major lab races to make language models larger, faster, and less prone to hallucination, TypeSafe’s founder Diogo Almeida, a co-inventor of RLHF and InstructGPT at OpenAI, decided that the text-generation paradigm itself is the bottleneck for enterprise automation. Jev is the first “System One Model”: an API that takes structured state in and returns typed probabilistic decisions out, with no natural language anywhere in the response.

The company backed the launch with $40 million in seed funding led by DCVC.

What Problem Does Jev Solve?

Enterprise AI adoption has stalled at a specific failure mode: teams build a pilot that works most of the time, then cannot make it work reliably enough to deploy in production. The culprit is almost always the same. Somewhere in the automation pipeline, an LLM returns a string, that string has to be parsed and validated, and occasionally the string is wrong in a way the parser does not catch.

Jev removes that failure mode entirely. Because the model only ever returns typed values (a choice from a list, a probability score, a yes/no with calibrated confidence), there is no string to parse and no way for the model to return an unexpected type. TypeSafe states this is not an empirical claim but a mathematical guarantee: schema violations are impossible by construction.

This is not a minor ergonomic improvement. For enterprise AI agent deployments, type safety is the difference between a workflow that requires human review on every edge case and one that can run fully autonomously. The adoption readiness gap at most enterprises traces directly to the reliability problem Jev is designed to solve.

How Jev Works

Jev is built on a new training method TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD). Unlike RLHF, which optimizes for human preference on text outputs, RLCD optimizes for calibration: the model’s stated confidence should match its actual accuracy. A model that says it is 90% confident should be right 90% of the time.

The model also uses parallel sampling rather than the autoregressive token-by-token generation that drives all major LLMs. Because the outputs are not sequential (each typed answer is independent of the others), all answers in a query can be computed in a single pass. This is the primary reason for Jev’s latency advantage.

A developer query looks like this in practice: you provide a state (a support ticket, a JSON object, any unstructured text) and a list of typed questions. Each question specifies its type (Noul, Choice, Score) and its possible values. The model returns a distribution over the possible answers for every question simultaneously, with a confidence score for each.

// Example: route a support ticket
state: "My card was charged twice for the same order."
questions: [
  { type: "choice", key: "department", options: ["billing", "technical", "sales"] },
  { type: "noul", key: "urgent" },
  { type: "score", key: "sentiment", scale: [1, 5] }
]

// Response (70-500ms)
{
  "department": { "billing": 0.91, "technical": 0.07, "sales": 0.02, "confidence": 0.87 },
  "urgent": { "yes": 0.72, "confidence": 0.80 },
  "sentiment": { "score": 1.8, "confidence": 0.75 }
}

Performance: Jev vs. Frontier LLMs

The table below summarizes TypeSafe’s published performance data from their workflow evals site, benchmarked against GPT-5.6 Terra, GPT-6 Astra, and Fable 5.1. Reference labels use the average of Astra and Fable at high thinking. TypeSafe acknowledges these figures may be at the high end of real-world gains.

MetricFrontier LLMsJev
End-to-end latency3 to 329 seconds70 to 500 ms
Speed advantagebaseline40x to 200x faster
Input cost$0.20 to $10 / MTok$0.042 / MTok
Output cost$0.50 to $50 / MTok$0 (free)
Type errorsYes (unavoidable)0% (guaranteed)
HallucinationPossibleNot applicable
CalibrationInconsistentRLCD-optimized
Output formatString (parse required)Typed values (direct use)

On the four representative workflows (expense claims, security incidents, invoice processing, customer service), TypeSafe’s combined speed and cost advantage on the Pareto frontier versus all tested frontier models is 193.6x faster and 444.6x cheaper on average. The evals compare against GPT-6 Astra and Fable 5.1 as reference, which TypeSafe notes biases the reference toward OpenAI and Anthropic’s models.

The comparison to GPT-5.6 Terra used in the live demo showed Jev returning a response in 0.114 seconds versus 8.566 seconds for Terra.

Enterprise Use Cases That Actually Matter

TypeSafe’s benchmark harnesses reveal where Jev fits and where it does not. The four workflows they published show what the model does well:

Security incident triage. A security alert fires. Given the alert and the machine’s profile, route it to close, pass to analyst, or contain immediately. Every second of latency matters here, and a wrong string parse can open a gap in response.

Agent trace observability. A support agent finishes a customer interaction. Given the full run including every tool call, decide whether a human needs to review it and how urgently. This is a direct complement to AI agent certification workflows.

Invoice processing. A vendor bill arrives with the underlying order and delivery record. Decide pay, hold, or return. The decision logic is entirely deterministic given the data, making it a good fit for typed outputs.

Customer service routing. Given a thread and account state, decide the next action. TypeSafe’s customer service workflow decomposes this into eleven parallel questions, including intent, frustration level, urgency, fraud flags, and retention risk, all returned in a single call.

What Jev cannot do: write an email, generate code, produce a summary, or handle any task that requires novel text. It is a decision layer, not a generation layer. Teams building agentic enterprise systems will likely use Jev alongside a generation model rather than replacing one with the other.

The Jevons Paradox Bet

The model is named after William Stanley Jevons, the 19th-century economist who argued that efficiency gains in coal usage led to increased coal consumption rather than reduced demand. TypeSafe’s naming signals a deliberate bet: if structured decisions become two orders of magnitude cheaper and faster, the number of decisions automated will increase by at least two orders of magnitude, and total token volume will rise, not fall.

The comparison to energy infrastructure is intentional. TypeSafe believes System One Models will eventually be embedded in every business workflow the way electricity is embedded in every appliance, running constantly in the background, making small decisions millions of times per hour. Today’s use cases (customer service routing, invoice approval) are the first applications of that infrastructure.

What Enterprise AI Builders Should Do Now

Three immediate steps for teams evaluating Jev:

  1. Audit your current LLM calls for decision-shaped workloads. Any call where your code parses the output to extract a classification, score, or yes/no is a candidate to replace with a Jev workflow. Look for calls with structured prompts, regex parsers after the call, or retry logic to handle unexpected output formats.

  2. Benchmark latency-sensitive pipelines. If you have automation that cannot tolerate second-scale LLM latency, run a workflow harness against Jev’s early access API. The cost of testing is low ($0.042/MTok input, free output).

  3. Plan for a layered model architecture. Generation and decision are different problems. Teams that redesign workflows around AI increasingly use specialized models for each step rather than routing everything through one frontier model.

Jev is in early access as of September 15, 2026. Access is via the waitlist at typesafe.ai. TypeSafe has not published a general availability date.