Why our AI can't make up numbers

A language model will tell you, fluently and confidently, that Mars is 78 million kilometres away today. It might be right. It might be off by a factor of three. Nothing in the sentence tells you which.

For a chat app, that can be a quirk. For a product people rely on, it's a defect. So I build to one rule:

The engine does the maths. The AI explains it. And every number says where it came from.

Here's how that plays out in three products.

Mars Deck: the AI is handed the facts

Mars Deck is a live map of the solar system. Its assistant, Ask the Deck, runs on xAI's Grok and answers questions like "when is the next window to Mars?"

The model never works out the answer itself. When a question comes in, the server first computes the relevant positions and dates with the deck's own orbital engine. Those figures go to the model as facts, and it is told plainly that it may not state any number it wasn't given. While it answers, the camera flies to whatever you asked about, so the answer and the map are on screen together.

A made-up figure is treated as a top-priority bug, not a style issue. When I tested a faster model and caught it inventing numbers, it was disqualified, however good its answers sounded.

The cost is real. Answers are less chatty, they're capped at about 300 characters, and the questions run on a paid API with a daily spending limit. The gain is that the assistant can never contradict the readout beside it.

EchoBorn: every card says where its number came from

I also run EchoBorn, a community site for a game. Its main page shows the state of the game world: timers, cycles and a travelling merchant's schedule.

The usual approach is to fetch all of that from a public feed. Instead, our own engines compute the cycles as plain arithmetic, and every card carries a mark: COMPUTED if we calculated it, LIVE FEED if it came from outside.

That labelling earned its keep the day the public feed went down for nine hours. The computed cards carried on as if nothing had happened. The visitor could always tell which numbers were ours and which we were passing along.

WREN: sometimes the right amount of AI is none

WREN is my dictation app for Windows. Speech recognition is AI, and there's no other sensible way to do it. The step after it, tidying the text, was where I expected a language model to shine.

It didn't. A local model took 696 milliseconds to clean up a sentence, and it made the sentence worse by deleting correct punctuation. A simple rules pass, made up of your own vocabulary list and the removal of pure fillers like "um", took 0.063 milliseconds and kept the punctuation. That's about 11,000 times faster, and better.

The rules pass can't reword you, and it can't hallucinate. It also never touches words like "like" or "so", because those are sometimes what you meant.

The pattern

Across all three, it's the same split:

• Let deterministic code do what deterministic code does well. Arithmetic, positions, dates, spelling you've defined.
• Let the model do what models do well. Understanding a messy question, and explaining an answer in plain language.
• Make the boundary visible. A mark on a card, a camera that shows the object, a number the user can check.

None of this is anti-AI. I build with AI every day. It's about putting it where it earns its place. In my experience, the fastest and most reliable step in a pipeline is often the one with no model in it, and the most trustworthy AI feature is the one that shows its sources.