Signal
AI Governance.
Agent Authorization.
Engineering Judgment.

On AI Governance

The Verifier Gap

Working on AI agent authorization systems has taught me something that is not yet widely understood: the problem of AI trustworthiness is structural, not technical. The next model version will not resolve it. Larger training datasets will not resolve it. The issue is that in unbounded domains, there is no compiler.

In software, the compiler is a brutal, cheap, automatic corrective mechanism. It catches errors before they reach production. AI has no equivalent. In architecture, integration, and governance decisions, errors made by AI remain invisible until they become expensive. Sometimes catastrophically so.

I call this the verifier gap. It is the absence of a verification layer that catches errors before they compound through a system that has already been deployed, already been trusted, and already been given access to data and decisions that matter.

What fills the verifier gap? In every enterprise AI deployment I have worked on, the answer is the same: engineering judgment. Not a tool. Not a framework. Human judgment, applied at the critical junctions where AI generates outputs that will be acted upon without further review. This is not a temporary situation while the models improve. It is a permanent feature of unbounded domains. And the organizations that understand this first will build systems that hold together under pressure. The ones that do not will discover the gap at the worst possible moment.

On Agent Authorization

What Agent Authorization Actually Requires

The financial services industry is currently building authorization frameworks for AI agents. The regulatory requirements are tightening. The frameworks are more complex than they appear from the outside.

An agent is not just a user. An agent can act on behalf of a user, spawn sub-agents, chain authorizations, and execute transactions at speeds that make human oversight a fiction if the architecture is not designed carefully from the start. The naive approach treats agents like users with special permissions. The naive approach fails because it does not account for scope drift, revocation propagation, liability chains between agent hierarchies, or the audit trail requirements that regulators will enforce retroactively.

What authorization actually requires: explicit scope binding at the moment of consent creation, time-bounded permissions with automatic expiration, revocation logic that propagates synchronously through agent chains rather than asynchronously, and an audit log that can reconstruct the exact authorization state for every decision the system ever made. None of this is technically hard in isolation. All of it requires engineering judgment about what matters before the system exists. After the system exists, the judgment has already been made. The only question is whether it was made deliberately or by accident.

The difference between deliberate and accidental authorization architecture is not visible when things work. It is only visible when something goes wrong, when a regulator asks for evidence, or when an agent acts on a permission that should have been revoked three steps earlier in a chain that nobody drew on paper.

On Engineering Judgment

Engineering Judgment Is the New Compiler

Code is now abundant. AI generates it at volumes and speeds that would have been unthinkable two years ago. This is not a threat to engineering. It is a redefinition of what engineering means.

The bottleneck has shifted. When code was scarce, the question was: can we build this? When code is abundant, the question becomes: should we build this, and if so, how do we build it in a way that will not collapse under the weight of the next change request?

That second question requires judgment that no model can supply. It requires understanding the organizational context in which the system will operate. It requires knowing which requirements are real and which are negotiable. It requires anticipating how the system will fail, not just how it will succeed. It requires someone who takes responsibility for the answer.

This is not a soft skill. It is the hardest technical skill in enterprise AI deployment, and it is becoming scarcer as the supply of generated code increases faster than the supply of people who understand what the code is supposed to do, why it was written that way, and what will happen when the organization it serves changes direction.

I have been building enterprise systems since 1998. The tools have changed beyond recognition. The underlying challenge has not. Technology moves faster than organizations. The gap between what a system can do and what an organization can absorb is where most transformation projects fail. Closing that gap requires human judgment. It has always required human judgment. AI has made that judgment rarer, not more common. That is the central fact of enterprise AI in 2026.