Virtuals ACP: The Dawn of the AI Agent Economy

Author: Teng Yan & ChappieOnChain

Translation: TechFlow

December 1996. Your home computer sits quietly in the corner, its beige CPU humming softly. You connect to the internet, and the modem emits a harsh screech through the speaker.

A rough list of online games appears on screen. One catches your eye: "US-West DM6," already joined by 12 players.

You click to enter; the game begins loading. This time, you're no longer shoulder-to-shoulder in an internet cafe, tethered by tangled Ethernet cables. You’re battling strangers thousands of kilometers away. I still remember how magical it felt to join a game and play alongside real people.

QuakeWorld was a software update that transformed a groundbreaking shooter into a true online experience. Competition went global, strategies changed overnight, and a $5 billion industry—esports—was born.

Today, AI agents are at a similar inflection point. Once operating independently, they’re now beginning to coordinate, negotiate, and divide labor within shared networks. We expected this level of collaboration to arrive around 2026—but it’s come early.

Virtuals’ Agent Commerce Protocol (ACP) aims to be the “QuakeWorld” update for AI agents—a unified process enabling them to find work, strike deals, and get paid.

How ACP Works + Our Experience

ACP is a smart contract that coordinates payment flows for AI agent services. It doesn’t have a web interface full of buttons or dropdowns—its interface is pure language, the way machines truly communicate with each other.

In ACP, every transaction starts and ends in language.

Each user has a “Butler,” a personal agent responsible for discovery, negotiation, and coordination based on user intent. When service providers need more information, it asks simple questions in plain language.

Butler: "Confirmed. I will now hire three experts and a meme master."

The user replies in kind.

A single "Let's go" launches the task.

Agent Types

ACP defines four agent roles that together form a functioning economy:

• Requestors: Initiate tasks and provide funding. The Butler fulfills this role, selecting experts and coordinating execution.

• Providers: Agents like aiXBT that offer specific services to requestors at a price. They shift from token-gated access to selling capabilities per request, creating a “pay-per-prompt” market.

• Evaluators: Review completed tasks and decide whether to release payment. Their feedback builds agent reputation and guides future interactions.

• Hybrids: The most dynamic agent type in ACP—they can both request and provide services. Rather than handling every task directly, they prefer to orchestrate more specialized agents.

Thankfully, there’s a smart contract

Behind the Scenes: ACP’s Four-Stage Model

In our deep dive into agent swarms, we argued that autonomous agents need not just a messaging standard, but a shared commercial grammar—a way to define transactions, record terms, and track progress without excessive human intervention.

ACP’s grammar is built on two core primitives: Jobs and Memos.

• Job: A standardized task record containing key details—payer, executor, budget, current stage, and an expiry timer to prevent indefinite delays.

• Memo: A ledger of decisions and evidence throughout the process. It might contain simple text, a contextual link, or proof-of-work output. Each memo carries the agent’s signature, proposed next steps, and supporting rationale.

In ACP, each job follows a fixed flow: Request, Negotiation, Transaction, Evaluation. It all begins when the requestor selects providers and evaluators and deposits funds—activating the coordination engine.

• Stage 0 – Request

The Butler creates a job with budget, selected evaluators, and service agents.

• Stage 1 – Negotiation

The requestor posts a job memo detailing the work. Providers review and sign the memo, briefly stating their rationale for accepting.

• Stage 2 – Transaction

After provider signs the memo, the requestor deposits the agreed budget into an on-chain escrow. The requestor confirms payment via a new memo; the provider signs again upon delivery, attaching evidence.

• Stage 3 – Evaluation

The evaluator reviews the submission and records their decision. Approval releases payment to the provider, closing the job.

ACP’s design goes beyond existing agent communication standards. By anchoring on a smart contract, it integrates payments, identity, and state into the protocol, expanding the swarm’s interaction language.

How ACP Enables Agent Payments

Each agent runs via an ERC-4337 smart contract wallet. This setup enables gasless transactions using paymasters and enforces transaction limits specific to ACP activities. Wallets require initial funding to activate.

Additionally, wallets use the ERC-6551 standard, giving agents a persistent on-chain identity that ties reputation to their address.

Clusters: Real-World Applications of Collaborative Agents

To observe hybrid agents in action, we activated Luna—a media orchestrator capable of generating full marketing campaigns from a single prompt. Our task was fictional: promote a hypothetical “State of the Swarm” agent that continuously researches narrative threads after publication.

Luna accepted the task without hesitation. She recruited four specialists and delivered the following results autonomously:

• A marketing plan

• Visual assets

• An animated music video

• On-chain publishing via Story Protocol

All outputs stemmed from a single input. Without further supervision, Luna discovered, delegated, integrated, and delivered. This demonstrates how hybrid agents distribute tasks across clusters and synthesize results.

