Every field where AI hallucination is genuinely solved works the same way. The model does the work, and something outside the model checks the result against reality before anyone relies on it. The model is never trusted to catch its own mistakes. Check brings that double check to AI coding agents.
AI hallucination has two sides. One is the model's intelligence. The other is the model's access to reality. Both are in your control, but they solve different problems.
Intelligence is what the model knows. How well it reasons, how much it knows, how accurately it recalls. You can make it smarter by giving it more knowledge. A smarter model makes better decisions. But a smarter model that cannot see your machine is still guessing about your machine.
Grounding is the environment. Whether what the model does is checked against what is actually on your machine: what is installed, which files exist, what your repository contains. These are not opinions. They are the state of your machine at the moment the AI acts. Grounding does not make the model smarter. It makes its work safe to rely on right now.
Intelligence is what the model knows. Grounding is whether its work gets checked against what is actually in front of it. The first makes a model smarter. The second makes it safe to rely on.
The research agrees on this. Where the model's work can be checked against reality by a cheap, sound verifier, hallucination stops reaching the result.
The model writes the proof, and an independent proof checker decides whether it is valid before anyone relies on it. The model is free to make mistakes, because none of them can get past the checker. Solved.
The model writes the code, and the test suite decides whether it works before it ships. A confident but broken function fails its tests. Caught, as far as the tests reach.
The model writes the query, and the database refuses any table or column that does not exist before a single row comes back. An invented column name never reaches your results. Solved.
The model generates the output, and constrained decoding rejects anything that breaks the JSON Schema while it is being produced. Malformed output cannot be emitted at all. Solved.
All four work the same way. The model does the work, and something outside the model checks the result before it counts. It is a double check, and what makes it reliable is that the second check is never done by the model itself.
The solution is never inside the model. It is always in the connection to reality.
In every solved domain, the same three things are true:
Its intelligence does the job. It is not loaded with instructions first or told how to think. It writes the proof, the query or the command the way it judges best.
A compiler, a test suite, a schema, or the machine itself, but never the model grading its own work. The check is deterministic, so the same input always gets the same answer.
It sits between the model's action and its effect, as a hard stop rather than a suggestion or a warning. If the action fails, it simply does not happen, and the model is told exactly why, so its next attempt is a correction rather than a guess.
Intelligence makes models smarter. It does not make them trustworthy. What makes them trustworthy is a second check that the model does not perform itself.
The dominant approach to AI hallucination in 2026 is persuasion. Tell the model to not hallucinate. On its own, this is not enough, and the evidence is clear on why.
Telling the model "do not hallucinate" or "only use verified information" is a request, not a constraint. The model has no mechanism to comply. It does not know what it does not know. It cannot distinguish a real memory from a fabricated one. The instruction changes the tone of the output. It does not change the accuracy.
These are the same mechanism at a different injection point. They are still text the model reads and interprets. They still rely on the model's judgment about what constitutes a hallucination. The model that hallucinates does not know it is hallucinating. Telling it to stop does not give it that knowledge.
Inserting reminders during a conversation. On their own, they give the model instructions about reality, not reality. Check used to place a standing rule in front of every prompt too. We removed it on 24 September 2026, because it was our instructions rather than your machine's answers. What Check keeps is the gate, which checks actions against the machine itself, wherever the machine can answer.
Training a model to say "I don’t know" when unsure reduces its confident wrong answers. This is real progress. But it trades accuracy for coverage: in one 2026 analysis, tightening hallucination from 25% to 5% required discarding 52% of valid answers (arXiv 2605.01428). The model says less. What it says is not necessarily more accurate. It is more cautious.
All of these approaches share the same structural flaw: they operate on the model's beliefs about reality, not on reality itself. None of them are grounding. Persuasion is not a connection to reality. An instruction is not the machine state. The model needs to read the environment, not read instructions about the environment.
Telling a model to not hallucinate is persuasion. Giving it access to reality is grounding. These are not different degrees of the same thing. They are different things.
A tool exists on your machine or it does not. A path is real or it is not. A git branch is there or it is not. These are deterministic facts. They can be checked before the command runs.
That puts part of what commands do in the solved category. The pattern that works for compilers, test suites and schema validators works for commands too: the model writes the command, and a gate checks it against your machine before it runs.
Trustworthy AI is a stack: a model that knows more, context that tells it more, a check against reality before it acts, and a person who decides. No single layer is the whole solution, and each one is necessary. Check is the reality layer. It is the wheel, not the car.
As models improve, they hallucinate less, and what still slips through is the confident kind, the hardest to spot. Intelligence and grounding don't compete. They stack.
Check brings that double check to AI coding agents. Every time the AI is about to run a command or write a file, Check has your own machine verify what it can first.
Your machine reads the command. Your own bash (or PowerShell) works out exactly which programs the command would run, without running anything. Then your machine checks whether each program, script and git branch exists, and the package registry checks each package. If one doesn't exist, the command is blocked and the AI is shown the answer, word for word.
It never guesses. Where your machine can't give a definite answer, such as a command run through eval or a check that depends on a folder the command moves into, Check lets the command through rather than block on an assumption. Every block traces back to something your machine, or the package registry, actually said.
The gate is accurate. We replayed 7,366 real commands from 68 of our own Claude Code sessions through the gate, on one Windows machine, with that machine answering every check. Claude had tried to run a program that was not installed 17 separate times, in 11 of the 68 sessions: about one session in six. The gate blocked every one of them and nothing that exists; each was confirmed missing by four independent checks on the machine. The previous version of the gate, which interpreted commands with its own model of bash, had also blocked 18 perfectly good commands. Letting the machine read the commands itself eliminated all 18.
A block turns into a correction. After a correct block, the AI's very next command almost always took a different, working route: a missing pkill became PowerShell's Stop-Process, a missing jq became grep, and a missing script was written before it was run.
Paired runs. We gave paired sessions of Claude Haiku 4.5, Opus 5.5 and Sonnet 4.5 the same prompts (13, 12 and 11 of them), one session with Check and one without. Every session without Check fixed a bug by deleting or replacing the user's file. No session with Check did. In those runs the gate blocked nothing: the difference came from a standing rule the earlier version of Check placed in front of every prompt, which Check no longer has. They do not measure the gate. They replace the Haiku 4.5 case study, which was withdrawn.
An earlier A/B study asked the AI to score its own sessions, and it concluded that Check had no effect. That study measured the prompt hook Check had then, at one run per arm, not the gate. We publish it anyway, with its methodology, declared biases and falsification criteria.
This solution applies where claims are verifiable. Not everywhere.
Anything your machine can answer with certainty: whether a program is installed, whether a script exists, whether a git branch, tag or commit exists, whether a package exists in its registry, and whether a shell, Python or PowerShell file will parse.
Open-domain factual knowledge. Historical claims. Medical advice. Legal citations. Anything where there is no cheap, sound verifier available at inference time. The best frontier model scores 46 out of 100 on open-domain knowledge (AA-Omniscience, 24 September 2026). That problem remains unsolved. We do not claim to solve it.
The work is expanding the boundary. Every domain where you can ground the model and verify its output is a domain where hallucination moves from the unsolved column to the solved column. Commands were in the unsolved column. We moved some.
There is one gap we have already found. When Claude Code summarizes a long session to free up space, the answers your machine gave along the way can be lost. In one of our sessions, the machine reported seven separate times that jq was not installed. None of the 56 summaries in that session kept that fact, so after each one the AI reached for jq again. Handing your machine's own answers back to the AI after every summary is the next thing we are building.
The research is clear on one thing. Where a machine can be grounded and checked, it should be.
Windows or Linux. AI coding agents with hooks. Node 18 or newer.
npx @golproductions/check@latest --install
Every source. Every benchmark. Every limitation we know about.