Deterministic AI: What It Means, Where It Breaks, and Where It Belongs

My parents have entered their AI chatbot era (shoutout to my brother for teaching them!), and these days they plan pretty much every trip with it without double-checking anything. On our last trip to Italy it sent us twenty minutes across town to a museum that turned out to be closed on Mondays. We adjusted our plans, asked it for other options, and nobody trusted it any less.

My parents aren’t the only ones; almost everyone I know uses AI in their personal life. Yet at work it’s a different story. Outside of software engineering, where you can run the code and see if it works, hardly anyone trusts it with anything that actually matters. I spent the past year following the space from the outside before joining Kepler, my first AI-native company, and whenever I asked why, the answer was trust. A wrong answer on a trip meant a detour. A wrong number in an investment memo costs someone their credibility. So anyone whose name is on the work checks everything, and once you’re checking everything, much of the time the AI saved goes straight back into checking its work.

That’s the gap the word deterministic is meant to close. It shows up in launch announcements, pitch decks and sales calls, usually without a definition. This piece is my attempt at one: what deterministic AI means, where each version of it breaks, and which parts of an AI system should actually be deterministic.

Same question, twice

While I was deciding whether to make the leap, I spent a lot of evenings using AI to research companies in the space. One night I asked a simple question about a startup I was looking at: roughly how much revenue was it doing? The answer came back as $40M, with a source. A few days later my roommate asked the exact same question and got $25M, also with a source.

There was no glitch. The two sources disagreed: one was an older article quoting an early estimate, the other a more recent interview with a different figure. Each time, the AI found one of them, picked it, and presented it with complete confidence. It never mentioned the other.

That’s the part that stuck with me. Both answers were sourced, both looked totally fine, and the system made a judgment call (which source to trust) without telling either of us it had made one. If my roommate hadn’t asked, I’d never have known there was another number.

Deterministic vs probabilistic AI

A deterministic system gives the same output for the same input, every time. A calculator, a spreadsheet formula, a database query, these are all deterministic: ask for revenue divided by headcount and you get one answer, and you can rerun it a thousand times to prove it.

A probabilistic system produces outputs from a range of possibilities. Large language models work this way. At each step, a model estimates how likely every possible next word is and picks one, which is what makes them so good at reading messy questions, summarizing documents and writing fluent explanations. It’s also why the same question can come back with a different answer.

Neither is better. They’re built for different jobs. The real question isn’t whether an AI system is deterministic or probabilistic (every useful one is both), but which job each part of it is doing.

Five things people mean by “deterministic”

Look closely at the claims and “deterministic AI” turns out to mean at least five different things. Each one guarantees something real, and each one breaks somewhere.

1. Consistent answers: The same question returns the same answer every time, either word for word or with the same facts in different wording. It guarantees repeatability; you can rerun a question and expect the same result, which makes a system easier to test and debug. It does not guarantee correctness. A system that’s wrong the same way every time is arguably worse than one that varies, because nobody thinks to check it. In my case, consistency would have hidden the disagreement between sources instead of exposing it.

2. Guaranteed format: The output always comes back in the same structure, like a table with the same columns or data that other software can read without errors. It guarantees reliability for whatever sits downstream; if answers feed into a spreadsheet or another system, a predictable shape matters. It does not guarantee the content is right. The table will always have a revenue column, but whether the number in it is correct is a separate question. In my case, both answers came back in exactly the same shape: one number, one source.

3. Fixed workflows and rules: Every request runs through the same steps in the same order, within a set of written rules (only use these sources, always show a citation, never answer questions about X). It guarantees a predictable process, which makes a system easier to audit and govern. It does not guarantee a correct result, because any step that relies on a model can still get it wrong, and rules only catch the mistakes someone saw coming. In my case, the same steps likely ran both times (search, find a source, pull a number, cite it) and still produced two different numbers.

4. Double-checked answers: A second pass reviews the first answer before it reaches you, usually another model asked to check the first one’s work. It guarantees fewer obvious mistakes, like unsupported claims, formatting slips and answers that don’t match the question. It does not guarantee an independent check. When one probabilistic model checks another, the check is probabilistic too, and the two often share blind spots. In my case, a reviewer checking $40M against its article would have passed it, because the number matched. The problem was the other source it never looked at.

5. Traceable answers: Every number links back to where it came from: a specific document, page or line. It guarantees accountability; you can follow any figure back to its source instead of taking the system’s word for it. It does not guarantee the right source. A citation tells you where a number came from, not whether it was the right place to look, or whether another source said something different. In my case, both answers were cited and both citations checked out. They just pointed to different places.

Is temperature 0 deterministic?

There’s one more fix people reach for first: set the temperature to zero. Temperature controls how much randomness the model uses when it picks the next word, and at zero it always picks the single most likely option.

In theory, that should make the output deterministic. In practice, it doesn’t, and the major model providers don’t promise identical outputs even at zero. When the AI research lab Thinking Machines dug into why, it sent one prompt to the same model 1,000 times at temperature zero and got back 80 different answers. The main cause wasn’t the model at all but the servers running it. Requests get grouped into batches that change size depending on how busy the server is, and that small change in the order of the arithmetic can be enough to flip which word comes out on top. Fixing it means changing how the model runs under the hood, and it makes everything slower.

And even a perfectly repeatable model only solves half the problem. Temperature zero could have given me $40M or $25M every time. It wouldn’t have told me the sources disagreed.

So which parts should be deterministic?

Run my revenue question back through all five, or through temperature zero, and none of them would have fixed it on its own. That’s because the problem was never that the AI was probabilistic. The problem was that the probabilistic part was doing a job that should have been deterministic: finding the numbers. A model-only system finds one number and stops.

The useful line isn’t between deterministic and probabilistic AI. It’s between the jobs inside an AI system:

• Make it deterministic wherever numbers are found and calculated: searching every source, every time, pulling each figure out, calculating with it, and linking it back to exactly where it came from. Ask about that startup’s revenue and both $40M and $25M come back, every time.
• Keep it probabilistic where judgment and flexibility are the point: understanding a messy question, weighing sources that disagree, and explaining the result in plain language. The model can say which figure it trusts more and why, as long as both are shown.

Put simply, deterministic code should find every number, and the model should weigh them in the open. That’s the line we draw at Kepler: deterministic code retrieves, calculates and cites every figure, and language models interpret the question, weigh what comes back and write the answer. Determinism isn’t the goal by itself. It’s how you get to answers that are verifiable.

Questions to ask about any “deterministic” AI system

Almost any vendor will say yes to “is it deterministic?” These questions get you further:

• Which parts are deterministic, and which aren’t? Look for a specific answer about how numbers are retrieved and calculated, not a general claim about the whole system.
• What happens when sources disagree? The right answer is that the system shows you, not that it picks one.
• How long does it take me to check an answer? If verifying a number takes as long as finding it yourself, the AI hasn’t saved you any time.

Back to my parents

My parents don’t need deterministic AI, because when it gets something wrong, they just change plans. A wrong revenue number nearly fed into my career decision, and inside most companies a wrong number costs far more than that, which is why so much of the important work still gets done by hand.

The fix isn’t to make AI less probabilistic. It’s to put determinism where the numbers are, so that every figure can be traced, rerun and checked faster than you could have produced it yourself. That’s the problem I joined Kepler to work on.