Dev.to AI πŸ€– Ai πŸ‘ 0 πŸ“– 6 min read

System One Models: The AI That Decides Instead of Talking

Most of the time we call an LLM from software, we don't actually want a conversation. We want an answer: is this ticket urgent, which team should get it, is this request safe to run? We ask a model that can write essays

Most of the time we call an LLM from software, we don't actually want a conversation. We want an answer: is this ticket urgent, which team should get it, is this request safe to run? We ask a model that can write essays and debug code to do the job of an if-statement, then wait seconds for it to produce text that we parse back into a decision.

Recently, a new category of models has appeared that tackle exactly that mismatch. It's called a System One model, and it's worth understanding before it quietly shows up in your architecture.

Fast and slow, applied to AI

The name comes from Daniel Kahneman's Thinking, Fast and Slow. System One is fast, intuitive judgment. System Two is slow, deliberate reasoning.

General-purpose LLMs are System Two machines. They generate one token at a time, reason through steps, and produce open-ended text. That's exactly what you want for drafting a document or working through a hard bug. It's overkill and slow for a yes-or-no routing decision.
A System One model flips the design. Instead of generating text, it takes in some context and returns a structured decision, in a single pass, with a probability attached.

How they differ from a general LLM

The clearest example is Jev, by a startup called TypeSafe AI, which raised a $40 million seed round. Its CEO, Diogo Almeida, is a former OpenAI researcher who co-invented the RLHF technique behind ChatGPT.

Here is how it works:

  • You define the possible answers up front. Choices, yes/no questions, or scores on a scale.
  • The model returns those answers directly, in parallel, each with a calibrated confidence score.
  • It cannot write text at all. No emails, no code, no conversation. Its output can only be a valid answer to the questions you defined.

That last constraint is the whole point. Because the output space is fixed, the model skips the token-by-token generation loop. TypeSafe claims responses in 70 to 500 milliseconds and input pricing of $0.042 per million tokens, with output tokens free since there are none.

Note the word "claims." We'll come back to that.

Why developers should care: the problem it solves

Think about where an LLM sits in a typical backend today. A lot of those calls are decisions disguised as text:

  • Ticket triage: classify an incoming ticket by priority and route it to the right queue.
  • Request routing: decide which service, tool, or model should handle a request.
  • Guardrails: check whether another model's output is safe or on-topic before it goes to a user.
  • Real-time scoring: rate leads, alerts, or transactions as they arrive.

TypeSafe describes the role as sitting between hard-coded business logic and a full LLM call, essentially "smart if-statements."

Take a support ticketing system as an example. A new ticket arrives. You need to know: is it a billing issue or a technical one, and how urgent is it? With a chat model, you prompt it, wait a second or more, then parse the JSON it hopefully returns in the right format. With a decision model, you declare the two questions and their allowed answers, and you get back typed results with confidence scores, fast enough to run on every ticket without noticing the latency.

Two practical benefits follow. Speed makes real-time use viable, and the confidence scores let you gate behavior: act automatically when the model is sure, and human-in-the-loop or a heavier model when it isn't.

Trend: It's not just one startup anymore

What makes this a trend rather than a product launch is how fast others moved.

  • OpenAI presented its Decisions API at DevDay, a dedicated endpoint built on a specialized version of GPT-6 Luna. OpenAI says it makes decisions up to 10x faster than calling the same model the usual way.
  • AWS released Strands Decider 2B. Run as a server, it answers at the same /v1/systemone endpoint that TypeSafe introduced with Jev.
  • Others followed. Upstage serves Solar Decide through that schema, Ollama added a /v1/systemone endpoint, and Perplexity, Liquid AI, and Cloudflare all released decision models or APIs in the same window.

There's a subtle difference worth knowing. Jev is a purpose-built model that was never trained to write. OpenAI's approach narrows a general model, constraining GPT-6 Luna to developer-defined questions. The interface looks similar, but the engine underneath is not the same.

The more interesting development is portability. Because several vendors are converging on one API shape, code written against one System One server can often work against another by changing the base URL. That is the same dynamic that made OpenAI's Chat Completions API a de facto standard.

The limitations (read this before you rebuild anything)

This is where a healthy dose of skepticism belongs.

  • The headline numbers are self-reported. TypeSafe's claims of up to 193x faster and roughly 444x cheaper than frontier models come from its own internal evaluations, and the company itself says those are the high end rather than typical results. Similarly, OpenAI's 150 millisecond figure compares its Decisions API against OpenAI's own model doing the same job the slow way, which says little about how it compares with other vendors.

  • "Zero hallucination" doesn't mean "always right". Jev's claim refers to guaranteed schema matching: the model can't return anything outside your defined options. A valid answer is not the same as a correct one. A model can confidently pick the wrong option.

  • Confidence scores need verification. If you plan to automate based on probabilities, you need evidence the probabilities are calibrated.

  • They are not general agents. An academic benchmark called System1-Arena evaluated 30 models on decision tasks. The strongest System-1 models matched fast closed LLMs in accuracy, with better probability estimates and lower latency, which is encouraging for single decisions. But in closed-loop settings, where a model takes a sequence of actions, large open LLMs succeeded most often (up to 32.9%), and small System-1 models rarely succeeded. These models are built for one-shot judgments, not multi-step work.

How I'd think about using them

System One models don't replace LLMs. They split the work. Fast, narrow, well-defined decisions go to a System One model. Open-ended reasoning, writing, and anything ambiguous go to a full LLM, and only when it's actually needed.

A sensible way to start is low risk. Pick one decision in your system that is currently an LLM call or a pile of brittle rules, such as ticket classification or content routing. Run a decision model in parallel with your existing approach, compare the answers, and check whether the confidence scores actually predict when it's wrong. Only then let it act on its own.

The takeaway

For years, the default has been to point the biggest model at every problem. System One models are a bet that a lot of software doesn't need a model that can talk. It needs a model that can decide, quickly, cheaply, and with an honest sense of how sure it is.

The claims still need independent verification, and the limits are real. But with OpenAI, AWS, and others shipping within weeks of each other, this is no longer a single startup's experiment. It's worth a spot on your radar.

What decisions in your stack are currently being handled by a model that talks too much? I'd like to hear where you'd try this first.

My Other Blogs:

πŸ“° Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.