The Number Nobody Is Pricing
Four hundred and twelve. That is how many distinct "AI agent frameworks" my scraper logged across public EVM and Solana repositories between October 2024 and the end of Q1 2025. Of that pile, fewer than thirty shipped a mainnet contract that had processed more than ten thousand autonomous transactions. Nine — I can name them, and I have the transaction hashes — ran an agent that completed a multi-step on-chain workflow end to end: research the pool, quote the route, sign, execute, settle, report, with no human finger on the confirm button in the middle.
The aggregate fully-diluted valuation of tokens branded around "agent frameworks" ran into the tens of billions during that same window. Price is one number. Usage is another. The distance between those two numbers is not a rounding error — it is the trade.
I have seen this exact divergence before, and not in crypto. Last quarter the sales-intelligence vendor ZoomInfo shipped an "Agent Teams" product and gave the entire orchestration layer away for free — no new SKU, no incremental charge. The market read it as generosity. It was a confession. When a company with a commoditizing data business starts bundling orchestration at zero, it is telling you the orchestration layer has no independent value left to sell. Crypto is walking into the same wall, but faster and with leverage.
Context: How We Got Here
The agent meta did not appear from nowhere. It compounded out of three separate manias that all resolved in the same direction.
First came the terminal. A language model posting to a social feed spawned a token, and that token did a hundred-x. The lesson retail extracted was that an AI agent could conjure a market cap. The lesson the market actually taught was that a language model plus a wallet equals a narrative, and narratives clear faster than code.
Second came the launchpads. Protocols emerged that let anyone spin up an "agent" — a persona, a prompt, a token — and attach a bonding curve. The launchpad became the product. The agent became the packaging.
Third came the frameworks. Open-source orchestration libraries — the ones that let a developer wire memory, tools, and a wallet into something that acts — proliferated under permissive licenses. One of them, a TypeScript framework that grew out of an "AI venture DAO," became the de facto standard almost overnight. It was forked into hundreds of derivatives. Every fork was a new token, a new Discord, a new thesis.
That is the landscape. A bull market, a reflexive loop between token price and developer attention, and a genuine technological shift — agents that can hold keys and move value — wrapped inside a valuation structure that assumes the hard part is already solved.
It is not. And the reason it is not has nothing to do with the agents. It has to do with where the value sits in the stack.
The Framework Is a Combination, Not a Breakthrough
Strip the branding and a crypto agent framework is a known recipe. Take a frontier model — usually a third-party API call to a Claude or a GPT. Add an orchestration loop: plan, call tool, observe, repeat. Bolt on a memory store, usually a vector database or a flat file. Attach a signing library and an RPC endpoint. Wrap the whole thing in a config file.
Every one of those components existed before the agent meta. The framework's contribution is composition, not invention. It is combination-level novelty wearing architecture-level marketing.
That distinction matters because combination-level code cannot hold a moat. The patterns are public. The papers are public. The prompts leak. The moment a framework demonstrates a working pattern — persistent memory, tool chaining, autonomous execution — that pattern is copied into a competitor within days. I watched a popular framework's signature "agent memory" module get reimplemented in a rival repo in under a week, with the commit history to prove it. The original author's response was to tokenize the framework and hope attention stayed sticky.
Attention does not stay sticky. Code stays sticky, and code is free. This is the core mechanic of the entire sector, and almost nobody prices it: the orchestration layer is open-source, which means its marginal cost of reproduction is zero, which means its equilibrium price is also zero.
A framework token is a bet that a free thing will stay scarce. That is not an investment thesis. That is a hope with a ticker.
I learned this the hard way in 2017, during the ICO boom. I was thirty, working as a software engineer, and I abandoned theoretical analysis to deploy real capital directly into an order-book DEX. I spent 15% of my salary to test whether I could interact with smart contracts faster than the centralized exchanges could list them. While I was doing that, I manually audited the proxy logic of three mid-tier token launches. In one of them I found a reentrancy path that let me exit forty-eight hours before the exploit landed. I doubled my position. But the lesson was not that I was clever. The lesson was that almost every token in that cycle was a combination of the same five ideas — a whitepaper, a proxy contract, a Telegram, a promise, and a countdown — and the market priced each one as if it were unique.
The agent framework wave is the 2017 ICO wave with better tooling. The ingredient list is public. The differentiation is narrative. And the only durable assets are the ones you cannot fork: the data underneath and the execution rails around it.
The Moat Is Data, Not Orchestration
Here is the part the framework maximalists skip. ZoomInfo's agent product was not defensible because of its orchestration — it was defensible, to the extent it was defensible at all, because of the Context Graph underneath it: a hundred million companies, half a billion contacts, billions of buying signals, built over a decade. The orchestration was a thin, replaceable skin. The data was the organ.
Crypto has an exact analogue, and it is not the framework. It is the context layer.
Ask a serious question: when an agent needs to act on-chain, what does it actually need? It needs to know what happened — historical state, labeled wallets, entity resolution, liquidity depth, token flow. It needs to know what is happening now — mempool conditions, gas, pending liquidations, oracle updates. And it needs to be able to do something — sign, route, settle, without leaking its keys.
The framework provides none of that. The framework provides the loop. The data provides the intelligence, and the execution rails provide the action. Both are scarce. The loop is not.
This is why the indexers, the archival nodes, the RPC and execution infrastructure, and the entity-graph providers are the real positions in this trade — and why the framework tokens are the exit liquidity. The indexers cannot be forked into existence. You cannot git clone a decade of indexed, decoded, entity-resolved chain history. You can, and people do, clone an orchestration loop in an afternoon.
I ran a version of this experiment in 2020, during DeFi Summer. I deployed fifty thousand dollars across Uniswap and SushiSwap pairs, chasing initial incentive emissions. I wrote a Python script to monitor gas and yield in real time and rebalance high-frequency. I made 400% in six months. But the durable edge was not the script — the script was trivial and everyone had one. The durable edge was the data: knowing which pools were about to emit, which liquidity was real versus mercenary, which pairs had a token that would survive the week. The strategy was free. The information was the business.
That is the same fault line running through the agent stack today. The framework is the free strategy. The data is the business.
Free Bundling Is a Confession, Not a Gift
Watch what happens to pricing when a layer commoditizes. It goes to zero, and the incumbents dress the zero up as generosity.
ZoomInfo did not charge for Agent Teams. No new SKU, no incremental line item. On the surface, value handed to customers. Underneath, a company whose net revenue retention had slid from a peak near 110% down toward the high 80s, whose market cap had shed more than 85% from its 2021 high, doing the only thing a commoditized data vendor can do: giving away the layer that has no pricing power left in order to protect the layer that still does.
Crypto is running the identical play, except the "free" is structural rather than strategic. The frameworks are open-source by default. The licenses are permissive. The orchestration is given away at the protocol level, and the monetization is pushed — usually — into a token whose value accrues to... the framework that just gave away its own differentiation.
When a layer is free, you do not own the layer. You own the thing the layer needs.
This is the single most important reframe in this article. In a bull market, the framework token pumps because the market confuses "the framework is being used" with "the framework is capturing value." It is not. The framework is a public good with a marketing budget. The value is captured by whoever controls the scarce input — the data, the execution, the liquidity, or the distribution.
And there is a second-order effect that nobody is modeling. When a product is free, its cost is not zero — it is simply hidden. ZoomInfo giving away agents means ZoomInfo eats the inference bill. Every agent run is tokens, and tokens cost money. The company even built an internal credit-estimation system, which is a polite way of saying "we are terrified of the cost and we are metering it quietly."
Now map that onto crypto. Who pays for the inference when a framework's agents run? Usually the token holder, through dilution and through the operational cost of running nodes and paying for API calls that the treasury subsidizes. The free framework is not free. You are paying for it in emissions and inference, and the bill arrives as a slow bleed in token price rather than a clean invoice.
Survival isn't about conviction; it's about position sizing. And sizing a framework token requires you to price a subsidy that does not appear on any dashboard.
Execution-Layer Security Is the Unpriced Tail
Here is where the crypto version gets genuinely dangerous, and where it diverges from the sales-tech version in a way that should terrify anyone holding agent exposure.
ZoomInfo's framing was precise: the operational risk in an enterprise agent is not what the agent says, it is what the agent does. That is correct, and it is the whole game. An agent that drafts an awkward email is a mild embarrassment. An agent that signs a transaction is a moving financial weapon.
Crypto agents sign transactions. That is the entire point. And the security model around that signing is, in the overwhelming majority of frameworks I have inspected, an afterthought.
Walk the attack surface. An agent reads untrusted input — a token name, a contract's return data, a social feed, a webpage it was told to scrape. That input is data, and data can carry instructions. Prompt injection is not a theoretical concern in a system where the agent's job is to read the outside world and then move money. A malicious token contract can encode a payload in its metadata. A compromised RPC can return a manipulated quote. A poisoned data feed can tell the agent that a worthless pool is deep.
Then there is the key problem. Most frameworks hold the agent's signing key in an environment variable or a local file. There is no hardware boundary, no policy engine, no spending limit enforced at the key layer. The agent's permissions are whatever the key can do, which is everything. There is no equivalent of a corporate card with a limit; there is a bearer instrument and a language model holding it.
And then there is memory. Persistent agent memory — the feature every framework advertises — is a long-lived store of context that may include wallet relationships, counterparties, and cross-session state. Nobody I have audited has a clean answer for tenant isolation or data deletion. The memory that makes the agent useful is the same memory that makes it a liability.
I have watched this movie before, in 2021, with the NFT minting bots. I wrote a Go bot to mint Bored Apes during the peak frenzy and burned twelve thousand dollars in gas to secure twelve tokens. I sold five to cover cost and rode the rest to an eighty-thousand-dollar profit. Then I leveraged my portfolio against the ETH/USD pair near the December top and got liquidated, giving back 60% of the gains in a single afternoon. The lesson was not about the mint. It was about the tail. The thing that killed me was not the thing I was watching. It was the thing I had not modeled.
In the agent stack, the thing nobody is modeling is the execution tail. When an agent with an unconstrained key meets an injected instruction, the loss is not a bad trade. It is a drain. And there is no circuit breaker, because the circuit breaker was supposed to be a human, and the entire value proposition is that the human is gone.
The market is pricing agent frameworks on the assumption that execution is solved. It is not solved. It is barely started. The first nine-figure agent exploit will not just crater one token — it will reprice the entire category, the way the Terra collapse repriced algorithmic stablecoins.
I know that repricing intimately. In 2022, during the Terra/Luna collapse, I read the peg mechanics, concluded they were unfixable, and shorted the ecosystem on perpetual DEXs at 5x on a twenty-thousand-dollar account. I watched on-chain whale wallets to time the entry and made ninety thousand dollars in seventy-two hours. But the part of that trade that still shapes how I write is not the profit — it is the counterparty lesson. Even a winning short can be erased if the venue holding your collateral becomes insolvent while you are right. Being correct is not the same as being paid.
Apply that to agents. You can be right that the orchestration layer is worthless and still lose money if the exchange, the bridge, or the execution venue you used to express the view fails around you. The tail is not the thesis. The tail is the tax on the thesis.
Where the Value Actually Redistributes
If orchestration is commoditizing, the question is not "which framework wins." The question is "which layer captures the rent when the loop is free."
There are three candidate layers, and only two of them hold.
Layer one: data and context. Historical state, decoded activity, entity graphs, labeled wallets, real-time signals. This layer is expensive to build, hard to replicate, and becomes more valuable as more agents consume it. It is the Context Graph of crypto. It does not care which framework is fashionable, because every framework needs it.
Layer two: execution and settlement. RPC, sequencing, key management, policy enforcement, MEV-aware routing, and the on-chain rails themselves. This layer captures rent because it is where the irreversible action happens. It is also where the security premium lives — the moment agents move real size, the market will pay for execution that does not leak keys and does not get sandwiched.
Layer three: the orchestration loop. This is the layer that goes to zero. Not because it is worthless, but because it is free. Open-source, forkable, and undifferentiated. A framework token is a claim on layer three, and layer three is the middle of the stack where value goes to die.
There is a structural reason the middle dies. When the layer below you is scarce and the layer above you is scarce, and you are neither, you are a pass-through. Pass-throughs get compressed. This is not a crypto phenomenon; it is what happened to the sales-tech middle when ZoomInfo bundled orchestration for free and pushed Clay, Outreach, and a dozen workflow vendors onto the defensive. The vendors that sold "orchestration" as the product suddenly had to prove they also owned data or distribution. Most did not.
Crypto framework tokens are those vendors, one cycle earlier and with worse fundamentals.
Now here is the second-order trade that most people are missing. Agent execution costs are paid in gas, and gas lives on rollups. The post-Dencun blob regime made rollup fees cheap — so cheap that agent micro-transactions look viable. But blob space is a finite resource and the demand curve is steep. My working estimate, based on the current blob consumption trend, is that blob data saturates within roughly two years. When it does, rollup fees for data availability double, then double again, and the economics of high-frequency agent execution — thousands of tiny transactions per agent — invert. The entire agent business model assumes cheap execution, and cheap execution has an expiration date that nobody has put on the calendar.
If you are underwriting an agent protocol on the assumption that gas stays near zero, you are underwriting a subsidy. Subsidies end. And the protocols with the thinnest margins — the pure-orchestration plays — get hurt first, because they cannot pass the cost to a data layer they do not own.
The Contrarian Angle: The Frameworks Are Not the Product
Everyone is long the framework. The trade is the framework. The memes are the framework. The Discord is the framework. And that is precisely why the framework is where retail money goes to die.
Here is the counter-intuitive claim, and I will state it plainly because the evidence is on-chain: the frameworks are not the product. They are the distribution. They exist to funnel attention into tokens, and the tokens exist to funnel attention into exits. The framework is the funnel, not the factory.
The smart-money read is the inverse of the retail read. Retail sees a framework with a hundred thousand GitHub stars and buys the token, because stars feel like adoption. Smart money sees a framework with a hundred thousand stars and asks who captures the rent when every one of those stars forks the code and competes on price. The answer is never the framework. It is the data provider the fork still has to pay, and the execution layer the fork still has to route through.
There is a second contrarian point, and it is uncomfortable. The biggest threat to crypto agent frameworks is not another crypto agent framework. It is the platform. In sales tech, the frameworks feared each other until the CRM platforms — Salesforce, HubSpot — shipped native agent capabilities and made the standalone orchestration vendors look like features. The same consolidation is coming to crypto. The exchanges, the wallets, the L1s, and the custodians are all shipping agent toolkits, and they have what no standalone framework has: the keys, the users, and the rails. When the platform bundles the loop for free — and it will — the standalone framework token has nothing left to sell.
The framework maximalist will tell you this is different because crypto is open. It is open, which is exactly the problem. Openness is the mechanism by which the middle gets compressed. A permissionless layer with no proprietary input is a public good, and public goods do not accrue value to their token holders — they accrue value to whoever sells the complements.
Hedge the ego, not just the portfolio. If you are holding a framework token because you believe in the technology, separate the belief from the position. The technology can be real and the token can still be worthless. Those are two different bets, and the market is only paying for one of them.
The Takeaway: Watch the Pricing Power, Not the Product
Do not watch the frameworks. Watch the layers that can charge.
The signal to monitor is pricing power. When a data layer raises prices and the frameworks still route through it, the data layer wins. When an execution layer charges a spread and the frameworks still settle through it, the execution layer wins. When a framework tries to charge for its orchestration and the forks undercut it to zero within a quarter, the framework loses — and it loses permanently, because the code is free.
The next confirmation will be a "free" announcement. Watch for a framework token to do a ZoomInfo: give the orchestration away entirely and pivot its monetization to data or execution. The market will cheer it as generosity. Read it as the confession it is. The first time a major agent framework announces that its core capability is now free, the reprice has begun, and the tokens that never owned a scarce input will not recover their highs.
The chart is a map; the trader is the terrain. The map right now shows a category priced for scarcity and shipping abundance. Liquidity is the only truth that pays the bills, and the liquidity in the agent stack is quietly migrating from the loop to the rails.
Position accordingly — and remember that arbitrage is just patience wearing a speed suit. The mispricing is visible. The patience is the edge. Bots don't panic; they execute. The question is whether you will.