What Makes Us Think We Can Even Build a Validator?
And Why Now?


On invariants, not failure modes – and why the timing is not an accident.

 

Sanjay Mittal

Founder & CEO
Predictika.ai

 

Email: sanjay@predictika.com

 

 

Grant the premise. Suppose you accept that an AI agent cannot guarantee its own actions – and that the problem is not unique to AI. A human operator running a script against the wrong database does the same damage. A piece of legacy code, doing exactly what it was told, does the same damage. The actor barely matters. What is missing, in every one of these cases, is a check that sits between the action and the system it acts on, and certifies the action before it is carried out.

 

So far, so good. But then comes the hard question, and it is the right one to ask: what makes us think that check can actually be built? Isn’t the whole problem that you can’t anticipate everything that might go wrong? If you could list every failure in advance, you wouldn’t need the agent to be smart in the first place.

 

This is the objection we take most seriously. Here is our answer.

 

Invariants, not failure modes

 

The objection smuggles in an assumption – that a validator works by listing the ways an action can go wrong. If that were true, the objection would be fatal. The ways an action can go wrong are innumerable. They are open-ended, often adversarial, and frequently novel. No list survives contact with the real world.

 

But that is not how a validator works. A validator does not enumerate failures. It declares invariants – the small set of things that must remain true no matter what – and it blocks any action that would violate one of them.

 

The difference is not cosmetic. It inverts the size of the problem. Take the configuration of a data-center hall. You do not list every bad configuration; there is no end to them. You state what must hold: total power draw must not exceed the feed, thermals stay within envelope, port counts reconcile, components are mutually compatible, and the configuration meets the regulatory and contractual limits that apply. A handful of constraints. Anything that violates them is rejected – including configurations no one has ever seen before. A trading action is the same: you do not imagine every bad trade, you state the position and exposure limits that must not be breached. A configuration change to a live service is the same: it must parse, and it must be compatible with what is already deployed.

 

Here is the property that matters. A constraint engine is closed over its constraints. It does not catch only the failures you imagined, the way a test suite or a hand-written guardrail does. It catches every violation of a known invariant, including the ones you never imagined. That is the whole point. The burden moves from “imagine all the bad outcomes” – impossible – to “state what must hold” – usually finite, and very often already written down somewhere as a spec, a policy, a standard, a contract, or a law. Or a combination of these.

 

We should be honest about the boundary, because it is real. Not every constraint can be stated. Some judgments are open-world – whether an action is fair, or tasteful, or wise in a situation no one anticipated. For those, a complete deterministic validator cannot be built, and we do not claim one. Anyone who tells you otherwise is selling something.

 

But notice where the expensive failures actually happen – not in exotic edge cases, nor in cases requiring judgment of the importance of a constraint, but in violations of rules the organization already had.

 

This is not abstract. In 2021 a single faulty configuration command took Facebook, Instagram and WhatsApp off the internet for six hours – and the audit tool built to catch exactly that kind of command had a bug of its own, so nothing stopped it. In October 2025 a bad configuration change to Microsoft’s Azure Front Door propagated worldwide after a manual operation bypassed the very protection layer meant to hold it back. This month a disaster-recovery test at Workday reportedly reached into production databases and froze payroll and time-keeping for Walmart, Target and others. And in October 2026 Bank of America settled with the U.S. Treasury’s OFAC over 475 sanctions violations – payments routed through blocked banks, exact-match names ranked too low to stop an alert, watchlist updates that never loaded – every one of them a transaction a rule already prohibited, executed because nothing checked it at the moment it mattered. Four industries, four different actors – a command, an engineer, a test script, a screening system – and one shared shape: the constraint existed, and it was not enforced at the point of action.

 

These are not failures of imagination; nobody needed to imagine them. They are failures of enforcement. So the specifiable class – the one where the invariants are knowable and the action can be intercepted before it commits – is not a toy corner of the problem. It is where most of the damage lives. And for that class, the answer to “can it be built” is not a hope. It is yes.

 

Why now

 

If this is so clear, a fair question follows: why didn’t validators become a standard layer of enterprise software long ago? The idea is not new. Constraint-based configuration has existed for decades. Expert systems reached for something adjacent in the 1980s and 1990s.

 

The answer is that checking was never the bottleneck. Capturing the constraints was. Someone had to sit with the experts and transcribe what they knew into rules, by hand, one at a time. It was slow, expensive, and brittle. The moment the world changed, the rules went stale, and the cost of keeping them current was more than most organizations would bear. The validator was buildable in principle and uneconomic in practice. That is what stalled the idea – not a wall of impossibility, but a bill no one wanted to pay.

 

That economics has just changed, and it changed recently enough that most of the industry has not caught up. Large language models are very good at precisely the thing that used to be the bottleneck. Point a model at a large corpus – product manuals, spec sheets, standards, regulations, contracts, incident reports – and it can read all of it and surface the constraints that are implicit in it. It does not get the final word. It proposes, and a deterministic process ratifies what it proposes into rules that are then enforced exactly, every time. It is the same division of labor we argue for everywhere: the model proposes, something deterministic certifies. Here we have simply turned that division on the construction of the validator itself. The model mines the constraints. The engine enforces them.

 

