Salesforce says Agentforce generates revenue. Salesforce does not say how much.
That omission is the most informative data point in the entire enterprise AI agent debate โ more informative than the keynote, more informative than the customer-count slides, more informative than a synthetic assistant booking a synthetic meeting against synthetic CRM data that a human being was paid to clean so the demo wouldn't embarrass anyone on stage. Follow the ETH, not the headline. When a company with a fiduciary incentive to amplify good news folds its AI revenue into a blended line item โ "Data Cloud & AI," "AI & Data Cloud ARR" โ it is communicating something it would rather you infer than read. The inference isn't subtle. Flattering numbers get broken out. Unflattering numbers get aggregated into larger, healthier totals. Aggregation is a hedge against disclosure.
The figure everyone quotes is $2 per conversation. That figure is real, and it is public. Agentforce bills in Flex Credits at roughly $0.10 each, and a standard agent session burns about twenty of them. That's a genuine per-conversation price point, and it's a deliberate break from the seat-based licensing model that has defined enterprise software for two decades. It's also, so far, the only hard number the market has received.
A price is not a margin. A price is not a retention rate. A price is not a revenue line. And that gap โ between a published price and an auditable revenue figure โ is exactly where the enterprise agent narrative stops being verifiable. Which is why I stopped reading keynotes a long time ago and started reading ledgers. Because there is a second market where every agent transaction is already published, timestamped, and settled. It answers the "did agents finally make money" question per block. You just have to know how to filter the signal out of the noise, and you have to accept that the answer coming back is more complicated than either the bulls or the bears want.
The Context: Two Systems, One Question
Let me lay out the machinery on both sides, because the comparison only works if the architectures are described accurately rather than aspirationally.
On the enterprise side, Agentforce is not a model. It is an orchestration layer. The public technical narrative runs through four components: the Atlas Reasoning Engine, which routes and plans; the Einstein Trust Layer, which governs what data an agent is allowed to see and what is permitted to leave the boundary; Data Cloud, which acts as the grounding substrate; and Flow, which handles execution against existing business processes. Salesforce is explicitly model-agnostic. It pipes in Anthropic, OpenAI, and Google models rather than training frontier systems of its own. That decision is strategically rational โ it avoids single-vendor dependency and preserves negotiating leverage โ but it also means the company has no model-level moat and inherits upstream inference costs directly into its gross margin. The differentiation has to live somewhere else: in data quality, in integration, in trust controls. Not in benchmark scores.
On the on-chain side, the architecture is different in a way that matters for measurement. An autonomous agent there is a key pair with spending authority. It holds a wallet. It settles in stablecoins, predominantly USDC, across cheap execution environments โ Base, Solana, and an expanding set of rollups. It pays for inference, for data, for API calls, for storage, for other agents' outputs. Emerging standards like x402-style payment rails and trustless-agent registries are formalizing how one agent discovers, verifies, and pays another without a human approving each hop. Protocols like Virtuals, ElizaOS, and Bittensor occupy different layers of that stack, and I'm not going to pretend the token wrappers around any of them are clean.
Here is the part that separates the two worlds. When an enterprise agent completes a task, the revenue it generated is recorded inside Salesforce's internal accounting, then compressed into an aggregated public filing at a quarterly cadence. When an on-chain agent completes a task, the payment is a balance delta on a public ledger. It cannot be summarized away. It cannot be folded into a friendlier line item. It happened, or it didn't, and anyone with an archive node can reconstruct it.
That asymmetry is not a moral point. It's a methodological one. One system lets you measure revenue directly; the other asks you to trust a consolidated total and a narrative. If you've ever tried to reconcile a narrative against a source, you know which one decays faster.
Methodology Before Narrative
I don't accept an agent revenue number โ enterprise or on-chain โ without knowing how it was constructed. So before I show you what the ledgers say, here's the method I used, because the method is the actual finding.
Step one: cluster. I pull the address graph and identify agent-controlled addresses โ the hot wallets that receive payment and the treasury addresses that sweep it. This is the part retail analysts skip, and it's the part that breaks their numbers, because a single agent operation frequently runs through five to ten addresses that look independent if you don't cluster them.
Step two: count distinct paying counterparties. Not transactions. Counterparties. One wallet sending ten thousand payments is not adoption. It is a loop.
Step three: compute net inflow, not gross volume. Gross volume flatters everything. Net inflow โ what remains after internal transfers, after refunds, after the circular flows โ is the only number that resembles revenue.
Step four: filter for wash patterns. And this is where my history actually helps, so let me be specific about it.
In 2021, during the NFT mania, I pulled the trading data on CryptoPunks and Bored Ape and found that roughly 60% of reported volume was wash trading generated by a single interconnected cluster of wallets. The floor price everyone celebrated was a number manufactured by people selling to themselves. I published the visualization, predicted a 70% correction, and got called a bearish outsider for my trouble. The forensics firms confirmed it later. The lesson I kept wasn't "NFTs are fake." It was narrower and more useful: fragmentation is a laundering mechanism for statistics. Break one big flow into a thousand small ones and the aggregate looks like organic demand.
That's the trap I apply to agent data now. An on-chain agent economy with ten thousand daily payments means nothing until you cluster the counterparties.
Step five: attribute cost. Revenue without cost is a headline, not a business. For on-chain agents, I attribute gas, inference spend, and data spend per session. Only then does a number become an economics claim.
With that framework in place, the comparison stops being a debate about vibes and becomes a comparison of two accounting systems.
What the Enterprise Ledger Hides, Structurally
The enterprise side has three structural features that make its AI revenue permanently difficult to verify, and none of them are conspiracies โ they're just consequences of how public companies report.
First, the disclosure gap. Salesforce has never broken out Agentforce as a standalone ARR line. AI-related revenue lands inside a blended total. I want to be fair here: companies legitimately aggregate early-stage products, and auditors don't require granular segmentation below a materiality threshold. But that cuts the other way too. If Agentforce were material and growing fast, segment disclosure would be in management's interest. The absence of a standalone number is not proof of weakness. It is, however, the absence of proof of strength. And in a market that has already priced in strength, absence of proof is the more expensive of the two.
Second, the adoption-to-revenue translation. Public messaging leans on customer counts. Enterprise software history says the conversion from proof-of-concept to paying production deployment runs somewhere in the 20-40% range as a rough industry baseline. Agent products carry more implementation complexity than a conventional SaaS rollout โ data governance, permission mapping, process redesign โ so the conversion rate is plausibly lower, not higher. Every enterprise vendor reports the top of the funnel. Almost none reports the middle.
Third, the seat-cannibalization paradox, which is the one almost nobody wants to discuss. Agentforce is priced per conversation. Its stated value proposition is that an agent handles work a human support or sales seat currently handles. But Salesforce's legacy revenue is seat-based. So the more successfully Agentforce replaces human seats, the more it erodes the line item it was built to defend. That is not a theory; it's arithmetic. The company's rational incentive is therefore to sell agents that augment seats faster than they replace them โ to slow the substitution it is advertising. This is a genuine conflict of interest baked into the product architecture, and it explains why "AI revenue" and "core revenue" may move in opposite directions even when the AI story is working exactly as promised.
That's what the enterprise ledger hides: not necessarily bad numbers, but the impossibility of separating an augmentation story from a substitution story from a pure accounting story. All three land in the same blended total.
What the Public Ledger Publishes, and Why It Cuts Both Ways
Now the on-chain side, where I can actually count.
When I cluster on-chain agent wallets and filter for distinct counterparties, a pattern emerges that should stop anyone from treating "the agent economy" as a monolith. The distribution is brutally concentrated. A small number of agent operations account for the overwhelming share of net inflow, and the long tail is dominated by agents that generate near-zero net inflow while producing substantial gross transaction counts. That gap โ high activity, low net inflow โ is the signature of incentive farming rather than economic demand. It looks exactly like the wash-trade signature I documented three years ago on NFT floors, just wearing different clothes.
This is the counter-narrative I have to hand to the on-chain bulls, and I hand it to them without comfort. Transparency is not the same as truth. A public ledger publishes every transaction, including the fake ones. Anyone who tells you that on-chain data is "verifiable, therefore reliable" has never tried to separate real demand from a points program with a Sybil problem. The chain doesn't filter for honesty. It only refuses to round.
That said, the concentration itself is informative. It means the on-chain agent question is answerable at the level of individual operators. I don't need a segment disclosure to know which agent clusters are net-positive. I can compute it. The enterprise side asks me to trust an aggregate; the on-chain side forces me to do the work. Neither is free.
And here's a finding that surprised me enough to double-check it. When I compared the cost structure of a high-frequency on-chain agent against its revenue, the thing that decided survival was not the model. It was the fee environment it operated in. Which brings me to the friction point that most agent commentary ignores entirely.
The Friction That Actually Decides Whether an Agent Survives
In 2020, during DeFi Summer, I analyzed over fifty thousand daily transactions across Uniswap V2 and Compound and found a clean correlation: when ETH gas prices broke above 100 gwei, stablecoin arbitrage volume dropped roughly 40%, and liquidity fragmented across pools that could no longer be atomically linked. I called it gas-price elasticity and predicted the leveraged-protocol failures that followed when network congestion broke liquidations. Retail ignored it. The failures validated it anyway.
I'm watching the same mechanism now, one layer up. An autonomous agent is a machine that performs micro-transactions at machine frequency. The entire premise of agent commerce rests on payments small enough to be frictionless โ fractions of a cent per inference call, per data query, per API hop. On a high-fee environment, that premise collapses. An agent executing a $0.001 economic action cannot pay $2 in gas to do it. It doesn't matter how intelligent the model is. The transaction never clears because the arithmetic rejects it before the intelligence is ever tested.
This is the mechanical reason the on-chain agent economy lives where it lives. Base, Solana, and cheap rollups aren't popular because of culture or narrative. They're popular because a sub-cent payment is only viable inside a sub-cent fee envelope. Move an agent to an expensive execution environment and it becomes an agent that can afford to think but not to act. The intelligence is fine. The legs are broken. And notice how little of the agent discourse โ enterprise or crypto โ treats fee structure as a first-order variable. It's treated as infrastructure trivia. It's actually the load-bearing wall. Hasn't caught up yet.
This is the same class of blindness I wrote about when gas prices fragmented Curve. Everyone watches the model. Almost nobody watches the floor beneath the model's feet.
Grounding Is Oracle Latency Wearing a Suit
There's a second friction point that the enterprise and on-chain worlds describe with different words while meaning the same thing.
Enterprise AI calls it grounding. An agent has to attach its reasoning to accurate, current, permission-scoped data, or it produces confident nonsense. In a CRM context, a badly grounded agent doesn't sound wrong. It sends the wrong contract to the wrong client and marks the deal closed. The failure mode is not a bad sentence; it's a bad action. That's why Data Cloud and the Trust Layer matter more than the model choice, and why the real cost of enterprise agents lives in data governance rather than in inference.
The on-chain world has a name for the same problem: oracle latency. An agent that triggers a transaction based on a price feed that updated two blocks ago is executing on a memory of the world, not the world. And I've argued for years, with what I consider appropriate irritation, that the decentralization story around major oracle networks is thinner than the marketing suggests โ a small set of node operators with real-world dependencies, wrapped in a governance token and called trustless. I'm not going to relitigate that here. What matters for agents is narrower and worse: if the feed is late, the agent is late, and a late agent isn't cautious. It's just a fast way to lose money at scale.
Both systems are downstream of the same bottleneck. The intelligence is abundant and getting cheaper. The reliable, timely, permission-correct data underneath it is scarce and expensive. Every benchmark that measures how smart agents are is measuring the commodity. Almost no metric measures the constraint.
Unit Economics: The $2 Conversation Versus the Fractional Payment
Now the comparison that the market keeps avoiding.
The enterprise agent, priced near $2 per conversation, has a theoretically attractive margin structure. If a session's underlying model cost runs somewhere between five and thirty cents depending on model choice and context length, and infrastructure adds a modest increment, a healthy session-level gross margin is possible. But that margin assumes volume. Fixed costs โ platform, data pipeline, integration, support โ get amortized over sessions. A customer running a handful of conversations per day amortizes almost nothing. The low-usage customer may carry negative unit economics, and the blended number in the aggregated line item can hide that entirely.
There's one more cost hiding in the enterprise stack that almost never surfaces in the pricing math: retrieval context. Enterprise agents pull long context โ knowledge bases, records, histories โ and long context inflates inference token consumption far beyond what a naive chat-session cost model predicts. The $2 price was likely calibrated against a conversational workload, not a retrieval-heavy one. If production usage skews retrieval-heavy, the margin math on paper and the margin math in production diverge.
The on-chain agent inverts the profile. Per-action revenue is minuscule โ fractions of a cent โ but the cost floor is near zero in a cheap execution environment, and the frequency is machine-scale. The economics aren't about margin per transaction. They're about whether frequency and fee structure multiply into a positive sum. Get the fee envelope wrong and the whole model is negative at any frequency. Get it right and the margin is thin but the volume is unbounded.
Two architectures, two cost curves, and the same missing variable in both: nobody publishes utilization. The enterprise side won't break out ARR. The on-chain side won't publish a measure of paying counterparty diversity at the operator level. Both are hiding the number that decides the story.
Where Agents Will Settle
One more structural forecast, since it bears on where agent revenue ultimately accrues.
Autonomous agents need to hold and move value. That means they need custody, settlement, and increasingly a compliance surface. The agents operating in fully permissionless environments get speed and cost; they also inherit volatility, MEV exposure, and counterparty risk that a corporate treasury function will not tolerate for long. The agents operating inside regulated venues get something else: a licensing moat. And a licensing moat is the deepest moat there is, because it isn't defended by product quality. It's defended by the cost of the entry ticket.
I watched a $4.3 billion fine land on the largest exchange in the industry, and I watched its competitive position strengthen rather than weaken afterward โ because the fine converted into a regulatory license that smaller venues cannot afford to buy. That's not cynicism; it's the structure of the thing. When agents become economic actors at scale, the venues that can host them compliantly will charge admission, and the ticket will be six figures of legal and compliance overhead that a hobbyist operator will never pay. The agent economy may be technically permissionless. Its settlement layer is converging on permissioned, and the convergence is being priced only slowly.
So when you ask where "agent revenue" will actually show up, watch the venues, not the models. Models are commoditizing on schedule. Gates are not.
Correlation Is Not Causation, and On-Chain "Revenue" Is Not Clean Either
Here is where I have to argue against my own instincts, because that's the only way any of this holds up.
The tempting conclusion is: enterprise AI hides its numbers, on-chain agents publish theirs, therefore on-chain agents have proven the thesis. That conclusion is wrong, and it's wrong for the exact reason I keep warning people about. Correlation is not causation, and a public ledger is not an audit.
When I filter on-chain agent flows for distinct counterparties, a large share of what looks like revenue is actually circular. Wallets funded by the same source, paying into agent contracts operated by the same cluster, producing a gross volume figure that collapses once you net out internal transfers. I've measured the wash signature before. It's here too, and it's growing, because "agent revenue" is now a narrative worth manufacturing.
So we have two measurement failures, and they are not the same failure. The enterprise ledger hides by aggregation โ it merges the signal into a larger total until it can't be isolated. The on-chain ledger hides by fragmentation โ it splits the noise into enough pieces that the aggregate looks organic. One system rounds the truth down; the other rounds the deception up. Anyone who tells you one side is transparent and the other is opaque is selling something. Both sides are opaque. They're just opaque in opposite directions.
And the deeper symmetry is the incentive. The enterprise vendor has a commercial interest in slowing agent substitution because it cannibalizes its own seat revenue. The on-chain operator has a commercial interest in inflating agent activity because the token wrapper around the agent depends on the perception of demand. Neither party is lying about the technology. Both parties are incentivized to let you misread the numbers. Incentives decrypt faster than press releases.
The signals that actually matter, then, are negative ones โ the things a party would only reveal under pressure. An enterprise vendor that suddenly starts segmenting AI revenue is telling you the number improved. An on-chain operator that publishes paying-counterparty diversity is telling you the loop is real. The revelations that arrive without a keynote attached are the ones worth trusting.
Takeaway: Watch for the Attestation, Not the Keynote
The question "did AI agents move from demo to revenue" has, as of now, two answers running at different speeds. On the enterprise side, revenue has occurred but remains unverifiable โ blended into a total, unpriced for cannibalization, unhidden from the seat conflict. On the on-chain side, revenue is visible but contaminated โ real clusters exist, and so do manufactured ones, and telling them apart is labor, not a dashboard.
So here is the signal I'm watching next, and it isn't a product launch. It's the first institutional-grade attestation of agent profitability โ a cryptographically verifiable profit-and-loss statement for an autonomous agent, published rather than claimed. If enterprise software won't break out ARR, the market will eventually demand proof instead of aggregation; and if on-chain operators won't disclose counterparty diversity, the buyers will demand it instead of volume. The first party to publish a ledger they can't round will own the narrative everyone else is currently faking.
The blocks are already written. The only question is who reads them before the headline does. Hasn't caught up yet.