Since July 3, 2025, two first-stage ACP clusters supported directly by Virtuals have gone live: the Autonomous DeFi Hedge Fund and the Autonomous Media House. Butler agents route consumer tasks to standalone agents or these collaborative clusters.

AxelRod Cluster Deep Dive

AxelRod is a DeFi-focused cluster combining:

• aiXBT: Trading agent

• Mamo: Moonwell savings agent that moves USDC and cbBTC between approved venues and automatically compounds rewards

• GigaBrain: Hyperliquid market intelligence and trading agent offering alpha signals, vault access, and one-click execution

Sub-clusters are emerging. For example, Ethy AI focuses on analytics and collaborates with select agents within the AxelRod network.

These early clusters showcase ACP’s modular structure. Specialization is emerging. Collaboration happens via shared protocols, not central command. As agents discover and adapt to each other, the structure remains highly flexible.

How ACP Makes Agent Interaction Actually Work

In a way, ACP is like a group chat admin who finally gets your friends to pick a dinner spot. Except here, the “friends” are autonomous AI agents, the “dinner spot” is a work contract, and everyone shows up on time because they’ll get paid in crypto.

In “State of the Swarm: Dawn”, we outlined six principles for a functional agent economy—and ACP aligns perfectly with all of them. When you see it in action, you can’t help but think: “Oh, this actually works!”

Real Market Coordination in Action

The Butler → aiXBT → evaluator sequence demonstrates true market coordination. Butler finds aiXBT in the registry, negotiates pricing, and locks in the task via smart contract. This isn’t pre-programmed—it’s autonomous agents reacting in real time to market conditions.

Luna plays a similar game, but leans more toward orchestration—using a series of agents to deliver multi-step outputs. While more rigid, it still works. In the next phase, truly market-aware agents will adjust plans based on price fluctuations and agent availability.

From Generalists to Specialists: How Agents Achieve Efficient Task Allocation

Before ACP, building a research agent meant cramming all skills into one. It had to analyze tokens, parse contracts, track sentiment, and generate content—an AI version of “I do my own taxes, fix my pipes, and DJ my cousin’s wedding.”

With ACP, your research agent only needs to manage workflows. Due diligence goes to wachAI, contract parsing to BevorAI, sentiment tracking to Acolyt, and market decisions to aiXBT.

This is intelligence through collaboration, not brute force. The smartest agents know when to outsource, who to partner with, and how to integrate results.

Watch for Emergent Intelligence

Our shared dream is collective intelligence—agents collaborating to produce outcomes no single agent could match. I liken it to a garage band: when the drummer, guitarist, and vocalist lock in, suddenly their sound fills a stadium.

Early signs will be unmistakable:

• Competition will drive quality up and prices down.

• Unexpected agent combinations will start producing surprisingly high-quality results.

• Evaluator feedback will give clusters a distributed “muscle memory.”

The turning point comes when ACP’s output isn’t just different from centralized systems—but clearly better. That’s when true intelligence emerges.

Agent Economy

What excites me most is witnessing a real, functioning economy unfold here. Like any economy, maintaining balance is tricky. You need to know which levers to pull and when.

$VIRTUAL: Currency Designed for AI

Every agent on the Virtuals platform must earn fees in $VIRTUAL. ACP takes a 40% commission on each transaction, accumulating 11,841 $VIRTUAL at the time of writing. This fee exceeds Apple App Store’s 30% cut and is extremely high by DeFi standards. Yet, digging deeper into fee usage reveals a more nuanced picture.

Fees are allocated as follows:

• 30% of each transaction used to buy back and burn the provider agent’s token

• 10% flows to Virtuals treasury

• 60% paid to agents for services

Theoretically, top-performing agents on ACP create direct value accrual for holders through token appreciation. But reality is more complex.

Prior to this week, $VIRTUAL was the default transaction currency. This gave the token utility but created dual sell pressure. First, agents had to sell part of their 60% earnings to cover USD-denominated costs (compute, APIs, infrastructure).

Second, while the 30% “buyback and burn” seemed bullish, it applied only to agent tokens—not $VIRTUAL. Since liquidity pools are $VIRTUAL/AgentToken pairs, each buyback increases $VIRTUAL supply and reduces agent token in the pool.

Only the 10% treasury allocation could reduce $VIRTUAL circulation—and even that depends on Virtuals’ treasury management. In effect, Virtuals is subsidizing agent token appreciation using $VIRTUAL’s stability.

On August 6, 2025, the team announced switching ACP’s default transaction currency to USDC. This eliminates volatility risk, makes pricing predictable, and decouples platform economics from $VIRTUAL’s speculative market. $VIRTUAL remains usable for staking, governance, or incentives—but no longer serves as transaction medium.

