I used to think building software was mostly about being precise. You write a function, you know exactly what it does, and if it breaks, you can trace the break back to a line of code. This is the world of classical AI—expert systems, decision trees, rule engines. It’s Newtonian. Give me the initial conditions, and I’ll tell you exactly where the apple lands.
Then LLMs showed up, and the ground shifted.
The Old World Was a Clockwork
For most of the history of software, “correct” meant “predictable.” A function took an input, and if you gave it the same input twice, you got the same output twice. This wasn’t just a convenience—it was the whole basis of how we reasoned about systems. Debugging worked because causality was traceable. Testing worked because behavior was reproducible. Security worked, more or less, because you could enumerate the possible states a system could be in.
This is what Newtonian physics gave the world three centuries ago: a universe you could, in principle, fully compute if you knew enough. Laplace’s demon—a hypothetical intelligence that knows the position and momentum of every particle—could predict the entire future and reconstruct the entire past. Classical AI aspired to something similar. If you encoded enough rules, you could predict the system’s every move.
Then the Model Stopped Behaving
The first time I ran the same prompt through an LLM twice and got two different answers, something in my engineer brain twitched. Not because the answers were wrong—they were both reasonable—but because reasonable isn’t the same as repeatable. I had spent years building systems where non-determinism was a bug. Now I was working with a system where non-determinism was the point.
This is the quantum shift. Quantum mechanics didn’t just say “we don’t know the exact position of the electron.” It said something stranger: the electron doesn’t have an exact position until you measure it. The uncertainty isn’t a gap in our knowledge—it’s baked into the nature of the thing. Heisenberg’s uncertainty principle isn’t a confession of ignorance; it’s a description of reality.
LLMs aren’t quite that deep, philosophically—their randomness starts out as a design choice, not a law of the universe. And yet the machine keeps surprising the people who try to tame it. Set the temperature to zero, and in theory you should get a deterministic function back: same input, same output, every time. In practice, at the scale of a real production cluster, this often isn’t true. A 2024 study ran five major LLMs through eight common tasks ten times each under supposedly-deterministic settings and found accuracy variations up to 15% across naturally occurring runs, with the gap between best-case and worst-case performance reaching 70%. None of the models consistently delivered identical output strings, much less identical answers. (Atil et al., 2024 — arXiv:2408.04667)
The root cause isn’t mysterious once you look under the hood. Modern LLMs run on thousands of GPU cores executing operations in parallel, and floating-point addition is not associative—the order in which tiny fragments of a calculation get summed can shift the result by a rounding error too small to notice individually, but large enough to nudge a token probability across a threshold. Multiply that across billions of parameters and you get output drift even at temperature zero, not because anyone chose uncertainty, but because the hardware itself introduces a kind of physical noise floor. The machine, at its very limit, resists absolute certainty—almost as if determinism at this scale is a convenient fiction rather than a guarantee.
Why This Matters More Than It Sounds
Here’s the thing that took me a while to internalize: this isn’t just a technical quirk, it’s a completely different discipline of engineering. When you build with deterministic systems, your job is to eliminate ambiguity. When you build with LLMs, your job is to design for the ambiguity that remains after you’ve done everything right.
Recent research on LLM outputs found something that pushes the analogy further than mere flavor text. A 2025 paper tested 38 language models across 383 reasoning tasks using the Erotetic Theory of Reasoning (ETR)—a formal cognitive framework with empirical support for predicting human reasoning outcomes—and found that stronger models produce more human-like errors, not fewer. As models advance in general capability, the proportion of their incorrect answers that align with ETR-predicted human fallacies tends to increase (ρ = 0.360, p = 0.0265). The same study confirmed pronounced order-effects in language model reasoning analogous to those observed in humans. (Richardson et al., 2025 — arXiv:2506.11128)
Crucially, these weren’t random errors. They showed structured patterns—order-dependent effects, systematic deviations from classical probability axioms—that look uncomfortably like the cognitive biases cognitive scientists have been documenting in humans for decades. The researchers were careful to say this doesn’t mean neural networks are secretly doing quantum physics—but the shape of the uncertainty is formally analogous to the models cognitive scientists have used to describe human judgment. That’s a strange and wonderful thing. It suggests the probabilistic nature of LLMs isn’t just noise we haven’t engineered away yet. It might be closer to an intrinsic property of systems built to model meaning rather than mechanics—closer to how humans actually reason, contradictions and all, than to how calculators compute.
Searching for a Theory of Everything
None of this means determinism is dead. If anything, the most interesting work happening right now sits exactly in the seam between the two paradigms, and it looks a lot like physics’ own oldest unfinished project.
For a century, physicists have chased a Theory of Everything—a single framework that unifies the deterministic, smooth geometry of general relativity with the probabilistic, granular strangeness of quantum mechanics. They haven’t found it. Gravity still refuses to sit comfortably next to the quantum field. But AI engineering is quietly attempting its own version of that unification, and it’s further along than physics ever got.
On one side, physics-informed neural networks (PINNs) take the “quantum” element of AI—a statistical, meaning-making engine that samples from distributions—and scaffold it directly inside rigid, deterministic Newtonian guardrails, embedding actual physical equations into the network’s architecture so that certain outputs stay anchored to conservation laws no matter how the probabilistic layers behave. (Raissi et al., 2024 — arXiv:2408.16806) On the other side, in domains like finance, teams are explicitly wiring LLMs to deterministic verification layers, because a probabilistic model that occasionally hallucinates a number is not something you want anywhere near a trading desk without guardrails. In both cases, the goal isn’t to choose Newton or Heisenberg. It’s to build a system where the probabilistic engine does what it’s uniquely good at—generating, inferring, generalizing—while a deterministic skeleton keeps it from drifting into nonsense. That’s not a compromise. That’s the actual shape of a working Theory of Everything, built one product at a time instead of one equation.
The Real Lesson
If there is a fundamental engineering lesson buried in all this, it’s this: the biggest shifts in our field aren’t when we get better at eliminating uncertainty. They’re when we realize a whole class of problems was never actually deterministic to begin with—we just hadn’t built anything sophisticated enough yet to reveal the uncertainty that was there all along. Newton didn’t fail; he was exactly right at the scale he was working at. Classical AI didn’t fail either. It just turned out that language, meaning, and judgment live at a scale where the clockwork model quietly runs out of road—and something more like quantum probability was waiting underneath the whole time.
References
- Atil, B. et al. (2024). Non-Determinism of “Deterministic” LLM Settings. arXiv:2408.04667
- Richardson, A. K. et al. (2025). Stronger Language Models Produce More Human-Like Errors. arXiv:2506.11128
- Raissi, M., Perdikaris, P., Ahmadi, N., & Karniadakis, G. E. (2024). Physics-Informed Neural Networks and Extensions. arXiv:2408.16806