The safe answer is 'I could not check'

The tempting answer

Every automated check eventually meets a case it cannot resolve. A name it cannot match to a record. A jurisdiction it has never seen. A document it cannot read. A data source that happens to be down for the thirty seconds you asked. The question is not whether this happens. It happens constantly. The question is what the system does when it does.

There is a tempting answer, and it is tempting because it is invisible. When the system cannot find a problem, let it report no problem. Nothing matched, nothing to flag, move on. The screen stays green. The demo runs smooth. Nobody waits.

It is also the single most dangerous thing the system can do, and it is dangerous precisely because it looks like success.

The error that costs

In ordinary software a missed check is a small bug. In regulated work it is the whole risk, because the two ways of being wrong are not the same size. Take a sanctions screen. It can flag a clean party, which costs a compliance officer a few minutes. Or it can clear a sanctioned one, which is a violation, a fine, and a name in a newspaper. Those are not two settings of one dial. They are different in kind.

When the errors are that lopsided, the design follows on its own. You build the system to make the cheap mistake and never the expensive one. A false flag is undone in a minute. A false clear is found later, by someone who is not on your side. So when the system cannot verify that a party is clean, it must not report the party as clean. It must report that it could not check.

That is what failing closed means. Not failing loudly, not failing often, but refusing to let the absence of a finding stand in for a clean result. What the engine returns in that case is not a verdict. It is an admission:

{
  "decision": "could_not_verify",
  "reason": "unresolved_party",
  "message": "Could not resolve 'ACME Trading FZE' to a screening record. The sanctions check is incomplete; verify manually before proceeding.",
  "checked": false
}

The system has to know the difference between "I checked and it is fine" and "I could not check," and it has to say which one it means, every time. Silence is not an answer.

The same discipline, everywhere

Once you hold to it, the rule shows up in every domain wearing the same face. When a transfer's destination is not in the table, the engine does not call the transfer lawful. When a date cannot be read, it does not call the deadline met. When a clause is ambiguous and the model is unsure, the reading goes to a person rather than into a verdict. In each case the engine declines to turn "I do not know" into "it is fine."

There is one domain where the direction looks reversed, and it is worth seeing, because it shows the principle is about cost and not about caution for its own sake. In AI governance, when the engine cannot tell how risky a system is, it does not default to low risk and wave it through. It treats it as high risk until a person decides otherwise. The conservative direction is not always "block" and not always "allow." It is whichever direction guards against the expensive mistake, and in governance the expensive mistake is letting a dangerous system pass as a trivial one.

The point

Failing closed makes a system look worse in a demo. It says "I do not know" more often than a system that guesses, and a confident guess always shows better on a slide than an honest blank. That is exactly why most systems skip it, and exactly why the ones that skip it cannot be trusted with anything that matters.

In a field where a wrong silence is a fine, a missed sanction, or a harmed patient, the ability to say "I could not check this" is not a weakness. It is the qualification. A system that cannot say it is not careful enough to stand near a regulator. Everything else the engine does, every rule, every citation, every deterministic check, rests on the fact that when it does not know, it says so.