Before cars, we had no need for stoplights, seatbelts, parking lots, gas stations, snowplows, tow trucks, or the DMV. A transportation system built around horses required hay, tack, horseshoes, and the occasional carrot. A transportation system built around cars required us to rethink the road itself.

What good is a Jiffy Lube to a horse?

Most of the time, our systems evolve alongside our technologies. But sometimes a new technology arrives so quickly that we mistake the absence of infrastructure for an unsolvable problem.

That is where we are with AI agents.

People are asking urgent and reasonable questions. What should an AI agent be allowed to do? Which decisions should remain off-limits? How can a company know whether its agents followed policy? Who is responsible when they do not?

These questions are becoming more important as agents move beyond generating text and begin taking actions.

Imagine an AI procurement agent working on behalf of a manufacturer. It searches for suppliers, compares prices, evaluates delivery times, negotiates terms, and places orders. In the course of a single assignment, it may make thousands of small decisions.

The company needs to know that the agent stayed within budget, avoided prohibited vendors, protected customer information, obtained the required approvals, and did not follow fraudulent payment instructions.

Today, the default answer is usually some form of logging.

Record everything the agent saw. Record every tool it called. Record its prompts, intermediate decisions, outputs, and actions. Then, if something goes wrong, inspect the trail.

This sounds sensible because it follows an old model of trust: one party reveals what it did, and another party watches.

But at the scale and speed of AI agents, that model begins to collapse.

A sufficiently detailed record may contain customer data, proprietary workflows, model behavior, internal prompts, commercial strategy, or security-sensitive information. Storing and sharing those records creates new risks. Reviewing them requires time and expertise. And even when complete logs exist, someone still has to determine whether thousands of individual actions complied with a complicated set of rules.

The solution appears to be more visibility: better logs, more detailed logs, more standardized logs, more people reviewing logs.

But that solution produces another problem. The more information we disclose in order to create trust, the more sensitive information we expose.

That means AI governance is not merely a difficult problem.

It is a dilemma.

Problems can be solved. Dilemmas must be reframed.

There is a distinction from Alan Watt’s The 90-Day Novel that I return to often. A problem can be solved. A dilemma is a problem whose apparent solution creates another problem.

Dilemmas cannot be resolved by applying more force to the original question. They require a shift in perspective.

Writers work with this distinction constantly.

A story may begin with an apparent problem: a woman needs to stop drinking. The obvious solution is for her to stop. But that is rarely the real story, because human beings do not experience their lives as neat sequences of problems and solutions.

The more interesting questions exist underneath the visible one.

When did she stop recognizing her own needs? Why is there a paintbrush beside her bed that she has not touched in seven years? Who is Sally, and why does she refuse to answer Sally’s calls?

The writer’s job is not merely to solve the problem presented at the beginning of the story. It is to discover the question that the apparent problem has been concealing.

Funny enough, AI governance demands the same kind of thinking.

The apparent problem is that we cannot inspect everything an agent does. The conventional response is to improve our ability to inspect it.

But what if inspection is not the real requirement?

What if trust does not require one party to reveal everything it did?

The prestigious problem is not always the necessary one.

Much of the technical work around verifiable AI has concentrated on an extraordinarily ambitious problem: proving the underlying computation itself.

In simplified terms, this can mean reproducing and verifying something like a simulated computer processor—demonstrating that an enormous sequence of computational steps was executed correctly.

It is a difficult, elegant, and prestigious problem.

But it is not always the problem that businesses actually need solved.

A company using a procurement agent may not need a cryptographic reconstruction of every internal computation the model performed. It needs answers to narrower and more consequential questions:

Did the agent purchase from an approved vendor?

Did it remain within its spending limit?

Did it obtain authorization before committing funds?

Did it transmit sensitive information somewhere it was not permitted to go?

Did it follow the rules?

That distinction led us to a different plane of reference.

Instead of attempting to expose or reproduce the agent’s entire internal process, we asked whether the agent could prove specific facts about its conduct.

Trust can come from proof rather than disclosure.

In the old paradigm, trust is earned through disclosure.

One party says: Here is everything I did. You may inspect it.

In the new paradigm, trust can be earned through proof.

One party says: I can prove that I followed the agreed-upon rules. You can verify the proof without seeing everything I did.

Return to the procurement agent.

Rather than handing an auditor a complete record containing vendor information, pricing strategy, model prompts, internal reasoning, and proprietary business rules, the system could produce a cryptographic proof that confirms several facts:

The selected supplier was permitted. The transaction remained below the authorized limit. The proper approval occurred. No restricted data was disclosed.

The verifier learns that the requirements were satisfied without gaining access to the sensitive information underneath them.

This is the essential promise of zero-knowledge technology: proving that a statement is true without revealing the private information used to establish it.

In principle, zero-knowledge proofs are well suited to AI governance. In practice, traditional proof generation has often been too slow or computationally expensive for agents operating in real time.

An agent cannot pause for minutes every time it performs an action. Proof must operate at the speed of the system it is protecting.

That is the problem Inherence was built to address.

We have developed methods that generate proofs on the order of tens of milliseconds. In our benchmarks, this is up to 4,778 times faster than prior approaches.

At that speed, proof no longer has to be an after-the-fact auditing tool. It can become part of the agent’s operating environment.

An agent takes an action. The relevant policy is evaluated. A proof is produced. Another system, company, regulator, or customer can verify that the required conditions were met without receiving the agent’s private data, model internals, or strategic logic.

The result is not merely a better audit trail.

It is a different architecture for trust.

AI needs infrastructure designed for AI.

Cars did not become safe and useful because we invented a better horseshoe.

We developed roads, traffic signals, licenses, brakes, crash tests, insurance, and rules of right-of-way. We built infrastructure around the actual properties of the new technology.

AI agents will require the same kind of conceptual shift. They act too quickly and at too fine-grained a level for human observation to remain the primary basis of trust. Their logs can be too large to interpret and too sensitive to disclose. Their behavior crosses organizational boundaries, software systems, jurisdictions, and chains of responsibility.

Trying to solve this only through greater disclosure assumes that the old model of oversight can survive if we simply collect enough information.

But this is the dilemma: the information needed to create trust can itself create exposure, liability, and risk. The way out is not to inspect everything more aggressively. It is to prove what matters.

Did the agent remain within its authority?

Did it comply with the policy?

Did it do what it claimed?

These questions can be answered without revealing every detail of how the agent arrived there.

That is the shift from observability to verifiability, from trust through disclosure to trust through proof.

Building Inherence

It is also the larger vision behind Inherence.

A few months ago, I sat down to work through what I thought was a narrow technical question and accidentally did a great deal of math. By the time I put my pen down, I was looking at a result that changed the scale of the question in front of me.

I had been thinking about how to make proof generation faster. What I had found suggested something larger: that cryptographic proof could become practical infrastructure for autonomous systems.

That left me with a choice. I could treat the result as an interesting piece of mathematics and walk away, or I could accept the risk, uncertainty, and responsibility of trying to build a company around it.

I chose the latter. I chose the thrill.

I founded Inherence because I believe this technology can do real good in the world. AI will not reach its full potential merely because agents become more capable. They must also become accountable in a way that matches their speed, complexity, and autonomy.

The company began with a mathematical result, but the reason to build it was never the math alone. It was the possibility of creating a new primitive for security, governance, and trust—one designed for the systems now coming into existence, rather than inherited from the systems that came before them.

Horses needed trails. Cars needed highways.

AI agents need a new trust layer.

They need proof.

Building that layer is the work I decided not to walk away from.