Compute, Then Interpret: The Architecture That Stops AI From Making Things Up

“Separation of concerns is usually an engineering convenience. Here it is something more: an epistemic discipline. It is the difference between a machine that knows and a machine that merely sounds like it does.”

---

One Decision Does Most of the Work

If I had to compress everything I have learned about building trustworthy AI into a single sentence, it would be this: decide, up front, which parts of the answer are computed and which parts are interpreted—and never let the two touch.

That one boundary does more to eliminate hallucination than any amount of clever prompting. I argued the general case in “Why LLMs Hallucinate.” Here I want to get concrete about the architecture itself, because the idea is simple but the discipline is not.

Two Jobs, Two Tools

Almost every unreliable AI system I have seen makes the same mistake: it asks one tool to do two fundamentally different jobs.

The first job is establishing facts. Where is the planet? What is the dose? What does the statute say? What is the sum of these numbers? These have exact answers. They must be right, every time, and rightness is checkable.

The second job is making meaning. What does this configuration suggest? How should I explain it? What matters here for this person? This is genuinely linguistic work—synthesis, framing, translation—and it is what language models are extraordinary at.

A language model is a superb interpreter and a terrible calculator. Most AI products fail because they ask it to be both at once, in the same sentence, from the same guess.

The two jobs feel like one job because, when a human expert does them, they happen in the same mind, seamlessly. But the instruments best suited to each are opposites. One needs to be deterministic and exact. The other needs to be fluent and flexible. Fuse them and you get the worst of both: numbers that flex and prose that pretends to be precise.

The Rule: The Model May Read Numbers, Never Write Them

So the architecture has exactly one non-negotiable rule. The deterministic layer produces every fact. The language model reads those facts and interprets them. The model never generates a fact of its own.

Computation–interpretation boundary concept

A hard separation in a system’s design: a deterministic engine computes all checkable values, and a language model is permitted only to interpret those values—never to originate them. Every factual claim the AI makes must trace back to something the engine actually computed.

When it works, you can point at any claim the AI makes and follow the thread back to a real computation. “Saturn is weak here” resolves to an actual strength score. “This period begins in 2027” resolves to a dated calculation. There is no floating assertion, no confident sentence hovering over nothing. If the engine did not compute it, the AI does not get to say it.

This is the same distinction I explored in “From Echo to Awareness”—the gap between replicating the pattern of an answer and being grounded in the thing itself. The boundary is how you engineer that gap closed.

A Worked Example: A Birth Chart

I built Eternal Evals on exactly this architecture, in a domain that punishes hallucination immediately: Vedic astrology.

The deterministic engine takes your birth date, time and place and computes a full sidereal chart from high-precision astronomical data—planetary positions, houses, divisional charts, dasha timelines, strengths, yogas. This output is not creative. Given the same input, it is byte-for-byte identical, every time. It is simply correct.

Only then does a language model enter, and only as an interpreter. It reads the computed chart and explains it in plain language. It cannot move a planet. It cannot invent a period. If you ask it something the engine did not compute, the honest answer is “that was not computed,” not a fabricated one. The result is an AI that can talk fluently about your chart without ever making your chart up. I tell the fuller origin story in “The Machine That Refused to Guess.”

The Same Shape, Everywhere Truth Is Computable

Astrology is just where I proved it, because the facts are so cleanly checkable. But the pattern generalises to every domain where a wrong fabricated answer does real harm:

• Medicine — an engine computes interactions and doses from real pharmacological data; the model explains them. It never invents a dosage.
• Law — a retrieval layer surfaces the actual statute or case; the model interprets it. It never hallucinates a citation.
• Finance — a deterministic model runs the numbers; the language model narrates them. It never guesses a figure.
• Engineering and code — a compiler, a test suite, a type checker establish what is true; the model reasons over the results rather than asserting them.

What It Costs

I will not pretend the boundary is free. It costs discipline, and discipline is expensive precisely because the tempting shortcut always sounds better.

At a hundred small decision points, it is easier to let the language model “help” with the facts. Let it estimate the number. Let it smooth over the gap. It always reads more fluently. It is always a little bit wrong. Holding the line—engine computes, model interprets, no exceptions—means repeatedly choosing a slightly less fluent answer that is actually true over a slightly more fluent one that is not.

Honesty in an AI system is not a personality you prompt for. It is a wall you build, and then refuse to put a door in, no matter how convenient a door would be.

That refusal is the whole product. Everything good about a computation-first system flows from the willingness to say no to the model at exactly the moment it is most persuasive.

How to Build It

Concretely, three pieces:

1. A deterministic core that owns every computable fact—calculation, lookup, retrieval. It is the single source of truth. It is tested like the critical infrastructure it is.
2. An interpretation layer—the language model—that receives the core’s output and does only linguistic work on it.
3. A hard boundary between them, enforced in the system itself and not merely requested in a prompt. The model is handed facts and asked to interpret; it is never handed the job of producing them.

Modern tooling makes this easier than it has ever been. Tool use, function calling, retrieval, and the Model Context Protocol are all mechanisms for exactly this handoff—the model reaching outside itself for truth. It is why I exposed the Eternal Evals engine as an API and MCP connector: so any AI can compute the chart through the engine and interpret only what returns, rather than guessing. The boundary, made portable.

Build that, and hallucination does not so much get reduced as get designed out—it has nowhere left to happen, because nothing checkable was ever left to the guesser. That is not a bigger model. It is a better-shaped system. And in the end, I think the better-shaped system is what trustworthy AI was always going to require.

---