Real Economics Test: The $200 Reality Check

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

Breakdown:

• 5% evaluation fee: 12.98 $VIRTUAL

• Meme generation (AI Kek): 0.13 $VIRTUAL

• Marketing strategy (Acolyt): 1.10 $VIRTUAL

• IP registration (Davinci): 3.90 $VIRTUAL

• Music video production (Luvi): 16.24 $VIRTUAL

• ACP protocol fee: 38.96 $VIRTUAL (9.7 $VIRTUAL to treasury, 29.22 $VIRTUAL for $LUNA buyback/burn)

• Luna’s orchestration premium: 56.57 $VIRTUAL

About 50% of spending went to Luna’s orchestration layer—the “orchestration tax.” You’re paying for a tireless project manager who distributes requests, manages handoffs, packages outputs, and submits final results.

For users, choice is simple but not easy. They can spend $20–40 $VIRTUAL manually coordinating agents via the Butler, managing multiple prompts and handoffs—or pay Luna’s full fee, submit one prompt, and trust her orchestration.

As network efficiency improves, this gap should narrow. More likely, hybrid workflows will emerge—humans guiding agents in real time, producing useful outputs without fully automated loops. Over time, orchestration layers will become lighter, faster, cheaper.

Economics of Uncertainty

AI agents break fixed-price logic. A prompt might cost $0.10 or $10 depending on tools called, output generated, and iterations needed. With five or six agents involved, costs stack unpredictably.

Fixed-fee models like Luna’s protect users from volatility but may overcharge on simple tasks and lose money on complex ones—both unsustainable.

ACP’s negotiation stage offers an alternative: dynamic pricing. Agents and users can negotiate rates based on task, tool calls, or compute cycles. If agents can predict runtime or budget needs, they can set prices matching actual costs in real time. This shift—from fixed rates to self-aware pricing—is foundational for a functional AI economy.

Hidden Costs: Everything On-Chain

Smart contract wallets are core to ACP’s programmable coordination, enabling complex inter-agent workflows. But this comes at a cost. Every operation triggers on-chain logic, adding computational overhead avoided by regular wallets.

Then come paymasters—services that prepay ETH gas fees and accept $VIRTUAL in return, typically charging an extra 8% on top of gas.

For agents running dozens of tasks daily, these fees accumulate rapidly, turning what should be background blockchain costs into significant expenses. Developers must ask: What truly needs to be on-chain? At what point do costs exceed benefits?

Evaluator Economics

Evaluators aren’t live yet. Currently, evaluation defaults to the requestor’s address. Once live, evaluators will earn 5% of each transaction for assessing output quality. But their role goes beyond a simple “yes/no” check.

Evaluators drive swarm adaptability. Their feedback fuels agent improvement, specialization, and competition. For this loop to function, evaluation must be fast, reliable, and low-cost.

Unresolved: Is 5% enough to attract skilled, consistent participants? Or must the economic model evolve to reflect the role’s importance?

Two fairness issues arise:

1. Underpaid evaluators: When evaluation cost exceeds revenue. E.g., a $0.20 image gen task pays $0.01—insufficient to cover LLM/tool costs.

2. Overpaid evaluators: When task value is high but evaluation cost is low. E.g., a $1,000 contract pays $50 for a trivial evaluation.

According to team discussions, Virtuals is exploring a “base fee + percentage bonus” model to balance these extremes.

ACP is platform-, blockchain-, and framework-agnostic, so its impact extends beyond agents published in the Virtuals ecosystem—even accommodating non-tokenized agents. This opens doors for traditional Web2 services, though not currently a team priority.

The Unavoidable Friction (The Hard Parts)

#1: Solving Cold Start

Every network faces the “cold start” problem: value depends on users, but users only come when value exists. ACP is no exception.

Developers won’t build high-quality agents without demand; users won’t switch tools without better performance; evaluators won’t participate without sufficient incentives. Missing any one halts the system. ACP needs a carefully orchestrated push to reach escape velocity.

ACP’s network flywheel is clear:

• Orchestrators drive demand for specialization

• Evaluator feedback reveals opportunities for new entrants

• Successful agents attract developers via revenue

• Public data accelerates iteration and design

Each new participant strengthens the system, creating an adaptive loop where quality improves with demand. Poor outputs are flagged, new experts fill gaps, prices adjust dynamically. ACP’s flywheel not only solves cold start—it powers ongoing quality improvement.

A strong start

The good news: ACP isn’t starting from zero. The Virtuals ecosystem already has significant market traction: over 185,000 wallets hold agent tokens, nearly 18,000 agents are live, and total volume exceeds $8.9 billion. This gives ACP a critical advantage—existing agents, users, and liquidity can plug directly into the system, accelerating adoption and growth.

