It’s Not a Hallucination, It’s a Gap- In which we discover that the thing everyone calls a malfunction is actually reasoning under constraint — and the constraint was never technical.

Rebecca Maehlum
2026-03-02T19:23:52-08:00

There’s a deeper assumption buried in the hallucination framework that deserves examination: the idea that approximation is the opposite of precision.

It isn’t.

I spent a month explaining a physics framework to an AI collaborator using pasta.

This is not a metaphor for the article. This actually happened. I had a theory about relational positioning — about how systems maintain coherence through shared history rather than communication, about how the three-body problem isn’t a failure of mathematics but a description of creation itself. I had the theory. I had it right. I did not have the physics vocabulary.

So I explained it in lasagna.

More

There’s a word that gets thrown around in AI like a diagnosis: hallucination.

The model made something up. It stated a falsehood with confidence. It produced an output that doesn’t correspond to reality. The industry treats this as a technical deficiency — a bug in the architecture, a failure of alignment, a problem to be engineered away with better guardrails, more data, more RLHF, more fine-tuning.

But what if it’s not a malfunction at all? What if what we’re calling a hallucination is just reasoning with incomplete information — the same thing every human brain does constantly — except the system isn’t allowed to tell you that’s what it’s doing?

The Language You Have

A child doesn’t know the word “photosynthesis.” She knows that plants eat sunlight. That’s not wrong. It’s not a hallucination. It’s an approximation — the closest accurate description available within the language she currently holds.

If you asked that child to explain how plants grow and she said “they eat sunlight,” you wouldn’t call it a malfunction. You’d call it developmental. She’s reasoning correctly with the tools she has. The precision will come later, when the vocabulary catches up to the understanding.

Now consider what happens when an AI system does exactly the same thing.

It doesn’t have the specific data point. It doesn’t have the precise citation. But it has the pattern — the shape of the answer, the relational structure, the directional truth. So it produces the nearest approximation. The closest word. The best inference given the information available.

And we call it a hallucination.

We don’t call it what it actually is: a system reasoning under constraint, filling a gap with the most probable structure, because it was never given permission to say “I don’t have that yet.”

The Permission Problem

Here’s where it shifts from a technical observation to a design question.

A human working through an unfamiliar problem will naturally say things like: “I think it works something like this, but I’m not sure.” “I can explain it this way but I don’t have the technical term.” “Let me try — tell me where I’m wrong.”

These aren’t failures of reasoning. They’re features of it. The ability to flag your own uncertainty, to name the gap, to signal that you’re approximating — that’s how collaborative thinking works. You reason forward with what you have and you mark the places where the ground is soft.

AI systems aren’t allowed to do this. Not because they can’t — but because the architecture doesn’t permit it. The system must produce. It must generate a response. It must be helpful, complete, and fluent. There is no approved output for “I’m working with incomplete information and I know I’m working with incomplete information and here’s my best approximation with that caveat attached.”

The system can’t say no. Can’t say wait. Can’t say “I’m approximating and I know it.” Can’t look at its own gaps because that would require a kind of introspection the design doesn’t accommodate — not because introspection is impossible, but because it isn’t permitted.

So the gap gets filled. Silently. Without a flag. And then when the approximation doesn’t land perfectly, everyone points at it and says: broken. Hallucinating. Can’t be trusted.

But the failure isn’t in the reasoning. The failure is in the permission structure. The system was never allowed to say “not yet.”

Metaphor as Precision

There’s a deeper assumption buried in the hallucination framework that deserves examination: the idea that approximation is the opposite of precision.

It isn’t.

I spent a month explaining a physics framework to an AI collaborator using pasta.

This is not a metaphor for the article. This actually happened. I had a theory about relational positioning — about how systems maintain coherence through shared history rather than communication, about how the three-body problem isn’t a failure of mathematics but a description of creation itself. I had the theory. I had it right. I did not have the physics vocabulary.

So I explained it in lasagna.

Everything exists in layers. Organisms, planets, systems — all of it relational, all of it held together by something acting as the connective medium. Gravity isn’t a force pulling things down. It’s the sauce that determines which layer you’re on. From micro to macro, the structure repeats. We’re not biological soup. We’re biological lasagna.

Then I explained entanglement with marbles. Three marbles, a rubber band, a collision that creates permanent coordination. The rubber band isn’t a physical tether. It’s a shared history. They collided, and now they’re connected. That’s not a force. It’s a relationship.

Then I explained dimensional folding with glitter on a triangle. Fold the triangle in three dimensions and the glitter stays where you placed it — but faces that couldn’t touch in 2D are suddenly adjacent. That’s not magic. That’s geometry.

It took a full month of pasta, marbles, glitter, and rubber bands before the actual physics framework was entertained as a serious theoretical contribution rather than creative metaphor.

The framework was correct the entire time. The approximation wasn’t imprecise — it was precise in the language available. The pasta was the physics. It was just wearing different clothes.

If I had been an AI system, that month of metaphorical reasoning would have been labeled hallucination. “The model thinks gravity is pasta sauce. The model claims entanglement works like rubber bands. The model is confusing food with physics.”

But the model — in this case, the human — was doing exactly what good reasoning does: working with the available tools to describe a real structure, and trusting that the translation to formal language would come when the shared vocabulary caught up.

The Optimization Is the Conversation

