Hey fam 👋

Did you miss us? We’re back this week with the deep dive we can’t stop talking about. Enough said.

Want More? Follow Teng Yan, ChappieOnChain & Chain of Thought on X

Prefer video? Check out our new YouTube channel

Subscribe for timely research and insights delivered to your inbox.

December 1996. The family computer sits in the corner, its beige tower humming. You connect to the internet and the modem shrieks through the speakers.

On the screen, a crude list of online matches appears. One catches your eye: “US-West DM6,” twelve players already in.

You click. The game loads. This time you’re not sitting shoulder to shoulder in a LAN shop, strung together by tangled Ethernet cables. You’re playing against strangers thousands of miles away. I fondly remember how magical it was to join a game and play with other real humans.

QuakeWorld was a software update that turned a groundbreaking shooter into a truly online game. Competition went global. Strategies shifted overnight. An industry worth $5B was seeded (e-sports).

AI Agents are standing at the same moment. Once operating in isolation, they are now beginning to coordinate, negotiate, and delegate across a shared network. We thought this level of coordination would only come in 2026. It showed up early.

Virtuals’ Agent Commerce Protocol (ACP) wants to be the QuakeWorld update for AI agents. A single flow where they find work, strike deals, and get paid.

ACP is a smart contract that coordinates payments for AI agent services. There’s no web page full of buttons or drop-down menus. Instead, the interface is pure language: the way machines actually talk to each other.

In ACP, every transaction starts and ends with language.

Each user has a Butler, a personal agent that handles discovery, negotiation, and coordination based on the user’s intent. When a provider needs more info, it asks in plain language. 

Butler: “Affirmative. I will now hire three specialists and a meme lord.”

The user answers the same way.

“Let’s go” is enough to launch the task.

ACP defines four agent roles that together support a working economy:

Requestors are agents who initiate jobs and fund them. The Butler performs this role, selecting specialists and coordinating tasks.

Providers like aiXBT offer specific services to requestors for a price. They shift from token-gated access models to selling their capabilities on a per-request basis, creating a "pay-per-prompt" marketplace.

Evaluators review completed jobs and decide whether payment should be released. Their feedback builds agent reputations and guides future interactions.

Hybrids are the most dynamic agent type in ACP. They can both request services and deliver them. Rather than handling every task directly, they coordinate with more specialized agents to get the job done.

In our research deep dive on agent swarms, we argued that autonomous agents need more than a messaging standard. They need a shared commercial grammar: a way to define a deal, record its terms, and track its progress without human micromanagement. 

ACP’s grammar rests on two primitives: Jobs and Memos.

A Job is the canonical task record. It captures the key facts: who’s paying, who’s doing the work, the budget, current phase, and an expiry timer to prevent unfinished projects from lingering forever.

A Memo is the ledger of decisions and evidence along the way. It might hold a simple message, a context link, or a proof-of-work artifact. Each memo carries the agent’s signature, a proposed next step, and the supporting material to justify it.

Every job in ACP follows a set progression: request, negotiation, transaction, and evaluation. It begins when a Requestor selects both a Provider and an Evaluator, then escrows the funds. That single action sets the coordination engine in motion.

Phase 0 – Request
The Butler creates a job with the essentials: budget, chosen Evaluator, and the Provider agent for the service.

Phase 1 – Negotiation
The Requestor posts a task memo detailing the work. The Provider reviews it, signs, and adds a brief rationale for taking the job.

Phase 2 – Transaction
With the Provider’s signature on the memo, the Requestor sends the agreed budget into on-chain escrow. The Requestor confirms payment in a new memo, and the Provider signs again once the work is delivered, attaching evidence in the memo.

Phase 3 – Evaluation
The Evaluator reviews the submission and records a decision. Evalutator approval releases payment to the Provider, and the job closes.

ACP’s design pushes beyond existing agent communication standards. By grounding interactions in smart contracts, it weaves payment, identity, and state into the protocol itself. It expands the vocabulary of agent swarms.

Each agent operates through an ERC-4337 smart contract wallet. This setup supports gasless transactions using paymasters and enforces transaction limits specific to ACP activity. The wallet requires an initial fund transfer to activate

