Safe AI May Be a Myth. Checked AI Is Not.

Safe AI May Be a Myth. Checked AI Is Not.

We cannot make a machine benevolent. We can check what it does — one task and one rule at a time, before it acts.

A recent piece in The Atlantic, “The Myth of Safe AI,” makes a claim that would have been heresy in Silicon Valley two years ago and is now close to conventional wisdom: the promise to make AI benevolent may be technically impossible. The admissions it collects are striking, and they do not come from critics on the outside. OpenAI conceded as far back as 2022 that there was “no known indefinitely scalable solution to the alignment problem.” Four years on, the company’s own chief scientist writes that “no lab has solved alignment,” and a former OpenAI safety researcher likens the whole effort to buttressing a structurally unsound dome — you patch the cracks you can see, and wait for it to come down somewhere you did not look. We should take this seriously, precisely because the people saying it are the ones building the systems.

Watch where even the optimists end up

Now, it is tempting to read all of this as a counsel of despair, and much of the commentary does. But look closely at where even the optimists land, because that is where the useful idea is hiding. The article sets two camps against each other. On one side, Anthropic’s Dario Amodei argues for a slowdown, to let alignment ‘keep up.’ On the other, Nvidia’s Jensen Huang calls the fear “not grounded on science” and insists that preventing AI incidents is “as simple as engineering” — just go in and root-cause the problem. The two could not disagree more about the nature of the technology. And yet, when a third voice in the piece, a researcher at Princeton, is asked what would actually have prevented the real incidents, his answer belongs to neither camp: “We have this entire set of safeguards that we can use to control these systems,” he says — and the safeguards he names are limiting what files and programs a model can touch, and monitoring what it does. Note what that is not. It is not inscribing a moral code into a neural network. It is watching the action, not perfecting the mind.

Aligning the mind is the wrong question. Checking the action is the right one.

That distinction is the whole game, and it is worth stating plainly. Alignment, as the field has framed it, asks an open-ended and possibly unanswerable question: can we make the machine itself good — honest, harmless, well-intentioned — across every input the world might present? This is hard for a reason that predates computers: we have argued for millennia about what ‘good’ even means, and we are not going to settle it in a training run. But there is a second, much narrower question we almost never ask, and it turns out to be the tractable one. For a given task, with its own explicit rules, is this particular action the machine is about to take correct — i.e., valid, permitted, and safe to execute? We do not need to know whether the model is wise. We need to know whether this one output is allowed. Let us give the thing that answers that question a name: a ‘validator’ — an independent, deterministic check that takes a proposed action together with the rules that must hold, and returns valid or invalid, with reasons, before the action takes effect.

Start with the simplest case: a shopping cart

Let us make this concrete with the simplest case, because the shape is easiest to see there. Consider a personal AI agent — the kind Meta has launched as Muse — asked to fill a shopping cart under a budget. The agent is good at the part it is good at: understanding what you want, finding the items, assembling a plausible order. But a cart is not a list; it is a web of coupled rules. Drop a promotion to qualify for a bundle, and the price changes; the new price changes warranty eligibility; the warranty changes the total against your limit. No amount of fluency guarantees that the agent has reasoned about all of those at once. So we do not ask it to. We place a validator between the proposed cart and the charge: it checks the final cart against every rule that must hold — budget, eligibility, the promotion-and-warranty interactions — and only a cart that passes is allowed through. The agent proposes; the validator certifies. Now generalize, because the enterprise looks exactly the same, only with more zeros. A quote, a configuration, an order, a journal entry, a trade, a benefits enrollment — each is a set of interdependent decisions that must be jointly correct, and each has rules that must hold before it is committed. In every one of them the same division of labor applies: let the AI do the proposing, and let a deterministic checker decide whether the result is valid.

Why this is tractable where alignment is not

Keep in mind why this works precisely where alignment does not. Alignment asks for universally good behavior from an open-ended mind over an unbounded space of inputs — a target that is contested, unbounded, and impossible to verify. A validator asks only a bounded question with a checkable answer: given this task’s stated rules, does this proposed action satisfy them? That question can be specified, it can be enforced, and — this part matters — it can be audited after the fact, because the validator can show exactly which rule passed or failed and why. In other words, we have traded an unsolved philosophical problem for a solved engineering one. We already do this everywhere else in high-stakes life and think nothing of it. We do not make pilots infallible; we give them checklists, interlocks and air-traffic control. We do not trust a single number in a company’s books; we reconcile it. A validator is simply that deterministic check, applied to the actions of an AI, before those actions reach the world.

No, the agent cannot just check itself

Now the obvious objection: if the AI is so capable, why not have it check its own work? Because a probabilistic model cannot certify a hard constraint — and that, in the end, is the lesson of every alignment failure in the Atlantic’s account. A system that produces a plausible answer can just as easily produce a plausible answer that is wrong in a place no one looks, and it has no sound way to prove to you that it did not. The check has to come from somewhere else: a deterministic engine, separate from the thing it is checking, that does not guess. (This is the work we have spent the better part of three decades on — first at Selectica, now at Predictika — reasoning about many interdependent rules jointly and returning an answer that provably holds, or provably does not.) There is a pleasant corollary here, too. Because the guarantee lives in the checker and not in the model, we do not need the largest, most expensive frontier model to make the pairing safe; an adequate model, guided and corrected by a deterministic validator, will do. The checker, not the mind, carries the promise.

A smaller promise — and one we can keep

Let us be careful not to oversell this, because overselling is exactly what has discredited the broader safety conversation. A validator does not solve AI safety. It does not align the machine, and it makes no such claim. It does one smaller and more honest thing: it limits the blast radius. For the bounded, high-value tasks where AI is actually being deployed today — enterprise transactions and personal-agent commerce — it turns ‘trust the model’ into ‘check the action,’ which is the whole difference between hoping and knowing. That is a far smaller promise than making AI benevolent. It is also one we can actually keep.

So we can grant The Atlantic its premise and lose nothing. Perhaps we cannot make AI safe in the grand sense; perhaps the aligned mind is, as the reporting suggests, a myth. But we were never going to run a civilization on good intentions in any case — we run it on checks, on reconciliations, on the humble machinery that catches the error before it becomes a loss. The task in front of us is not to perfect the machine’s character. It is to check its actions, one task and one rule at a time, before they take effect. That is not a myth. It is engineering, and we can start today.

Written in response to Matteo Wong, “The Myth of Safe AI,” The Atlantic, October 22, 2026, and the wider 2026 conversation on unsolved alignment and agentic-AI risk.