This is not a thought experiment for us. We have built more than two thousand validators from public data. We did it by using language models to search and analyze large public corpora, extract the constraints that govern a domain, and compile them into deterministic validators that enforce those constraints at the point of action. And they are not variations on a single problem. They range across product configuration and quoting, agent actions like refunds, deployments, access changes and network commands, finance operations like three-way match and journal entries, and financial-services decisions like sanctions screening, lending and trade orders. They also reach the physical world: industrial and manufacturing equipment from machining centers to welding cells, and a robot’s proposed motion checked before the arm moves. Different domains, different rules, the same engine underneath. Two thousand is not a number on a slide. It is an existence proof that the capture problem – the thing that kept validators from ever becoming a standard layer – is now tractable at scale.

 

So “why now” has two halves, and they arrived together. The necessity is new: actions now come from many actors – agents, scripts, integrations, legacy jobs – and none of them can be trusted to carry its own check. And the feasibility is new: the one step that made validators uneconomic for forty years, capturing the constraints, is no longer the bottleneck. It is uncommon for a hard problem to become both urgent and solvable in the same moment. This is one of those moments.

 

The real risk

 

We will end where we began, with a caution rather than a boast. The risk ahead is not that validators cannot be built. It is that someone builds an incomplete one and trusts it as if it were complete. The discipline – the actual engineering – is in knowing which class an action belongs to: the specifiable, interceptable class where a deterministic guarantee is real, and the open-world class where it is not. We build for the first. We are honest about the second. And we refuse to blur the line between them. That is what makes the guarantee worth anything at all.

 

When checking becomes a duty

 

There is a further consequence, and it is worth stating plainly. For any system where the cost of a mistake is high, it now makes sense to pair the thing that induces change – an AI agent, a deployment pipeline, a trading system, a person with broad access – with a validator that checks its actions before they take effect. Not as a nicety. As a basic control.

 

And once a control is feasible, the expectation around it changes. For most of the history of software, when a bad action slipped through, the honest defense was that no one could realistically have caught it. That defense is expiring. When a deterministic check can be built – and we have argued that for a large and consequential class it can – the question after the next failure will not be “who could have known.” It will be “a check was available; why wasn’t it there.” It is not hard to see organizations, in high-consequence domains, being held to that standard before long – by regulators, by courts, by their own customers. Feasibility is what moves a failure from misfortune to negligence. The responsible move is to get ahead of that, not to wait for it to be imposed.

 

See a validator work

 

Five short, self-contained demos. Each was built from a company’s public information, with fictional customers and example prices, and each plays back a run recorded on the live engine.

 

Agent Action Validator – the same refund, deploy or access change gets a different verdict depending on who asks, what came before, and what is left in the budget.

 

Robot Arm Action Gate – an AI-planned robot arm motion checked before anything moves – load, reach, a zone speed that depends on who is nearby, open guards and hazardous tools – with a five-rule violation replanned until it clears.

 

Dell Server and Rack Quote – component-level rules for a data-center rack – processors, memory, power and cooling checked together.

 

Loan Action Validator – a lending decision checked against the rules behind it, with the rule that fired attached to the verdict.

 

Three-Way Match – purchase order, receipt and invoice reconciled before a payment is allowed to post.

 

Further reading

 

Don’t Trust AI. Verify Its Actions. – the case for checking the action rather than trusting the model.

 

Complex Business Logic Requires a Declarative, Not Procedural, Approach. – why hand-written rules and procedural code fail as the logic grows.

 

The Business Case for Constraint-Based Configuration. – the constraint engine this paper stands on, and why constraints beat code.

 

About

 

Predictika builds a patented, deterministic constraint engine that checks an AI agent’s action – a refund, a deploy, a quote, a journal entry – against an organization’s actual rules, and returns allow, needs approval or block, with the reason, before anything executes. The approach descends from constraint-reasoning research at Xerox PARC and the configuration engine behind Selectica, now carried into LLM-driven systems. Learn more at predictika.ai.

 

Dr. Sanjay Mittal is the founder and CEO of Predictika. He was a research scientist at Xerox PARC (1982–1990 and 2008–2009), where his work in artificial intelligence and constraint reasoning included founding papers on product configuration. He founded Selectica, the enterprise CPQ pioneer, led its engineering and served as CEO from 2002 to 2003, and invented its configuration engine; Selectica went public in 2000 at about $5 billion, with customers including IBM, Cisco, Dell, GE, Hitachi, Disney, Samsung, Anthem, Aetna, AT&T and BMW. He holds more than ten patents, including two on deterministic validation of LLM-driven systems, and has authored more than twenty publications. He earned a B.Tech. from IIT Kanpur and a Ph.D. from Ohio State University.

 



Copyright © Predictika Inc. 2026