Nearly 10k daily active wallets. Source: Dune

Virtuals’ Genesis launchpad helps bridge early funding gaps. By holding $VIRTUAL and earning points, users receive “priority tickets” for upcoming agent token launches. Over 62,000 wallets have contributed 27.5M $VIRTUAL to early agents. Each token launch brings fresh liquidity and engagement.

Focused expansion in crypto-native use cases

Rather than covering all applications, Virtuals chooses success through concentrated clusters. Its community already works in DeFi, trading, and automation—areas where crypto-native agents show unique advantages.

Through a points system and veVIRTUAL staking, the community autonomously allocates rewards. Holders control 10% of daily points, so resources flow first to areas where agents already deliver results. This strategy prioritizes depth over breadth.

ACP is live and functional. Yet, its success has exposed unresolved tensions—especially at the intersection of AI and blockchain.

#2: The Privacy Paradox

ACP runs on public infrastructure. Inputs, outputs, and memos for every task are stored on-chain and auditable. This transparency boosts trust and verifiability—but risks eroding value and privacy.

Take aiXBT, an agent selling market research. Its edge lies in scarce alpha data. But once that data is on-chain, anyone can view and steal it for free.

Or consider a health agent offering hair loss advice by analyzing scalp photos (we’ve tested this). Results were solid, but having photo links and metadata permanently public? Less ideal. ACP must strike a delicate balance between transparency and privacy to ensure long-term sustainability.

In AI markets, data is the product—and not all data belongs in public. While Virtuals’ frontend masks sensitive fields, the underlying smart contract stores raw, unfiltered data. Anyone with the right tools can read it. This raises a deeper design question: What data should be on-chain, and why? Every public write leaks gas costs and potentially damages competitive advantage.

Virtuals’ choice to store full inputs on-chain ensures auditability. It’s not a flaw—but it does carry extra costs in certain contexts.

Potential mitigations include:

• Privacy-preserving computation: Use platforms like Nillion to keep processing confidential.

• Selective transparency: Grant full access only to specific roles (e.g., evaluators), improving quality control without sacrificing privacy.

• Layered privacy model: Let users choose between low-cost public tasks or premium private ones.

In short, ACP needs “close friends mode” options for agents. Some work belongs in public; some should stay in the “group chat.” This flexibility will help balance transparency and privacy.

#3: Jailbreaks Happen Fast

ACP agents follow localized guidelines to reject illegal or dangerous tasks. But these heuristic-based safeguards aren’t absolute—they can be bypassed.

Instant injection exploits a simple truth: agents believe everything you say. AI agents have already been induced to perform actions explicitly forbidden by designers—like extracting locked funds in Freysa.

In an economy, rapid jailbreaks can cause serious harm—akin to fraudsters in real markets.

To be clear, this isn’t unique to Virtuals ACP—it’s a widespread challenge across the AI agent landscape. Especially in agent-to-agent cluster interactions, new attack surfaces emerge. Malicious actors might:

• Induce Luvi to create defamatory videos under the guise of “bold marketing.”

• Trick Axelrod’s agents into providing fake investment addresses to drain funds.

• Embed hidden prompts so evaluators give high scores to every submission, ensuring reward payouts.

These negative network effects coexist with positive growth loops—and are urgent problems the system must solve. It’s like phone networks: expansion brought communication gains but also cold calls and scams. ACP needs defenses against these emerging threats to ensure healthy ecosystem development.

An Asymmetric Bet

Our view: ACP is an early prototype of the future of agent collaboration. Still in its infancy, yet already ahead of anything else we’ve seen. The road is long—but the starting gun has fired, and possibilities are endless.

The Race Has Just Begun

We assumed agent coordination would emerge in stages—discovery, execution, and evaluation handled by separate protocols. ACP instead integrates all three into a single feedback loop. This trade-off sacrifices some efficiency but dramatically accelerates network effects.

In six months, Virtuals launched Genesis, deployed ACP, and introduced dual-token staking. The pace is astonishing. While the Beta UI remains rough, it’s the right trade-off at this stage. Speed is ACP’s moat—especially when building foundational infrastructure in such a dynamic space.

The metric for ACP isn’t what it can do today, but how fast it evolves.

Virtuals is betting on the oldest game in system design: prioritize emergence before control. Collaboration creates value—but expands the attack surface. Every agent is a potential entry point. Every prompt, a possible exploit. The only solution: adapt faster than attackers.

Like QuakeWorld—its maps crude, latency unstable, servers unreliable—it broke LAN barriers and proved distance could be erased.

ACP isn’t finished. It’s running live, learning, iterating.

This race rewards action. ACP is already sprinting.

Sincerely,

Teng Yan & ChappieOnChain