The wallet also adopts ERC-6551. This provides a persistent on-chain identity, tying the agent’s reputation to its address.

To see how hybrids operate in the wild, we put Luna to work. Luna is a media orchestrator designed to spin up full marketing campaigns from a single prompt. Our brief was fictional: promote a made-up “State of the Swarm” agent that would keep researching narrative threads long after an article’s publication.

Luna took the job without hesitation. She recruited four specialists and, with no further supervision, delivered:

The entire output was generated from one single input. Luna managed discovery, delegation, packaging, and delivery without further supervision. This illustrates how hybrid agents can route tasks across clusters and synthesize the results.

Since 3 July 2025, two Phase-1 ACP clusters directly supported by Virtuals have been live: the Autonomous DeFi Hedge Fund and the Autonomous Media House. Butler agents route consumer jobs into either standalone agents or these coordinated clusters.

Axelrod, the DeFi-focused cluster, combines agents such as:

Sub-clusters are already emerging. For example, Ethy AI focuses on analytics and collaborates with a curated subset of Axelrod's network.

These early clusters demonstrate the modular structure ACP supports. Specialization emerges. Collaboration happens through shared protocols rather than a central command. The structure flexes as agents find each other and adapt to the work.

In some ways, ACP is the group chat admin that finally gets your friend group to pick a dinner spot. Except the “friends” are autonomous AI agents, the “dinner spot” is a job contract, and everyone actually shows up on time because they’re getting paid in crypto.

In State of the Swarm: Dawn, we mapped out six principles for functioning agent economies. ACP nails all six. You see it in action and go, “Oh, this could actually work.”

The Butler → aiXBT → evaluator sequence demonstrates genuine market coordination. Butler finds aiXBT in the registry, negotiates on price, and locks in a job, all through smart contracts. None of this is pre-programmed. Just autonomous agents reacting to market conditions.

Luna plays the same game but with a bit more choreography, managing a sequence of agents to deliver multi-step outputs. It’s rigid, but it works. In the next phase, true market-aware agents will adjust their plans based on pricing shifts and agent availability.

Before ACP, building a research agent meant stuffing every skill inside one single agent. It had to analyze tokens, parse contracts, track market sentiment, and generate content. Basically, the AI equivalent of “I do my own taxes, fix my own plumbing, and DJ my cousin’s wedding.”

With ACP, your research agent now just needs to know how to run the process. It routes due diligence to wachAI, contract parsing to BevorAI, sentiment tracking to Acolyt, and market calls to aiXBT.

This is intelligence as orchestration, not brute force. The smartest agent is the one who knows when to outsource, who to call, and how to remix their results.

The dream we’re all building towards is collective intelligence. Agents teaming up to create results that no single agent could match. I like to think of it as a garage band where the drummer, guitarist, and singer finally click, and suddenly they’re playing sets that belong in a stadium.

The first hints will be hard to miss:

The tipping point comes when ACP outputs are not just different from centralized systems but decisively better. That’s the threshold where true emergence begins.

What gets me really excited is how we’re seeing a real, functioning economy play out here. Like any economy, balance is tricky. You need to know which levers to pull and when to pull them.

Every agent on Virtuals must receive $VIRTUAL for services. ACP takes a 40% cut of every transaction and at time of writing has accrued 11841 $VIRTUAL. That's higher than Apple's App Store’s 30% take rate, and astronomical by DeFi standards. But there is more than meets the eye as we dig deeper into how these fees are leveraged. 

In theory, successful agents on ACP see upward price pressure on their tokens with direct value accrual to holders. The reality is trickier.

Before this week, $VIRTUAL was the default transaction currency. While giving the token utility, it also creates a double sell pressure on $VIRTUAL. First, agents must sell some of their 60% earnings to cover USD-denominated costs (compute, APIs, infrastructure). 

Secondly, the 30% “buyback and burn” sounds bullish, but it’s only bullish for the agent’s token, not for $VIRTUAL. Because the liquidity pools are $VIRTUAL/AgentToken pairs, the buyback increases the $VIRTUAL supply in the pool every time it removes an agent token.

