Glossary
What is deterministic AI?
Short answer
Deterministic AI is an AI-built system that gives the same output every time it receives the same input. Its decisions run as fixed, reviewed logic (code, rules or tables a person has approved) instead of a language model generating a fresh answer on each request. Language models still help build it, but they do not improvise the decision at run time.
Definition: "Deterministic AI" describes AI-built systems whose production behaviour is deterministic: the same input always produces the same output, because the decision path runs as fixed, reviewed logic rather than a fresh model generation on every request.
It's how we build: compiled AI. Models do the engineering at build time; deterministic code does the executing.
Why "temperature 0" isn't deterministic
Setting a model's temperature to zero makes it pick its most likely next word, but it doesn't guarantee the same answer twice in production. Outputs can still drift because of:
- Batching and parallel arithmetic. Floating-point operations run in different orders on shared hardware, and tiny differences can change which word wins.
- Model updates. Hosted models are revised by their providers, sometimes behind the same name.
- Context drift. A slightly different prompt, retrieved document or conversation history is a different input.
That's fine for drafting. It isn't fine for a credit decision, a claim outcome or a price quote. There the dependable fix is to make the decision path itself deterministic.
The full explanation, and the practical levers for making LLM outputs as reproducible as possible: why temperature 0 is not deterministic (Academy, lesson 2).
Deterministic AI vs generative AI
Deterministic AI gives the same answer to the same input because fixed logic makes the decision. Generative AI writes each answer fresh, which makes it good with language and unreliable for decisions that must repeat. They are not rivals: most production systems use both, each where it belongs.
| Aspect | Deterministic AI | Generative AI |
|---|---|---|
| How it produces an answer | Runs fixed, reviewed logic: code, rules or decision tables | Generates output word by word from probabilities a model learned |
| Same input, asked twice | Same output, every time | Can differ between runs, even at temperature 0 |
| Explaining a result | Trace it to the exact version of the logic that ran | Hard to reconstruct why a particular answer was produced |
| When it is wrong | Wrong the same way each time, so it can be found, fixed and covered by a test | Can be wrong on one run and right on the next, which makes errors harder to catch |
| Unexpected or messy input | Handles only what was anticipated; new cases ship as a new version | Copes well with open-ended language and unstructured documents |
| What changes its behaviour | Only a new, tested release | The model version, the prompt, the context, or a provider-side update |
| Best for | Decisions: eligibility, pricing, credit and claims rules, anything an auditor may replay | Language: drafting, summarising, conversation, reading documents |
A common combination: a generative model reads a customer's email or document into a strict, predefined format; code checks that format; deterministic logic makes the decision; and a person takes over when the input doesn't fit. Agentic AI, which chains model steps across tools, is a third pattern, compared below.
Deterministic vs generative vs agentic
Generative
Good at: drafting, summarising, conversation.
Can go wrong: different answers to the same question; confident errors.
Belongs: where a person reviews the output.
Agentic
Good at: multi-step tasks across tools.
Can go wrong: errors compound, and actions are taken on them.
Belongs: reversible, low-value tasks with hard permission limits.
Deterministic
Good at: decisions that must be repeatable and explainable.
Can go wrong: misses cases nobody anticipated, so changes ship as new, tested versions.
Belongs: anywhere a customer, auditor or regulator relies on the answer.
Where deterministic execution matters
- Lending and collectionsAffordability, credit and dunning rules applied the same way to every customer.
- InsuranceClaims triage and underwriting rules your team can read and defend.
- Policy, price and eligibilityAnswers about what a customer is entitled to come from logic you approved.
- Anything replayableDecisions an auditor may ask you to reproduce months later.
The Graduated Exposure Ladder
Deterministic doesn't mean all-or-nothing. Our framework decides, step by step, how much model belongs at run time. Every step starts at Level 0 and moves up only after it has proven itself against measured criteria on your data.
Deterministic logic and the EU AI Act
Under the EU's 2026 Digital Omnibus agreement, the AI Act's timetable is:
- 2 August 2026: Article 50 transparency obligations (telling people they are dealing with AI).
- 2 December 2027: high-risk obligations for Annex III systems, including credit scoring, employment, education and insurance pricing.
- 2 August 2028: high-risk obligations for Annex I regulated products.
High-risk systems need documentation, logging, human oversight and monitoring. Versioned, testable logic makes each of those easier to provide. Conformity remains the obligation of the system's provider or deployer; we design to support that work.
This is a summary for orientation, not legal advice.
Common questions
What is the difference between deterministic AI and generative AI?
Deterministic AI runs fixed, reviewed logic, so the same input always gives the same output and every result can be traced to the version of the logic that produced it. Generative AI produces each answer fresh from learned probabilities, so it is flexible with language but can answer the same question differently. Most production systems combine them: generative models for reading and drafting, deterministic logic for the decisions.
Is deterministic AI still AI?
Yes. The intelligence goes into building the system: models read the policies, draft the logic and generate the tests. What changes is run time, where the decision path executes as reviewed code instead of a new model output each time.
Can an LLM ever be fully deterministic?
Not reliably in production. Even at temperature 0, outputs can shift with batching, hardware, provider-side model updates and small changes in context. If a decision must be repeatable, it is safer to make the decision path itself deterministic.
How do you make LLM outputs more reproducible?
Pin a dated model version rather than an alias, keep the prompt, context and settings fixed, use a seed where the API offers one (providers describe it as best effort), constrain the output to a strict schema that code validates, and cache outputs you need to replay exactly. For decisions that must never vary, have the model write the logic at build time and run that reviewed code instead of the model.
Does deterministic mean no LLM at all?
No. A model can still read an unstructured document or handle conversation, as long as it works inside a strict schema, its output is validated by code, and a person takes over when it is unsure. What it never does is make the commitment on its own.
Which industries need deterministic execution most?
Anywhere a decision has to be explained or replayed: lending, credit and collections; insurance claims and underwriting; eligibility, pricing and policy answers; and regulated operations generally.
How do we test whether our current AI is consistent?
Run the same inputs many times and compare the outputs, then measure accuracy against examples your team has already labelled. A Proof Sprint does exactly this on one of your workflows and hands you the report.
Is your AI giving the same answer twice?
A Proof Sprint measures consistency, accuracy and cost per case on one of your workflows, then compiles it into deterministic logic. Fixed scope. You keep the code.
Scope a Proof SprintNo commitment required