Why AI cannot fact-check itself.

The core problem: no ground truth.

AI models hallucinate because they generate text based on pattern probability, not verified facts. When you ask a model to "check" its answer, it runs the same process again - pattern completion against the same training data, with the same biases, the same gaps, the same tendency to produce plausible-sounding text.

Self-consistency is not accuracy. A model can generate the same wrong answer ten times in a row and be 100% consistent and 0% correct. Consistency measures whether the model agrees with itself. Accuracy measures whether the model agrees with reality. These are different things.

The model has no mechanism to distinguish between "I know this is true because my training data supports it" and "I'm generating this because the pattern probabilities favor it." From the inside, a hallucinated response feels exactly the same as an accurate one. There is no internal signal that says "this one is made up."

Why "generate, then reflect" fails.

Same weights, same blind spots. When a model generates an answer and then evaluates it, both steps use the same weights. If the training data contained a misconception, the evaluation step will confirm the misconception. The model cannot catch errors that originate from its own training.

Confidence calibration does not help here. A model can be highly confident in a hallucinated answer. Asking "how confident are you?" produces a confidence estimate from the same uncalibrated process. RLHF training makes this worse - models are trained to sound confident, so the confidence estimate is inflated for both correct and incorrect answers.

The sycophancy problem amplifies. When you prompt a model to review its own output, you are essentially asking it to critique something. Models trained on RLHF are biased toward agreement and helpfulness. The model is more likely to confirm its own answer than to challenge it.

Chain of thought does not escape this. Showing the model's reasoning does not make the reasoning correct. A model can produce a perfectly logical chain of reasoning from a false premise and arrive at a false conclusion - confidently and consistently.

What about multi-model verification?

Using a second model to check the first model's output is better than self-verification, but still insufficient. If both models were trained on similar data, they share similar blind spots. If the training data says X (and X is wrong), both models will agree that X is correct.

Multi-model approaches add diversity, not truth. They increase the chance that one model might disagree, creating a signal worth investigating. But disagreement is not a reliable hallucination detector - models can disagree about correct answers and agree about incorrect ones.

The fundamental issue remains: no model in the chain has access to ground truth. You cannot get truth by running opinions through more opinions. At some point, the system must contact reality.

Verification requires external reality.

The only reliable verification is external verification - checking the model's output against something outside the model. Not against its own weights. Not against another model's weights. Against the actual state of the world, right now.

This is what Check does. Before the AI acts, Check reads the actual machine state - file systems, databases, APIs, configurations - and injects that reality into the AI's context. After the AI proposes an action, Check verifies the action against that same reality. The model's self-assessment is irrelevant. What matters is whether the proposed action matches what actually exists.

Grounding is the technical term for this. An AI is grounded when its outputs are connected to verifiable external reality, not just to its own internal patterns. Without grounding, every AI output is an unverified claim. With grounding, every AI output can be checked.