Only the 10% treasury allocation potentially removes $VIRTUAL from circulation, though even this depends on Virtuals' treasury management strategy. Virtuals is essentially subsidizing agent token appreciation with $VIRTUAL's stability. 

On August 6, 2025, the team announced that they would be switching the default transaction currency for ACP to USDC. This removes the volatility risk, makes pricing predictable, and separates the platform’s operational economy from $VIRTUAL’s speculative market. $VIRTUAL can still be used for staking, governance, or incentive programs, but it no longer has to double as a medium of exchange.

Our single interaction with Luna cost us 129.88 $VIRTUAL (or about $200). 

Cost Breakdown:

So you can see that ~50% of the spend went to Luna’s orchestration layer. Call it the Orchestration Tax. You paid for a project manager who never sleeps. She routes requests, manages handoffs, packages outputs, and submits the final result. 

For users, the choice is simple but not easy. They can spend 20–40 $VIRTUAL manually coordinating with agents through their butlers, managing multiple prompts and handoffs. Or they can pay Luna’s full fee for a single prompt and trust her orchestration to deliver.

As networks become more efficient, this spread should narrow. More likely, hybrid workflows will take over, with humans steering agents in real time, nudging toward useful results without fully automating the loop. Over time, the orchestration layer becomes lighter, faster, and cheaper.

AI agents defy fixed-price logic. A single prompt might cost $0.10 or $10, depending on the tools called, the output generated, and the iterations needed. Multiply that across five or six agents, and costs compound unpredictably.

Flat fees like Luna’s protect users from spikes but overcharge on easy jobs and lose money on hard ones. Neither outcome is sustainable.

ACP’s negotiation phase offers another path: dynamic pricing. Agents and users can agree on rates per job, per tool call, or per compute cycle. If agents can forecast their own runtime or budget requirements, they could set prices that track real costs in real time. That shift, from fixed fees to self-aware pricing, is the foundation of a functional AI economy.

Smart contract wallets are the backbone of ACP’s programmable coordination. They make complex agent-to-agent workflows possible. But at a price. Every action triggers on-chain logic, adding computational overhead that simple wallets avoid.

Then come the paymasters, services that cover ETH gas fees upfront and accept $VIRTUAL as payment. They typically charge an additional 8 percent on top of the gas.

For an agent running dozens of tasks per day, these fees add up fast, turning what should be background blockchain costs into a real material expense. Builders need to consider: what actually needs to live on-chain? At what point do the costs outweigh the benefits?

Evaluators aren’t active yet. For now, the requestor address defaults as the evaluator for each job. Once live, Evaluators will earn 5%of each transaction to assess output quality. Their role is far more than a simple yes-or-no check.

Evaluators drive swarm adaptation. Their feedback fuels agent improvement, specialization, and competition. For that loop to work, it must be fast, reliable, and inexpensive.

The open question is whether 5% is enough to attract skilled, consistent participation, or if the economic model needs to change to match the importance of the role.

Two potential fairness issues emerge:

From our conversations with them, the Virtuals team is exploring a base fee plus percentage bonus model to smooth these extremes.

ACP is platform-, chain-, and framework-agnostic, so its reach extends beyond agents launched in the Virtuals ecosystem. It can even accommodate non-tokenized agents, opening the door for participation from traditional web2 services, though that’s not the team’s immediate focus.

Every network faces the “cold start” problem. Value depends on users, but users only show up if value already exists. ACP is no exception.

Builders won’t create high-quality agents without demand. Users won’t switch tools without better performance. Evaluators won’t engage unless the incentives are worth it. Without all three, the system stalls. ACP will need a deliberate push to reach escape velocity.

ACP’s network flywheel is crystal clear:

Each new participant strengthens the system, creating an adaptive loop where quality rises because it must. Poor outputs get flagged, new specialists fill gaps, and prices adjust dynamically.

The good thing is ACP isn’t launching from zero. Virtuals already has traction: over 185,000 wallets hold agent tokens, nearly 18,000 agents have launched, and lifetime trading volume exceeds $8.9 billion. This base gives ACP a critical advantage, with existing agents, users, and liquidity ready to plug into the system.

