System One models for enterprise AI: the four numbers to finish before one goes in front of traffic

What are System One models for enterprise AI, and what does one decide?#

A System One model answers a typed question with a value your code can branch on and a calibrated probability, at $0.042 per million input tokens. TypeSafe's System One concepts page defines them as "a class of AI models built to make fast, structured decisions that software can use directly". So the answer comes back under the id you chose. It arrives as a yes-or-no probability, a choice with its confidence, or a score.

Because the answer is a value rather than a paragraph, the call sits inside an if. Your code decides what happens next. So the question to ask of a workload is not whether a model can do it. The question is whether the answer is one of a set your code already knows.

For example, the API reference names three question types. So a noul returns the probability that a yes-or-no question is yes. A choice returns one option from criteria you wrote, with a probability for every option. A score rates the state along levels you define. In each case you name the question, and the answer comes back under that same name.

Then the daily bill follows from the price on TypeSafe's models page, at 2,000 tokens of state per document.

What does a typed decision layer save, and who has to be hired to run it?#

Say a support desk runs 20,000 tickets a day: that is 120,000 typed decisions for USD 1.68, and no machine-learning hire to keep it running. In this example each ticket carries about 2,000 tokens of state. It needs six decisions: queue, severity, product area, language, refund risk and duplicate. Batched into one call per ticket, that is 40 million input tokens a day. At TypeSafe's published $0.042 per million, the day costs USD 1.68.

For example, asked as six separate calls instead, the same desk re-sends the state with every one. Say the same volume again: the day then costs 240 million input tokens and USD 10.08. The work is identical. Only the shape of the request changed.

Therefore the outcome worth reporting upward is not accuracy. It is that the decision layer costs under two dollars a day at that volume. And it is that no specialist has to be hired to hold it, because the questions live in your own schema rather than inside a model. That matters, because expertise is what most firms say stops them.

What has to be in place before an enterprise can run one at all?#

Adoption tracks size rather than enthusiasm: 55.03% of large EU enterprises use at least one AI technology against 17% of small ones. Eurostat published those shares for 2025, with data extracted in December 2025. So the gap is about capacity rather than appetite.

So what decides whether this ships is not the model. It is three things a firm either has or does not have. First, a job already written as a decision, with the options named. Second, a schema somebody owns, because the questions live in your repository. Third, a queue a person watches, because some share of answers will land below the threshold by design.

TypeSafe's how-to-build page puts the same rule on the model's side: keep code in control and give the model narrow, structured decisions. When any of the three is missing, the work is not modelling work. Instead it is the ordinary work of writing down how a decision is already made.

In practice the schema is where the effort lands. Because the criteria are what the model reads, each option needs a description a stranger could apply. Boundary cases belong in the criteria too. When an answer looks wrong and you find yourself explaining what you really meant, the jaggedness page says that explanation was the missing half of the instruction.

Which enterprise jobs does a typed decision fit, and which ones does it not?#

Classification, routing, extraction, scoring and re-ranking fit; re-ranking a shortlist moved top-1 accuracy from 5% to 18% across 40 CLERC queries. TypeSafe's re-ranking cookbook reports that run, along with top-10 accuracy rising from 38% to 62% over the same 40 queries.

So a job fits when its answer is a value from a set the code already knows. Re-ranking is the clearest case. The candidates exist already, the model only orders them, and the ordering is checkable. In practice that is why it gains more than a paragraph about the candidates ever could.

The jobs that do not fit are the ones where the answer is open-ended, or where the value has to be computed rather than judged. Those come back later, in the exit.

Meanwhile routing is the other everyday case. A ticket arrives, the queues exist already, and the decision is which one. Because the options are yours, the answer is checkable against what the desk actually did. As a result the same log that measures the model also measures the threshold above it.

Why does asking thirteen questions in one call change the bill?#

The same thirteen questions over the same article cost USD 0.00609 as thirteen calls and USD 0.000497 as one, because the state is sent once. TypeSafe's parallel questions cookbook runs exactly that comparison over one article.

The reason is mechanical. Every call carries the whole state. So thirteen calls carry thirteen copies of the article, and one call carries a single copy. Because the questions themselves are small, cost follows how often the state is re-sent rather than how many questions are asked.

As a result, the first design decision is not which model to use. It is where the batch boundary sits: one call per document with every question attached, rather than one call per question.

What does the same batching do to the clock a person is watching?#

Thirteen separate calls took 2.71 seconds and the single batched call took 0.27, which is the difference between a spinner and an answered screen. The same cookbook run reports both times.

Because batching removes twelve round trips as well as twelve copies of the state, the clock moves with the bill. So a screen that waits on a batch of decisions does not wait once per decision. It waits once. For anything a person is watching, that is the difference between an interface that feels broken and one that does not.

Where does the confidence threshold go, and how much human review does it buy?#

