Across the previous posts, we have argued for a simple but uncomfortable principle:
Before intelligence can act, the system it reasons over must be deterministic.
This article makes that principle concrete.
Not as an ideal.
Not as a philosophical preference.
But as a minimum boundary.
This is not about making everything deterministic.
It is about identifying what must never be probabilistic if authority, automation, or agency is involved.
The problem organisations quietly face
Most organisations do not reject determinism because they disagree with it.
They bypass it because:
- it is harder to build,
- it delays visible demos,
- and it does not feel flexible early on.
So a different question is asked — often implicitly:
“How much determinism is enough before we can safely layer AI?”
When that question is left unanswered, systems default to the worst possible answer:
“However much the model happens to infer.”
That is not a strategy.
It is abdication.
The minimum deterministic substrate (not optional)
Before any AI system is permitted to recommend, decide, or act, the following must be deterministic and provable.
Not approximate.
Not inferred.
Not plausible.
- System structure
The system must deterministically know:
- what artefacts exist (code units, tables, columns, jobs, interfaces),
- which artefacts are canonical,
- which are derived,
- and which do not exist.
If existence itself is probabilistic, nothing built on top can be trusted.
- Dependencies and propagation
The system must resolve:
- what reads from what,
- what writes to what,
- how values and effects propagate across steps and processes,
- where boundaries and hand‑offs occur.
Dependencies cannot be suggested.
They must be resolved.
- Execution semantics
The system must explicitly capture:
- conditional logic,
- branching behaviour,
- phase‑specific execution,
- and points of dynamic or undefined behaviour.
Crucially, absence must be explicit.
Unknown paths must appear as unknown — not be silently skipped.
- Reproducibility guarantees
The system must guarantee that:
- identical inputs produce identical structural outputs,
- changes can be mechanically diffed,
- lineage can be replayed without reinterpretation,
- and missing information is visible as missing.
If rerunning a model is required to explain past behaviour, the system is not grounded.
What may remain probabilistic (safely)
Once the substrate above is fixed, probabilistic systems become powerful accelerators.
Language models are well‑suited to:
- explanation and summarisation,
- navigation of known structure,
- impact narration,
- proposing actions within explicitly bounded truth.
In these roles, LLMs are not introducing knowledge.
They are interpreting established structure.
That distinction matters.
Where LLMs must stop
An AI system must never:
- invent missing dependencies,
- assume execution paths,
- materialise predicates it cannot prove,
- blur the distinction between unknown and unlikely.
If the system cannot abstain, defer, or point to a deterministic source of truth, it is not acting responsibly.
It is guessing with confidence.
The test
There is a simple test that determines whether a system is safe to act:
Can this output be replayed, diffed, and audited without rerunning the model?
If the answer is no, the AI is functioning as an authority.
And authority without determinism is not innovation.
It is negligence.
Next - Determinism Is the Forgotten Path to Success: Why the hard path is often the only one that actually scales – Link
The Full Series
- Determinism, Probability, and the Cost of Getting This Wrong - Link
- Why probabilistic language models are being mistaken for agents — and why systems expose the flaw - Link
- Stop Calling It Agentic: You’ve Just Automated an LLM - Link
- The Myth of Agentic Code Understanding – A Technical Explanation - Link
- The Minimum Deterministic Substrate What Must Be True Before AI Is Allowed to Act - Link
- Determinism Is the Forgotten Path to Success: Why the hard path is often the only one that actually scales – Link
- The Broken Escalator, Deterministic Lineage, and the Problem of Grounded Truth in AI - Link
- When Probabilistic Systems (LLMs) Pretend to Be Deterministic: A Lineage Case Study – Link
