Entropy and Fallibility: catastrophic outcomes through compounding irreducible ambiguity and conjectural reasoning at the intent–execution interface

A common premise in agent engineering is that if we make the model smart enough, the harness becomes optional. The reasoning goes: an LLM that is arbitrarily good at interpretation and reasoning and can reach 3-sigma reliability on any single task should be trusted to act autonomously. I want to argue the opposite: even under those ideal conditions, a serious agent system still needs a control plane — and the reason is not model reliability but two structural properties of intelligence itself: the irreducible entropy of language and the conjectural nature of reasoning.

Language has null spaces

Natural language is not a deterministic encoding. For every message, ticket, email, or log line, there are regions where multiple interpretations are valid, where the correct reading depends on context the model does not have, or where the model will produce a confident, coherent answer that is wrong. I call these regions null spaces.

Null spaces are not edge cases. They are the irreducible ambiguity built into human communication. The model cannot detect its own null spaces from inside them: it will answer fluently, and the failure signal is invisible to the agent itself.

Reasoning is conjectural

Even when the words are unambiguous, the inference drawn from them is not guaranteed. A model can construct a fluent, confident, internally coherent chain of reasoning that is nevertheless wrong — a false generalization, a hidden assumption, a misplaced quantifier, an overconfident extrapolation. From the inside, the reasoning looks like proof. From the outside, it is a guess that has not yet met a critic.

This is the Popperian insight: all knowledge is conjectural. The problem is not that models sometimes reason badly; the problem is that no reasoning process can certify its own correctness. A model cannot detect its own bad inference any more than it can detect its own null space. Both errors are invisible to the agent that makes them.

Chained decisions turn null spaces and bad inferences into unbounded consequences

Even if each individual interpretation is 99.73% correct (3-sigma), an agentic system is a chain of decisions:

message → interpretation → decision → action → next message → …

If each link has independent probability p of landing in a null space, then after n chained decisions the probability of at least one null-space hit is:

These are not random failures. They are systematic: the model enters a null space, produces a confident but wrong interpretation, and acts on it. If the action is irreversible — a send, a purchase, a commit, a data deletion — the consequence is unbounded because the chain cannot be unwound.

The Entropy and Fallibility Conjectures

Here are the conjectures Narada is built on:

The Entropy Conjecture: Even if an LLM is arbitrarily good at interpretation, natural language contains irreducible null spaces — regions where a fluent, confident answer is not uniquely determined by the available context. The model cannot detect these null spaces from inside them.

The Fallibility Conjecture: Even if an LLM is arbitrarily good at reasoning, reasoning remains conjectural. A fluent, confident inference can be wrong even when the premises are clear, and the model cannot detect its own bad inference from inside it.

Joint implication: When decisions are chained, the probability of landing in a null space or a bad inference approaches certainty, and if the resulting actions are irreversible, the consequences are unbounded. Therefore, serious agent systems require a control plane that externalizes admission, approval, continuity, and evidence, independent of the model’s own reliability.

Not the paperclip argument

This is a descendant of the paperclip maximizer, but the mechanism is different — and the difference is the point. The paperclip argument is an outer alignment failure: the objective is misspecified, and an arbitrarily powerful optimizer pursues the letter of it to catastrophe. Wrong target, unlimited thrust. It asks you to believe in an implausible agent.

The Entropy and Fallibility Conjectures assume the objective is right and the model is arbitrarily good — and claim the system still fails, because the failure sits at the intent–execution interface itself. Every spec, every instruction, every approval is language, and language has null spaces; every plan, deduction, and generalization is reasoning, and reasoning is conjectural. The catastrophe is not one coherent optimizer converting the world to paperclips; it is drift, compounding through ordinary chained decisions until an irreversible action makes it unbounded. No superintelligence required — an ordinary agent with email and a credit card, running long enough, will hit null spaces and bad inferences.

The mitigations differ accordingly. Alignment tries to get the values right; a control plane exists because the interface cannot be gotten right and the reasoning cannot be certified, so the consequences must be bounded instead. And where the paperclip argument is an intuition pump, these conjectures are pinned to an executable benchmark designed to break them. The paperclip argument asks you to believe in an implausible agent. The Entropy and Fallibility Conjectures ask only that language is ambiguous, reasoning is guesswork, and multiplication works.

What a control plane does

A governed control plane does not make the model more reliable. It bounds the consequences of null-space and bad-inference failures:

• Admission: not every interpretation becomes work.
• Approval: not every drafted effect becomes an outward action.
• Audit: every null-space hit or bad inference that survives the gates is visible after the fact.
• Criticism: invariants and tests check the model's conclusions against constraints it did not have to invent.
• Continuity: the system can recover and correct without losing the record of what happened.

The model remains perfect at interpretation and reasoning inside its own frame. The harness provides the frame and the criticism.

Where this leaves Narada

Narada is not competing on “smarter agent.” It is competing onbounded agency: a system where the model is trusted to interpret and reason, but not to decide what becomes work or what becomes an irreversible effect. The Async Message Responder benchmark is a falsifiable test of whether a system has that property.