Last week I spent four hours hunting a single number. The number was 79% — the share of multi-agent failures that supposedly trace back to specification problems. It appeared in a strategy document on Salesforce's Dreamforce 2026 positioning, attributed to "the article author's analysis." No paper. No dataset. No vendor survey. No sample size. Four hours of searching produced no origin point, no methodology, and nobody willing to claim authorship.
And yet that number is now load-bearing. It sits underneath a product narrative worth potentially hundreds of millions in annual contract value: that agent governance is not a compliance add-on but infrastructure, and that whoever owns the governance layer owns the enterprise agent economy.
Ignore the number. Watch what happens when you try to verify it. Because the thing crypto has been shipping for roughly eighteen months — agent identity registries, agent payment rails, on-chain reputation scoring — is a direct attempt to solve the exact problem that sentence gestures at. And it carries the identical verification problem. A registry nobody audits is a registry nobody should trust.
Illusions dissolve under stress testing. So I ran the test. What follows is what held up, what collapsed, and where the actual money sits.
The Claim, Stripped to What Can Be Verified
Here is the honest ledger. I refuse to build an argument on unverifiable scaffolding, so let me separate the Salesforce positioning into three tiers before I analyze anything.
Verifiable today: Salesforce launched Agentforce in late 2024 and shipped an agent command center with Model Context Protocol support in mid-2025. That is documented. The company reported Agentforce and Data Cloud annual recurring revenue crossing roughly $1.2 billion in its fiscal Q2 2026 disclosure. Also documented. The direction — governance, observability, and permissioning as a sellable platform layer — is consistent with everything Salesforce has said publicly for eighteen months.
Plausible but unconfirmed: an agent revenue line at $1.5 billion with 240% year-over-year growth. That arithmetic is not crazy on its own, but 240% compounding on a $1.5 billion base implies roughly $5.1 billion within a year. Very few enterprise software lines have ever done that. When I see a growth rate quoted without a net revenue retention figure attached, I assume the author did not have one.
Unverifiable and structurally suspect: product names tied to future dates, a partnership roadmap extending into 2027, and the 79% figure. Those I treat as trend inference, not reporting.
This distinction is not pedantry. It is the entire difference between a research note and a pitch deck. In 2017 I audited the cold-storage claims of five token projects by tracing Ethereum mainnet flows with a Python script. Three of the five held less than 5% of their stated reserves in cold storage. The whitepapers were internally consistent, beautifully typeset, and wrong. The only thing that separated the two documents was whether the numbers could be traced to a ledger. That habit never left me.
The Liquidity Map Nobody Draws
Step back from the vendor announcement. The macro question is simpler: where is the marginal dollar of enterprise software budget actually going in this cycle, and what does that do to the crypto asset class?
Enterprise AI capex has been the dominant absorption mechanism for discretionary software spend for two years running. That is not controversial. What is under-discussed is the composition shift inside it. Inference spend is now competing with orchestration spend. Observability, logging, permissioning, and evaluation tooling — the invisible middleware — are growing faster than the model line item itself, because models have commoditized faster than the systems around them.
That is the vector. Follow the vector, not the hype. The governance layer is where enterprise buyers are being told to spend next, and Salesforce is not the only vendor making that argument.
Now overlay the crypto side. Stablecoin float has been running in the neighborhood of $280 billion — a number I would want to re-pull before quoting in a client memo, but the order of magnitude is right. Most of that float is settlement infrastructure for humans. The open question that has consumed every agent-payments protocol team I have spoken with this year is whether that float becomes settlement infrastructure for machines.
That is the macro map. Two systems are converging on the same missing primitive from opposite directions. Enterprise software is converging on it from the top down, through proprietary permission graphs. Crypto is converging on it from the bottom up, through open registries and payment rails. Neither has solved it.
The Specification Layer Is the Real Bottleneck
Let me rescue the 79% figure by finding what it was probably mangled from.
In early 2025 a Berkeley-led group published a multi-agent failure taxonomy. They analyzed traces from several agent frameworks, catalogued fourteen failure modes across three categories, and reported that the largest cluster was not model capability. It was specification and inter-agent misalignment — agents that were individually competent but collectively uncoordinated, because nobody had written down precisely what each one was supposed to do, in what order, with what authority, and with what stopping condition.
That finding is real. The precise percentage is contested, and I am not going to launder someone else's rounding error into authority. But the directional claim is correct, and I have watched it hold in practice.
Here is the structural reason it must be true. When you scale a multi-agent system, the failure surface does not scale linearly with agent count. It scales with the number of possible interaction paths, which is closer to quadratic. Three agents have three pairwise relationships. Ten agents have forty-five. Each path needs a specification, and each specification needs a conflict-resolution rule when it contradicts another.
This is a consensus problem wearing a product-management costume. Distributed systems have faced this exact shape for forty years, and the industry's answer was never "more capable nodes." It was a protocol: a shared, verifiable, deterministic rule set that every participant could check independently. Paxos, Raft, and eventually blockchains are all the same answer to the same question — how do you get independent actors to agree on state when nobody trusts anyone's private ledger?
Salesforce's answer is a permission graph that lives inside its Trust Boundary. Crypto's answer is an on-chain registry that anyone can read. Both are consensus layers. One is closed. One is open. Both are attempts to price the same underlying good: verifiable coordination.
Vector Decomposition: Where the Money Actually Accrues
When I modeled DeFi yield sustainability in 2020, the technique was to decompose a headline APY into its constituent vectors — organic trading fees, incentive emissions, leverage carry, and reflexive token appreciation — and then ask how much of each survived when emissions went to zero. Short-term liquidity mining had inflated total value locked by roughly 300%. Strip the emissions and most of the yield was a subsidy dressed as a return.
Apply the same decomposition to the agent economy. Every dollar of "agent value" resolves into some combination of:
Compute — inference calls. Accrues to model providers and their hosting clouds.
Orchestration — task routing, tool selection, state management. Accrues to whoever owns the runtime.
Permission graph — who is allowed to invoke what, under which identity, with what scope. Accrues to whoever owns the trust boundary. This is the contested layer.
Settlement — moving value between agents. Accrues to stablecoin issuers, payment processors, and the chains underneath them.
Verification — proving an agent did what it claimed. Accrues to oracles, attestation services, and restaking networks that rent out economic security.
Observability — recording what happened. Accrues to logging and analytics vendors, and carries a storage bill nobody models.
Now run the stress test. Which of these vectors is defensible?
Compute is commoditizing. Orchestration is being absorbed into the platform layer for free. Observability is a feature, not a business, at the enterprise tier. Verification is genuinely hard and genuinely valuable — and is the one vector where crypto has a structural advantage it has not yet monetized. Settlement is a land grab. The permission graph is the only vector where a vendor can build a tollbooth that survives model replacement, because it is bound to the customer's identity and data, not to the model.
That is why Salesforce is framing governance as infrastructure. Not because governance is technically interesting. Because it is the only layer in the stack that does not get commoditized.
Identity: The Registry Question Both Sides Are Avoiding
An agent without a verifiable identity is an anonymous process. Every governance claim collapses into "we promise" without it.
Crypto's current answer is a draft standard from Ethereum circles, authored with contributors from wallet, search, and exchange infrastructure — three registries: identity, reputation, and validation. An agent registers a handle. Counterparties accumulate attestations against it. Third parties stake economic value to validate claims. It is a clean design, and it maps almost perfectly onto the enterprise concept of a service account plus an audit trail plus a certification authority.
Salesforce's answer is the Trust Boundary: agents run under the authenticated permissions of a real human user, inside a container the platform controls.
The design difference is not technical sophistication. It is the location of the root of trust.
In the enterprise model, the root of trust is the platform. The platform decides who is an agent, what the agent can touch, and what the audit log says. This is enormously convenient for the buyer, who gets a compliance artifact without building one, and enormously convenient for the seller, who now sits between the customer and every machine that acts on the customer's behalf.
In the on-chain model, the root of trust is economic. Nobody grants permission. Participants stake value, and misbehavior is priced. This is enormously inconvenient for the buyer, who must now think about key management, gas, and adversarial behavior, and enormously valuable for anyone who wants an agent that can transact with a counterparty that has never heard of their vendor.
These are not competing products. They are competing philosophies of trust, and the enterprise one wins onshore, in regulated industries, in the short term — because it converts a technical problem into a procurement decision, and procurement decisions can be signed.
Where it loses is at the boundary. An agent governed by Trust Boundary A cannot transact with an agent governed by Trust Boundary B unless someone builds a translation layer, and that translation layer is now the most valuable unowned real estate in the stack. Everyone knows it. Nobody has shipped it.
Settlement: Why the Machine-Money Rail Is Already Decided
This is the part of the conversation where crypto people and enterprise people talk past each other, and I want to be blunt about why.
In 2025, four serious agentic payment specifications shipped within about five months of each other: a card-network-backed agent payments protocol, an HTTP-402-based stablecoin rail, an OpenAI-and-Stripe commerce protocol, and a Google Cloud instantiation of the same idea. Some of these overlap. Some are complementary. All of them were announced with partner lists that read like a who's-who of payments infrastructure.
Now notice what every single one of them actually settles on. Not a new unit of account. Not a token. Not a chain's native asset. Dollar-denominated stablecoin balances or card-network authorization rails.
I have held a specific view on Bitcoin since the spot ETF approvals, and I will hold it here: the original peer-to-peer electronic cash thesis is dead. It was killed not by regulation but by success — the asset was absorbed into portfolio allocation models as a macro hedge and a liquidity beta instrument, and the actual machine-to-machine value transfer use case migrated to stablecoins on high-throughput chains. That is not an opinion about price. It is an observation about which rail a software agent would actually choose if you asked it to pay a counterparty $0.004 for an API call at three in the morning.
Bitcoin cannot do that transaction economically. Ethereum mainnet cannot do it economically. A stablecoin transfer on a cheap, fast chain can.
Volume without conviction is just noise. The question is not whether agent payment volume exists. It is whether that volume is economically meaningful or a subsidized ghost. I have been burned by this distinction before, in 2020, when a 300% total-value-locked increase turned out to be the same dollars cycling through the same three protocols with a token incentive stapled to each hop. I will not make the mistake twice.
What On-Chain Data Would Actually Prove Agent Demand
Here is the part of this essay that is genuinely useful, and it is the part I would hand to an analyst on my desk tomorrow.
The agent narrative has a measurement problem, and I think it is solvable. When I built a simulation of autonomous agent interaction with blockchain networks in 2025, the model predicted roughly a 200% increase in transaction volume driven by machine-to-machine activity. That prediction is only useful if you can falsify it. So here is the falsification protocol — five proxies I would track, and what each one means when it moves.
First, the transfer-size distribution. Human retail transfers cluster in recognizable bands. Machine payments do not — they cluster at sub-dollar and sub-cent granularity and they arrive in high-frequency bursts. If stablecoin transfer counts are rising while median transfer size is falling, you are watching machines. If count and median size rise together, you are watching humans and macro flows. This single chart separates the two narratives better than any vendor announcement.
Second, gas consumption entropy. Agents transacting programmatically produce more predictable gas patterns than humans clicking buttons. Addresses with low behavioral variance and high transaction counts are machine addresses. You can cluster them. I have done a cruder version of this when auditing exchange proof-of-reserves in 2022 — the same trace logic that found solvency gaps finds automation fingerprints.
Third, registry growth quality. An identity registry's raw registration count is worthless. What matters is the ratio of registrations that subsequently transact to registrations that never do, and the half-life of that activity. A registry where 90% of handles are dormant is a marketing artifact. In 2021 I made exactly this kind of argument about NFT holder distribution — that floor prices correlated with global M2 money supply rather than intrinsic utility, and that the "digital art" framing was masking a liquidity trap. The tell was concentration and velocity, not price. The same tell applies here.
Fourth, oracle update frequency. If agents are consuming price feeds to make decisions, feed update frequency and the number of distinct consumers per feed should rise before transaction volume does. Oracle consumption is a leading indicator. Transaction volume is a lagging one.
Fifth, the cost side. Complete observability of agent behavior implies storing every action trace forever. That is a storage and compute bill that scales with agent count and appears nowhere in the marketing. When a governance vendor starts disclosing per-agent infrastructure cost, you will know the economics are real. Until then, assume the unit economics are worse than presented.
The Cost Curve Nobody Publishes
I want to spend real space on this because I think it is the most under-modeled risk in the entire narrative.
The pitch is that governance solves coordination failure above five agents. The implicit assumption is that governance cost scales linearly with agent count. It does not. It scales superlinearly, for three mechanical reasons.
Tool proliferation. An enterprise exposing sixty-odd callable tools through a standard protocol must maintain sixty-odd permission scopes, version histories, deprecation paths, error contracts, and audit hooks. Every tool is a surface. Every surface is a scope. Every scope is a policy that must be reviewed when the tool changes. This is not a governance feature; it is a governance liability that the governance product is being sold to manage.
Path combinatorics. As I argued earlier, interaction paths grow closer to quadratically. Each path needs a specification, and each specification needs conflict resolution. At ten agents you have forty-five relationships. At thirty agents you have four hundred and thirty-five. Nobody has published a governance overhead curve against agent count, and the absence of that curve in every vendor deck I have read is itself the finding.
State consistency. The genuinely hard engineering question — how do you guarantee that a multi-agent workflow either completes or rolls back cleanly when agent seven fails after agents one through six have already written to production systems — appears in essentially none of the public materials. Distributed transactions, idempotency keys, compensating actions, saga patterns. This is solved engineering in traditional systems. It is unsolved in agent systems because agents are non-deterministic. A rollback of a deterministic transaction is trivial. A rollback of a language model's side effects is a research problem.
That third point is the one I would put money behind. The specification layer is hard. The state-consistency layer is harder, and nobody is selling it yet.
Distribution Beats Proof Systems, Every Time
I have a standing disagreement with most of my peers on Layer 2 architecture, and it is directly relevant here.
The received wisdom is that the rollup landscape will be decided on technical merit — proof systems, finality guarantees, data availability costs. I think that is wrong. The real difference between the dominant optimistic stack and the dominant zero-knowledge stack was never the cryptography. It was which team convinced more projects to deploy chains first. Distribution, not mathematics, decided market share. The proving system is a cost input. The developer relationship is the moat.
The agent settlement layer will resolve the same way. Every chain with a credible throughput story wants to be where agents pay each other. Almost none of them will win on cost per transaction, because costs compress toward zero across the board and the differentiator disappears. The winners will be the ones whose tooling an agent developer can integrate in an afternoon, and whose identity and reputation primitives already have counterparties in them. That is a network problem, not a cryptography problem.
Which means the most valuable thing a chain can do right now is not shave another tenth of a cent off gas. It is to be the default registry that other registries talk to.
The Contrarian Case: Agents Do Not Need a Blockchain
Now the part that will annoy half the people reading this.
Everything I have described on the crypto side is optional. Every single function — identity, reputation, validation, payment, settlement — has a working centralized implementation that enterprises are already buying. A company that wants governed agents can sign one contract with one vendor and get identity, permissions, audit, and observability in a single procurement cycle. That is a genuinely superior product for the buyer, and no amount of protocol elegance beats a purchase order.
The on-chain version wins only where the counterparty is unknown. Its entire value proposition is trust-minimized interaction between parties who have no contractual relationship, no shared vendor, and no ability to litigate. That is a real and growing market. It is also a much narrower market than the crypto agent narrative implies.
And here is the sharper version of the contrarian claim. The current on-chain agent economy looks, in its incentive structure, remarkably like DeFi summer. Registrations inflated by airdrop expectations. Transaction counts inflated by subsidized fees. Total value locked metrics that measure the same capital cycling. The floor is a trap for the impatient — and the floor in agent registries is registration count, which is the cheapest metric in the world to manufacture.
I said in 2020 that short-term liquidity mining rewards were inflating total value locked by 300%, and I built a model specifically to separate organic growth from subsidy. The same model applies here. Separate agent activity that would exist at zero subsidy from agent activity that exists only because someone is paying for it. I would bet the organic fraction is currently under 20% of headline activity, and that the number will look embarrassing in eighteen months when the first cohort of subsidized registries goes dormant.
There is a second contrarian claim, about the enterprise side, and it is less comfortable.
Governance is being sold as a safety product. It functions as a control product. When a vendor owns the permission graph, it owns a complete map of every system the customer's machines can touch, every data source they read, and every action they take. That is an extraordinarily valuable dataset about the customer's operations, and the vendor is simultaneously the governance provider, the observability provider, and a potential model provider. There is a structural conflict of interest embedded in the architecture that no amount of contractual language fully resolves.
This is not a conspiracy theory. It is a straightforward reading of the incentive structure. And it is the same critique crypto people correctly level at centralized exchanges when they talk about proof-of-reserves that nobody audits. I audited three of those in 2022 and found solvency gaps large enough to justify a hedging program that cut client exposure to the subsequent collapses by about 60%. The lesson was not "exchanges are evil." The lesson was that an unaudited claim of safety is a liability, whichever logo is on the door.
The Standard Will Be Captured, and That Is Fine
One more uncomfortable observation, then I will get to positioning.
There are currently three philosophical camps competing to define how agents talk to each other and to systems: the platform-native camp, which wants governance inside a proprietary boundary; the open-protocol camp backed by a model lab, which wants a connection standard that it happens to steward; and the agent-to-agent camp backed by a hyperscaler, which wants cross-platform interoperability as a public good it happens to define.
All three describe themselves as open. All three have governance authority concentrated in a small group of founding stewards. This is normal. It is how every standard in computing history has begun, and every one of them has been captured to some degree by the largest implementers, because standards converge on the lowest common denominator and the largest implementers define the denominator.
So the practical question is not "which standard is philosophically correct." It is "which standard has the most counterparties already inside it in twelve months," because that is the one that will be extended rather than replaced.
And the deeper claim, which I will stake out here: the general-purpose agent specification problem may be unsolvable, and the winners will be the people who narrow the domain rather than the people who build universal standards. A specification layer for a bounded, well-understood workflow — invoice reconciliation, supply chain exception handling, on-chain liquidation monitoring — is tractable. A specification layer for arbitrary agent behavior is a formal verification problem that nobody has solved for arbitrary software, let alone for non-deterministic systems. The vendors selling universal governance are selling a boundary condition they have not found.
Positioning in a Chop Market
We are in a consolidation regime. Ranges compress, narratives rotate faster than capital moves, and the temptation is to force a directional bet on a story that is still being written.
Do not. Chop is for positioning, not for conviction trades.
The vector here is not "AI agents." That is a category, not a trade. The vector is the permission and verification layer — the part of the stack that survives model substitution, holds customer identity, and cannot be commoditized by a better checkpoint. On the enterprise side that is a small number of platforms with existing enterprise relationships. On the crypto side it is the registry, attestation, and verification primitives, plus the settlement rail that agents actually choose when the subsidy is removed.
What I am watching over the next two quarters, in order of signal quality:
Stablecoin transfer-size distribution breaking toward sub-dollar granularity while count rises. That is the cleanest machine-activity proxy available, and it is public data.
Registry activity half-life rather than registration counts. If the handles transacting at month six are the same handles that were transacting at month one, and everything else is dormant, the organic cohort is real and small. That is a buying opportunity. The opposite is a warning.
Any vendor disclosure of per-agent governance cost, and any vendor disclosure of net revenue retention on agent products. The first number nobody wants to publish. The second number everybody quotes without it.
Whether a genuine cross-boundary governance translation layer ships, and who owns it. That single artifact determines whether the agent economy is one market or several disconnected ones, and it is the highest-leverage unbuilt thing in the entire stack.
And the quiet one: whether the specification problem gets solved in the general case or gets abandoned in favor of bounded domains. I think it gets abandoned, and I think that is the correct engineering answer, and I think most of the current governance marketing will not survive contact with that conclusion.
The number I could not verify was 79%. The number that matters is whichever one you can trace to a ledger. Everything else is narrative.
Which raises the question I cannot yet answer: when the first cohort of subsidized agent registries goes dormant and the audit logs are finally published, will anyone still argue that coordination was ever the easy part?