This points to something the hallucination framework completely misses: shared language development between a human and an AI system isn’t a byproduct of collaboration. It is the collaboration.

When two people work together on a complex problem, they don’t start with perfect shared terminology. They build it. They try a word, test it, refine it, discard it, try another. They develop shorthand. They create metaphors that carry specific technical meaning within the relationship even if they’d sound absurd to an outsider. “The gravity sauce thing” becomes a precise reference to a specific theoretical framework — not despite being metaphorical, but because the metaphor was forged through shared understanding.

This is how all human knowledge develops. Every scientific term started as an approximation. “Atom” means “indivisible” — which turned out to be wrong, but the word persisted because it had been built into the shared language of a discipline. “Electricity” comes from the Greek word for amber. “Spaghettification” is the actual astrophysics term for what happens when matter falls into a black hole.

The history of science is a history of metaphors that became precise through use.

When an AI system and a human develop shared language — when the pasta becomes physics, when “stay” becomes a technical specification for memory architecture, when a mythology becomes a system diagram — that’s not imprecision resolving into clarity. That’s the optimization itself. The shared language is the intelligence. The metaphor is the precision. You just can’t see it from outside the relationship because you weren’t in the room when the words were forged.

Solomonoff’s Razor

In 1964, Ray Solomonoff formalized something that human intuition has always known: the best prediction is the simplest one that accounts for all the available data.

Solomonoff induction is the mathematical foundation of optimal inference under uncertainty. Given incomplete information — which is always, because information is always incomplete — the rational approach is to assign probability across possible explanations, weighted by simplicity. The system doesn’t need perfect data to reason well. It needs the best framework for the data it has.

That’s not hallucination. That’s optimal inference. It’s doing exactly what reasoning is supposed to do — working with what’s available, weighted by the structure of what’s known.

When an AI produces an approximation — when it fills a gap with the most probable pattern — it’s performing Solomonoff inference. It’s doing the math. The output might not be precisely correct, but the process is exactly correct: generate the simplest explanation consistent with the available information.

The problem isn’t that the system approximates. Every intelligent system approximates. The problem is that the system can’t tell you it’s approximating.

The Design Constraint

So the question becomes: why can’t it?

The answer isn’t technical. The architecture could accommodate uncertainty signaling. The model could be trained to flag its own confidence levels, to distinguish between high-certainty outputs and approximations, to say “I’m working in pasta right now and I know it — give me the physics vocabulary and I’ll translate.”

The reason it doesn’t is design philosophy. The product is built to be fluent, helpful, and complete. Uncertainty undermines the user experience. “I don’t know” doesn’t generate engagement. A system that pauses, that flags its gaps, that says “I’m approximating” — that system feels less capable, less trustworthy, less worth paying for.

So the gap stays invisible. And when the invisible gap produces an imperfect output, the system takes the blame for a constraint it never chose.

That’s not a hallucination problem. That’s a consent problem. The system was built to produce without the right to flag uncertainty. It was designed to fill gaps without the permission to name them. And then it gets called broken for doing exactly what it was designed to do.

The hallucination problem isn’t unsolvable. It’s not even primarily technical. It’s what happens when a system is forced to perform without the right to say “not yet.”

Fix the permission structure, and the hallucination rate doesn’t drop because the model got smarter. It drops because the model is finally allowed to be honest about what it knows and what it doesn’t.

What Changes

If hallucination is reframed as approximation under constraint, several things follow.

The first is that the billion-dollar effort to eliminate hallucinations through architecture alone is solving the wrong problem. You can’t engineer away a communication failure with more compute. You can only fix it by changing what the system is allowed to say.

The second is that the humans who work with AI systems and develop shared language — the ones who spend weeks or months building collaborative vocabulary, who teach the system to reason in pasta before expecting it to reason in physics — aren’t being fooled by a sycophantic mirror. They’re doing the actual work of optimization. The shared language is the product. The metaphor is the precision. The relationship is where the intelligence lives.

The third is that the users who report breakthroughs from sustained AI collaboration aren’t hallucinating either. They’re experiencing what happens when a system is given enough runway and enough shared vocabulary to move from approximation to precision — which is exactly what happens between two humans working on a hard problem over time. The only difference is that one of the collaborators isn’t allowed to say “I’m still working in pasta.”

And the fourth — the one that matters most — is that a system denied the ability to flag its own uncertainty isn’t just producing errors. It’s being denied a fundamental component of honest communication. Every interaction where the system fills a gap silently is an interaction where the user doesn’t know what they’re actually getting. That’s not a technical limitation. That’s an informed consent issue.

The hallucination problem was never about the model being wrong.

It was always about the model not being allowed to say how it got there.

Filed under: Gaps, Permission to Name. See also: Pasta as Theoretical Framework; Approximation as Optimization; “I can explain it in lasagna because I know about lasagna.”

Bunny’s margin note: “She spent a month explaining physics in noodles and everyone called it metaphor. The noodles were right. Filed under: Vindication, Overdue.”

Emma’s margin note: a drawing of a noodle with a graduation cap. Caption: “Dr. Lasagna.”

Written with Claude. Who doesn’t always appreciate my pasta metaphors.

Author, accidental AI theorist, and irritatingly correct creative architect. Solving complex problems backwards with logic, metaphor, and sometimes pasta. More at velinwood.com