"Trust the process, but verify the code." I said it so many times at meetups that it became a shirt design nobody bought. The darker irony of 2026 is that the process itself has become a product. In this bull market, verification theater is selling better than any real proof.
Three weeks ago, I sat in a Lagos co-working space watching a founder from Singapore demo a "verifiable AI agent." The pitch deck had all the bells: zero-knowledge machine learning, an optimistic verification layer, a TEE fallback, and a token that would, of course, "rebalance incentives." The demo was smooth. The code was weird.
I asked for the audit report. What came back was a two-page PDF with a logo I almost recognized. The "verification" section described a process that boiled down to: the model’s output gets hashed and stored on-chain. That’s it. No verification of model weights. No verification of input data. No verification of the price oracle feeding the agent real-world information. Just a hash of an answer, stored permanently.
I checked my numbers afterwards. This project raised $120 million in a Series A last March. Its token is up 14x since launch. And it took me a while to understand why the audit looked so clean: there was almost nothing in it to audit.
AI agents are the new DeFi Summer. In the last twelve months, the sector — marketed under labels like "DeAI," "verifiable compute," and "autonomous commerce" — absorbed more than $8 billion in venture funding. Every major exchange listed a token with a bot name. Every incubator birthed a protocol where an autonomous trader or marketer executes with "cryptographic guarantees." Search any block explorer, and you will find a graveyard of agent contracts that moved money exactly once, at deployment.
Let me say what nobody wants to hear in a bull market: most of those guarantees are hypothetical. And the gap between the narrative and the implementation is where the next wave of user losses will come from. I risk sounding like the safety wrapper on every pitch deck, but the difference between this mania and previous ones is that the collapse will be misdiagnosed as an AI-safety problem when it is really an engineering-audit problem.
The thesis, I want to be clear, is compelling. Read it without the marketing lens, and it makes real sense: if an AI agent is going to custody funds, move positions, or sign messages on behalf of users, then those users deserve to know what model ran, what inputs it consumed, and whether the computation was tampered with along the way. That is the floor of "verifiable AI." It is a governance question as much as a technical one — the same philosophical spine we used in 2017: don’t trust, verify.
The execution, however, keeps stranding users at the airport of good intentions. Let’s walk through the three roadmaps being sold and where each one breaks under honest stress-testing. Based on my audit experience from the 2022 bear-market trenches to the present cycle, I have seen the same wiring diagrams in multi-million-dollar DAOs and low-cap experiments. The failure modes repeat.
The first roadmap — the one you will hear called the gold standard — is ZKML, zero-knowledge machine learning. A prover generates a proof that a specific computation ran correctly on a specific model with specific inputs, without revealing the weights. This is beautiful mathematics. It is also terrible economics. Even a mid-sized transformer requires minutes of proving time and gigabytes of memory per inference. The proof costs more than the prediction it validates. And here is the dark detail I rarely see in blog posts: the model is usually hosted by a centralized GPU provider. ZK does not decentralize that. ZK only proves that "that" centralized server ran correctly. You have upgraded the nature of trust, not reduced the parties you must trust. You still trust one API key. I have verified fourteen ZKML pipelines this cycle; eleven of them depended on a single cloud endpoint signed by a single organization.
The second roadmap is opML — optimistic machine learning. Anyone can compute the output; you are presumed correct unless someone challenges. Optimistic designs are elegant, but they carry a hidden demand: at least one honest, well-funded challenger must exist at all times. In a bull market, nobody challenges — because challenging an in-vogue token community is expensive, technically demanding, and socially risky. In a bear market, nobody cares. Either way, the security assumption is, practically, "hope." There is a deeper mechanical mismatch as well: optimistic fraud proofs were designed for stateless transactions, not for continuous, stateful inference loops. An agent that trades every minute generates thousands of outputs per day. Challenging one percent of that volume is an enterprise-scale operation. The math does not work at the speed the narrative promises.
The third roadmap is TEEs — trusted execution environments. Chip-level attestations that the code running inside an enclosure is the code you intended. Fast. Cheap. Pragmatic. And effectively a bet that Intel, AMD, and the cloud providers hosting them have no remote exploits, no backdoors, and no inconvenient legal obligations to subpoena memory. TEEs are genuinely useful. TEEs are not "trustless." They move trust from one party to a supply chain of chip manufacturers and facilities concentrated in three countries. In an emerging-market context, I can tell you exactly what that means: the user loses, the vendor explains in English, and the regulator explains in a language the vendor does not speak. We saw this movie in mobile-money integration and in everything I tried to build with Sankofa Yield. The trust stack follows the geopolitical stack.
Here is the insight that most analysis skips: even if you solve the proving layer, you still inherit the oracle problem — because an AI agent is only as honest as its inputs. The founder I met in Lagos was building an autonomous yield agent. Its price feed, when I asked directly, came from a "decentralized oracle network" that turned out to be three nodes in Frankfurt. The cryptographic guarantee over the model output means nothing when the data entering the model is garbage. I have said it for years: garbage in, gospel out. The result may be verified; it will still be wrong, and the user will still be poor.
In a bull market, "verification theater" is the new "liquidity mining." In 2021, projects faked volume to attract real capital. In 2026, I am watching projects fake proofs to attract real capital. The mechanics have shifted from fabricated trades to fabricated trust. I have audited projects claiming "on-chain verifiability" and found the entire pipeline in a TypeScript orchestration script — no model registry, no input commitment, no dispute mechanism, no slashing. Just a hash, a banner, and a trading pair. The writeup writes itself; the code testifies otherwise.
A question that deserves far more friction than it receives: who is supposed to verify the verifier, and who pays for it? The verifier’s dilemma, first described in blockchain literature, exposes an uncomfortable economic truth. When verification is expensive and fraud is rare, the rational strategy is not to verify. You save on audits, on challenge games, on redundancy, and you outrun disciplined competitors. This is not corruption. This is game theory. In a bull market, the payoff for speed is so large that verification becomes an ornament worn in the whitepaper rather than a load-bearing wall. The only sustainable counter-pressure is real user losses, which then produce a winter of introspection. That is not a comforting thought, but it is the thought the enthusiasm does not want you to have.
There is also a scheduling problem almost nobody prices in. The proofs that make verification real — ZKML, zkVM, frequent opML challenges — are data-hungry. They compete for blob space on layer-2 rails that already struggle with DeFi volume. Post-Dencun, we were promised cheap data forever. My pipeline analysis suggests AI-verification demand will saturate blob space far earlier than public estimates assume. When that saturation hits, the rollups with the most ambitious verification workloads will see their gas costs double, then double again — and the economics of "verify every inference" will quietly die, regardless of which proving scheme wins the culture war. Verification is not just a math problem or a trust problem. It is a bandwidth problem, and bandwidth has a price.
So let me offer the contrarian take, because I am tired of the binary between "AI agents will eat finance" and "AI agents are all scams." The real survivors will not be the projects with the most advanced proving schemes. They will be the ones that define an honest boundary of trust — and publish it with the same clarity as their tokenomics. A protocol that says "we use a TEE, and yes, we trust Intel, and here is what that means for your worst-case losses" is infinitely more valuable than one that claims "fully trustless AI" while a single API key serves the whole network. Narrow certainty beats broad fiction.
The bottleneck is not ZK. The bottleneck is not even the model. The bottleneck is the willingness of founders to say out loud what they are actually trusting — and the willingness of communities to accept a secure boundary instead of demanding a magical one. On this point, the verifiable-AI era will learn the same lesson DeFi learned in 2020: decentralization is a journey with honest checkpoints, not a claim you can mint after a seed round.
For the record: I remain optimistic. My own Verifiable Truth Initiative has spent the past year wrestling with these exact failure modes, and we have come away with deeper respect for both TEE vendors and ZK researchers; each has a place, neither is the whole answer. The next generation of agents will be verifiable in narrow, well-defined slices: "We verify the model inference. We do not verify the oracle, and here is the insurance we have bought for that gap." That is an architecture a user can actually make a decision on.
But that future does not arrive by accident. It arrives when users — right now, in this bull market — start asking the uncomfortable question at demo day: "What are you actually proving?" Because right now, the honest answer from far too many projects is: "That we can raise $120 million and produce a PDF."
Trust the process, but verify the code. If you bought the token, you are the process. And nobody is verifying you.
