The next billion decisions

Buy a pair of shoes online and count the decisions that follow. Is this card fraudulent? Which warehouse ships it? Is the address real? Does the confirmation email land in the inbox or in spam? Is the review you leave a week later genuine? Which agent sees your return request, and how urgent is it?

Dozens of judgment calls, made in seconds, for one pair of shoes. Not one of them is read by a person. Multiply by every purchase, message, upload, login, and API call on earth, and you get the real workload of the economy: billions of small decisions a day, made by software, for software.

We think this workload deserves its own kind of model.

Two bad options

Today these decisions are made in one of two ways.

The first is rules. Thousands of if-statements, written by people who understood the world as it was when they wrote them. Rules are fast and predictable, but they’re brittle. They can’t read a messy support ticket, they miss the scam phrased a new way, and every edge case adds another rule that someone has to maintain forever.

The second is chat models. They read anything and handle nuance beautifully, but they were built to talk to people, and that shows. They answer in prose that has to be parsed. They take hundreds of milliseconds to seconds, and their cost grows with every word they write. They sometimes answer outside the options you gave them. And they sound just as sure when they’re wrong as when they’re right.

One option is fast and dumb. The other is smart and built for a different job. The middle, judgment at the speed and price of code, has been empty.

Knowledge we can’t tell

Why have rules always been brittle? The philosopher Michael Polanyi put it in one line: “We can know more than we can tell.” A nurse senses that a patient is slipping before the numbers move. A fraud analyst spots a ring of fake accounts at a glance. An editor knows a headline will land. Ask them how, and the explanation always falls short of the skill.

This is tacit knowledge, and most good judgment is made of it. The economist David Autor called the problem Polanyi’s paradox: we can’t automate what we can’t write down. Rules fail not because their authors are careless, but because the knowledge was never in words to begin with.

Language models broke the paradox. They learned tacit knowledge the way people do, from examples, at enormous scale. But they can only express it by talking. To make a judgment, they write one out: a chain of thought, a paragraph, a plan. Forcing tacit knowledge back into words is slow, it is expensive, and it loses the one thing an expert’s judgment carries that a paragraph doesn’t: an honest sense of how sure they are.

What the middle needs

A model built for this middle needs four properties, and each one comes from asking what software, not a person, needs from an answer.

• Bounded. The answer is always one of the options you defined. Not usually. Always.
• Calibrated. Every answer comes with a probability you can trust, so “0.9” means right nine times in ten.
• Consistent. The same input gives the same probabilities. No sampling, no mood.
• Cheap enough to run on everything. If the model only reads and never writes, cost tracks the input, not an essay it might produce.

None of these is exotic on its own. Together they turn AI from an oracle you consult into a component you can engineer around, with thresholds, fallbacks, audit logs, and service levels.

Where it isn’t optional

For many tasks, a decision model is simply cheaper. For some, it’s the only thing that works. They share one of three constraints.

A deadline in milliseconds

A voice agent has to decide, every couple of hundred milliseconds, whether the caller has finished speaking. Too early and it interrupts; too late and it feels slow. A payment has to be approved, challenged, or declined before the checkout spinner stops. There is no time to write a paragraph and parse it.

A volume in billions

A marketplace screens every listing for scams. A data team wants to ask one question of every row in a hundred-million-row table: does this ticket describe a safety problem? At this scale, a fraction of a cent per call is a budget line, and generating text for each row is out of the question. Reading each row once is a batch job.

A cost of error that needs a confidence score

Before an agent deletes files or moves money, something should check that the action matches what the user asked for. A clinic’s inbox needs to spot the message that describes stroke symptoms among hundreds of refill requests. In both cases, the most valuable output isn’t the answer. It’s knowing when the model isn’t sure, so a person can step in.

The tacit layer

Agentic AI has made remarkable progress on the explicit side of intelligence: planning, writing code, working through long tasks. But inside every one of those tasks sit dozens of small judgments. Did that tool call fail? Is this search result relevant? Is the job done? Should I ask the user first? Today each one goes through the same large reasoning model, at full cost and full latency, as if an expert had to write an essay before every glance.

That is the missing layer. We think every serious agent will pair its reasoning model with a structured decision model: one that makes the small, typed calls in a single pass, says how sure it is, and hands the hard or novel ones up to explicit reasoning. Agents become faster and cheaper. They also become safer, because the check before a risky action is finally cheap enough to run every time.

Judgment as a primitive

Databases made storage something you call, not something you build. We want judgment to work the same way. Imagine asking a question of a whole table the way you’d filter it:

# A sketch of where we’re headed, not a shipped API
risky = tickets.where(
    tacet.noul(state="body", question="Does this describe a product safety risk?") > 0.9
)

When a judgment costs about as much as reading the text once, you stop rationing it. You put it on every event, every row, every step. That’s when new products start to appear.

What we’re not claiming

Tacet α is an early model. It’s more accurate and much better calibrated than the model it started from, but we haven’t yet measured its speed and cost against matched workloads, and it still struggles with deciding when to call a tool. Structured decision models won’t replace reasoning models either. They make reasoning models worth their price by keeping them for the problems that need them.

And for decisions that seriously affect people, the point of a confidence score is to bring a human in at the right moment, not to remove them.

Why “Tacet”

Tacet sounds like tacit, and the resemblance is the point. Our models carry the kind of knowledge experts can’t put into words, and they use it the way experts do: as a judgment, not an explanation.

In a musical score, tacet tells a player to stay silent. It doesn’t mean the player has nothing to contribute; it means the music is better without extra sound. The best decision layer is like that. It knows more than it says. It decides, says how sure it is, and leaves the rest to people.