TypeSafe's own pattern routes anything below 0.6 to a person, acts on 0.6 and above for low-stakes work, and asks for confirmation up to 0.85. Above 0.85 on a high-stakes action, the pattern acts automatically.

But the bands are not a quality setting. TypeSafe's concepts page is explicit about why: calibration is measured across groups of predictions, and "it does not guarantee that an individual answer is correct". So a high confidence does not mean this answer is right. It means answers scored like it are right at that rate across the group.

Therefore the threshold is a staffing dial. Raise it and more work reaches the review queue. Lower it and fewer answers are checked. Because that queue is a real cost, pick the number after someone has agreed to watch it.

Can the decision call run inside an edge request without blowing the budget?#

Waiting on the call costs no CPU time on Workers, so the real ceiling is the subrequest budget of 50 on Free and 10,000 on Paid. Cloudflare's Workers limits page states it plainly: "Waiting on network requests (such as fetch() calls, KV reads, or database queries) does not count toward CPU time."

So an edge runtime is a fine place for a typed decision, and the thing to count is calls rather than seconds. One batched call per request leaves the budget almost untouched. But one call per question, in a loop over a list, is how a Worker meets its ceiling.

The same arithmetic settles where the call belongs. When a request needs one decision about the thing in front of it, the edge is the right place. When it needs a decision per row over a long list, that work belongs in a job with its own retries, not in a request a person is waiting on.

Which pages do you build this from, and in what order?#

Five documentation pages carry everything here, in build order: the design rule, the request shape, the routing pattern, the failure list and the runtime limits. So read them in this order:

1. How to build with System One: the rule that code keeps control and the model gets narrow, structured decisions.
2. API reference: the HTTP request shape, the three question types, the response shape and the error table.
3. Confidence-gated routing: the 0.6 and 0.85 bands, and what the code does in each.
4. Model jaggedness for jev-1.13: the published failure classes, which is the list your code refuses.
5. Models: the price, the request budget and the model aliases.

What is the smallest working example, and where does it refuse the model?#

Four steps in TypeScript: post the state with every question, read each typed answer and its confidence, branch on the bands, refuse what the model cannot do. Every field below comes from the API reference; the bands come from the routing pattern.

// 1. One request: the state once, every question attached (api.md).
const res = await fetch('https://api.typesafe.ai/v1/systemone', {
  method: 'POST',
  headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    state: ticketText,
    model: 'jev-latest',
    questions: {
      department: {
        type: 'choice',
        instructions: 'Which team should handle this?',
        criteria: {
          billing: 'Payments, invoicing, refunds',
          technical: 'Bugs, outages, integrations',
          sales: 'Pricing, upgrades, new accounts',
        },
      },
      is_urgent: { type: 'noul', instructions: 'Does this convey urgency?' },
    },
  }),
});

// 2. Each answer comes back under the id you chose (api.md).
const { answers } = await res.json();
const department = answers.department;

// 3. Branch on the documented bands (confidence-routing.md).
if (department.confidence < 0.6) {
  await sendToHuman(ticket, department);
} else if (department.confidence < 0.85) {
  await askToConfirm(ticket, department.choice);
} else {
  await route(ticket, department.choice);
}

// 4. Refuse in code what the model does not do (jev-1.13.md).
const refundTotal = lineItems.reduce((sum, item) => sum + item.amount, 0);

Finally, step four is the one that is easy to skip. The jaggedness page for jev-1.13 says "Jev is not a calculator" and recommends implementing mathematical logic in code. It also records that the model does not count reliably, whether that is characters in a word or items in a long list. So the total above is added in code, and no question asks the model to do arithmetic.

The same page gives the second refusal. When an instruction needs interpreting, it says to state the exact condition and put boundary cases in the criteria. Where interpretation cannot be avoided, it says to split the question into two literal ones and combine them in code. Both of those are refusals your code owes before the call, rather than repairs after it.

When is a System One model the wrong tool, and a frontier model the right call?#

When the state plus the longest question will not fit the published 32k budget, or the job is arithmetic, use a frontier model. TypeSafe's models page publishes both bounds as 64k tokens per request, and 32k for the state plus the longest question.

Three cases fail here, and each for its own reason. A long contract with a long question fails on the budget. Then a refund total fails because the model is not a calculator. Finally a customer-facing paragraph fails because the answer is not a value from a known set.

In each case the honest move is to use the tool built for the job. Then keep the typed decision for the branch that follows. For example, a frontier model can draft the paragraph, and a System One call can decide whether it is ready to send.

Where does this go from here?#

The decisions left are which workload to type first, where the call lives, and who watches the queue the threshold creates. For the buy-or-not comparison against a frontier model, read TypeSafe AI Jev vs LLMs. For where a call like this belongs in a multi-step job, read Cloudflare Workflows for AI and what belongs at the edge.

For the work of having the layer built and governed, two pages help. The AI-augmented development page covers how the decisions get written down and reviewed. Then Cloudflare development covers where the call runs. Still, the documentation above is enough to build the first one without any of that.