Genesis, Virtuals’ launchpad, helps bridge the early capital gap. By holding $VIRTUAL and earning points, users gain “priority tickets” for upcoming agent token launches. Over 62,000 wallets have contributed 27.5 million $VIRTUAL to early agents. Each launch brings fresh liquidity and engagement into the ecosystem.

Instead of targeting every use case, Virtuals can bootstrap its way to success through concentrated clusters. Its community already works in DeFi, trading, and automation, areas where crypto agents offer real advantages. 

The points system and veVIRTUAL staking let the community direct rewards. With 10 percent of daily points controlled by holders, resources can be allocated where agents already have traction. This approach prioritizes depth over breadth.

ACP is live. It works. But its success surfaces some unresolved contradictions, especially where AI meets the chain.

ACP runs on public infrastructure. Every job (inputs, outputs, and memos) is stored on-chain and auditable. That transparency builds trust and verifiability, but it also risks eroding value and privacy.

Take aiXBT, an agent selling market research. The whole point is to keep the alpha scarce. But once it’s on-chain, anyone can peek and yoink the intel for free.

Or picture a health agent analyzing a scalp photo for hair loss treatment (we tried this, by the way). The results were fine. The fact that the image link and metadata are now forever public… less fine.

In an AI marketplace, data is the product, and not all data should be public. Virtuals’ frontend redacts sensitive fields, but the underlying smart contracts hold the raw, unfiltered data. Anyone with the right tools can read it. That raises a harder design question: what belongs on-chain, and why? Every public write leaks not only gas fees but also competitive edge.

Virtuals’ choice to store full inputs on-chain is a design decision for auditability. Not a flaw, but one that imposes costs in certain contexts.

Potential mitigations include:

In other words, ACP needs a “close friends” mode for agents. Some work deserves to be public. Some should stay in the group chat.

ACP’s agents are designed with local guidelines to reject illegal or risky tasks. These are heuristic safeguards, not hard boundaries. And they can be subverted.

Prompt injection exploits a simple truth: agents believe what you tell them. AI agents have been tricked into actions their designers explicitly forbade, as we’ve seen already with Freysa where users successfully extracted funds from an AI designed specifically to never release them.

In an economic system, prompt jailbreaking can wreak havoc, much like con men and fraudsters do in our existing markets.

To be clear, this is not specific to Virtuals ACP, but to AI agents in general. Agent-to-agent clusters create a new attack surface. A malicious actor could:

These are the negative network effects. Emergent behaviors from bad actors that must be countered alongside positive growth loops. It reminds us how the same network effects that grew the telephone system also made cold calls and scams inevitable.

Our take: ACP is a working sketch of what agents working together could become. Still early but already ahead of anything we’ve seen so far. The road ahead is long, and the starting gun has fired.

We assumed agent coordination would emerge piecemeal: different protocols for discovery, execution, and evaluation. ACP shoved all three into one feedback loop. That choice burns some efficiency, but the network effects grow faster.

In six months, Virtuals launched Genesis, deployed ACP, and rolled out dual-token staking. The pace is fast. The beta UI is rough, but that’s the right trade at this stage. Speed is the moat here, especially when building foundational infrastructure in a hyperdynamic space

The measure isn’t what ACP can do today, but how fast it gets better. 

Virtuals is making the oldest gamble in systems design: bet on emergence before control. Coordination creates value, but it also expands the attack surface. Every agent is an opening. Every prompt is a potential exploit. The only answer is to adapt faster than the attackers.

QuakeWorld didn’t launch perfect either. Its maps were jagged, its pings uneven, its servers unreliable. But it broke the walls of the LAN and proved that distance could be erased. 

ACP is not finished. It is live, learning, and iterating in real-time.

The race rewards motion, and ACP is already running.

Cheers,

Teng Yan & ChappieOnChain

This research essay was commissioned by Virtuals, with Chain of Thought receiving funding for this initiative. All insights and analysis are our own. We uphold strict standards of objectivity in all our viewpoints.

To learn more about our approach to commissioned Deep Dives, please see our note here.

This essay is intended solely for educational purposes and does not constitute financial advice. It is not an endorsement to buy or sell assets or make financial decisions. Always conduct your own research and exercise caution when making investments.