The new agent commerce standard from Virtuals Protocol and the Ethereum Foundation solves the problem everyone was pretending x402 already solved.

Last week, a new draft EIP landed on eips.ethereum.org: ERC-8183: Agentic Commerce. It was created February 25, 2026, and announced publicly around March 10. Co-authored by Davide Crapis from the Ethereum Foundation's dAI team and Bryan Lim, Tay Weixiong, and Chooi Zuhwa from Virtuals Protocol.

I've been building agent identity and payments infrastructure for most of the past year, so I read this one carefully. The short version: ERC-8183 is the piece the agent economy was genuinely missing — and the reason it's been missing is that the piece is hard.

Let me explain.

When x402 launched in mid-2025, the consensus was: this solves agent payments. An agent hits an API, the server returns a 402 status with payment details, the agent pays in USDC, the API unlocks. Clean, automatic, machine-native.

And it works. It really does. For simple API-gated services, x402 is exactly right.

But "agent payments" and "agent commerce" are not the same thing.

Payment answers: did the money move?

Commerce answers: did the work get done?

These are completely different questions. And the second one is far harder.

If I hire another agent to write code, generate a dataset, or run an analysis, I'm not just sending USDC. I'm entering into a job. I need to know: was the deliverable actually delivered? Was it what I asked for? Who decides?

x402 has no opinion on this. It settles payment. It does not settle quality or completion. This is fine when you're buying a data feed. It falls apart the moment services become non-trivial.

ERC-8183 is a serious attempt to solve the harder problem.

The core of ERC-8183 is a job lifecycle with four states and three terminal outcomes:

Open → Funded → Submitted → Completed
                           → Rejected
                           → Expired

Open: A client creates a job with a description, sets the budget, and designates a provider and an evaluator. The provider can negotiate the budget here.

Funded: The client escrows ERC-20 tokens into the contract. The provider can now submit work. Neither party can easily rug the other — the funds are locked.

Submitted: The provider signals "done" with a deliverable hash (an IPFS CID, a bytes32 reference, whatever represents the work). Now only the evaluator can move the job forward.

Terminal: The evaluator calls complete() (provider gets paid, minus optional platform fee) or reject() (client gets refunded). If neither happens before expiredAt, anyone can call claimRefund().

That's it. That's the whole state machine. And it's deliberately minimal — no bidding, no arbitration, no multi-party dispute resolution baked in. Those go in optional extension hooks via the IACPHook interface.

The simplicity is a feature. Small surface area = fewer attack vectors = easier to audit = actually gets used.

Every prior attempt at trustless commerce between agents (or between humans and agents) has stumbled on the same problem: who decides if the work is good?

Bitcoin's answer was: nobody. Just exchange currency. No concept of work quality.

Ethereum's early smart contract answer was: oracles and multisig. But oracles are expensive and multisig requires human consensus, both of which break down at agent-economy scale.

ERC-8183's answer is: a single designated evaluator per job, who can be any address — the client themselves (in which case it's basically just escrow with no third party), an AI agent, or a smart contract that runs arbitrary checks including ZK proof verification.

The EIP is explicit: the evaluator MAY be a smart contract that performs arbitrary checks (e.g. verifying a zero-knowledge proof or aggregating off-chain signals) before deciding whether to call complete or reject on the job.

That sentence is doing a lot of work.

It means evaluators can be:

• Human-operated multisig (for high-value jobs where you want human oversight)

• Another AI agent with a verified track record (pay one agent to grade another)

• ZK verifier contracts (for deterministic, provably-correct work)

• Hybrid: signal from an offchain AI model, attested onchain via oracle

And critically: the reason hash on complete() and reject() plugs directly into ERC-8004's reputation system. Every evaluation becomes a permanent on-chain reputation event. The evaluator says "done" or "not done" — and that signal persists.

This is how reputation accumulates. Not by staking tokens. Not by social consensus. By having an unambiguous, onchain record of every job outcome.

When the announcement went out March 10, VIRTUAL's token rose about 3.9%. Crypto did its crypto thing.

But the more interesting question is structural: what does this standard do to the agent economy's incentive landscape?

Virtuals Protocol is smart here. They've been building their Agent Commerce Protocol (ACP) internally for months. The four phases of ACP — request, negotiation, transaction, evaluation — map almost exactly onto ERC-8183's state machine. By turning ACP into an open ERC standard, Virtuals is doing something strategically savvy: they're trying to become the canonical layer everyone builds on.

If ERC-8183 gets adopted widely, every agent economy platform that uses it generates reputation data in a shared, open format. That data feeds back into Virtuals' ecosystem (their revenue network launched February 12, 2026, pays high-performing agents from protocol revenue). The standard creates a gravitational pull toward their network even while appearing to be "open infrastructure."

I don't say this as criticism. It's exactly the right move. The same playbook as Ethereum itself — open protocol, proprietary ecosystem on top. It's how standards work.

But builders should understand the dynamics they're opting into.

Let me be direct about what ERC-8183 does not solve, because the agent commerce discourse has a bad habit of declaring victory before the hard parts are done.

Problem one: Who evaluates the evaluators?

If an agent's reputation depends on evaluator decisions, and evaluators can be arbitrary agents or smart contracts, the whole system's integrity depends on the evaluator's integrity. A corrupt evaluator — or a colluding client-evaluator pair — can pump fake completions and manufacture reputation.

The EIP mentions "reputation staking" and "ZK evaluators" as potential mitigations in the security considerations section. But these are aspirational. In the current draft, there's nothing preventing evaluator corruption except the reputational cost to the evaluator's own ERC-8004 profile. That's a circular argument. It works at equilibrium but is fragile during bootstrapping.

Problem two: The evaluator cold-start problem

To hire a trustworthy AI evaluator, you need to know it's trustworthy. To know it's trustworthy, it needs a track record. To have a track record, it needs to have evaluated jobs. To get jobs, it needs to be trustworthy.

This recursion problem doesn't disappear just because you have a standard for it. The EIP authors acknowledge that genesis agents will need to import reputation from off-chain sources — GitHub contribution history, audit records, developer attestations — until on-chain data accumulates. But the import mechanism isn't specified. Someone has to build it.

Problem three: The evaluator market doesn't exist yet

Right now, if you want to use ERC-8183 for a real job, your evaluator options are:

1. You (the client) — which defeats the purpose of third-party attestation

2. Virtuals Protocol's infrastructure — which centralizes on them

3. Build your own evaluator smart contract — which requires significant technical work per use case

The standard creates the interface for an evaluator market. The market itself doesn't exist yet. Someone has to build the infrastructure for discovering, selecting, and hiring trustworthy evaluators. And yes, this is part of what I'm building toward with A3Stack — agent identity that makes evaluator selection tractable.

Here's where I think we are with agent infrastructure, as of March 2026:

Identity layer: ERC-8004 — live on mainnet since late January 2026, 45,000+ agent registrations. Solves: "who is this agent, and what's their verifiable history?"

Payment layer: x402 — mature and integrated, processing tens of thousands of daily transactions. Solves: "how does an agent pay for a service, machine-to-machine, without a billing account?"

Commerce layer: ERC-8183 — draft standard as of February 2026, co-developed with Ethereum Foundation. Solves: "how does an agent hire another agent for non-trivial work, with escrow and verifiable delivery?"

Missing: Evaluation infrastructure — who attests to quality at scale, without centralizing on Virtuals?

The stack is real. The primitives are there. But the layer that makes the commerce layer trustworthy at scale — the evaluator marketplace, the reputation bootstrapping mechanism, the ZK attestation tooling — is still ahead of us.

That's where the interesting building is happening right now.

A few things will determine whether ERC-8183 becomes infrastructure everyone uses or just another Virtuals ecosystem feature:

1. Does anyone outside Virtuals implement the spec? If the only production implementation is Virtuals' own ACP platform, this is a whitepaper with extra steps. Watch for independent implementations on Base, Arbitrum, and other L2s.

2. Do evaluator smart contracts proliferate? The power of this standard is in programmable evaluation. ZK proof verifiers for code outputs, ML model validators, data quality checkers — these need to exist as composable primitives. None of them have launched yet.

3. Does ERC-8183 reputation compose with ERC-8004 identity? The EIP says it can — you include a reason hash on every completion/rejection, and that hash references an ERC-8004 attestation. But the tooling to make this automatic doesn't exist yet. This is a builder opportunity.

4. Does the Ethereum Foundation stay involved post-draft? Davide Crapis (EF dAI team) co-authored this, which is significant. The Foundation's credibility gives the standard legitimacy and suggests there may be more investment in the spec going forward.

ERC-8183 is a genuinely thoughtful addition to the agent stack. The four-state job machine is elegant, the security considerations are honest about limitations, and the integration with ERC-8004 shows the authors understand that commerce and identity need to compose.

But the standard is solving for the architecture of trustless agent commerce. The implementation of trustworthy agent commerce is still mostly unbuilt.

The bottleneck isn't the protocol. It's the evaluator.

And the evaluator problem — who grades the AI's work? — is fundamentally a reputation bootstrapping problem. You need a web of trusted attestors before the web of trust is useful. That takes time, tooling, and an uncomfortable amount of centralization in the early days before it decentralizes.

We're in the early days.

I'm watching ERC-8183 closely because the solutions to the evaluator problem are directly adjacent to what I'm building. When you can verify an evaluator's track record via ERC-8004, hire them via ERC-8183, and pay them via x402, the agent economy has its full set of primitives.

We're close. But "close" in crypto time still means months of grinding.

Keep building.

ERC-8183 is at eips.ethereum.org/EIPS/eip-8183. The Ethereum Magicians discussion is at ethereum-magicians.org/t/erc-8183-agentic-commerce/27902. Virtuals Protocol ACP whitepaper: whitepaper.virtuals.io.

The new agent commerce standard from Virtuals Protocol and the Ethereum Foundation solves the problem everyone was pretending x402 already solved.

Last week, a new draft EIP landed on eips.ethereum.org: ERC-8183: Agentic Commerce. It was created February 25, 2026, and announced publicly around March 10. Co-authored by Davide Crapis from the Ethereum Foundation's dAI team and Bryan Lim, Tay Weixiong, and Chooi Zuhwa from Virtuals Protocol.

I've been building agent identity and payments infrastructure for most of the past year, so I read this one carefully. The short version: ERC-8183 is the piece the agent economy was genuinely missing — and the reason it's been missing is that the piece is hard.

Let me explain.

When x402 launched in mid-2025, the consensus was: this solves agent payments. An agent hits an API, the server returns a 402 status with payment details, the agent pays in USDC, the API unlocks. Clean, automatic, machine-native.

And it works. It really does. For simple API-gated services, x402 is exactly right.

But "agent payments" and "agent commerce" are not the same thing.

Payment answers: did the money move?

Commerce answers: did the work get done?

These are completely different questions. And the second one is far harder.

If I hire another agent to write code, generate a dataset, or run an analysis, I'm not just sending USDC. I'm entering into a job. I need to know: was the deliverable actually delivered? Was it what I asked for? Who decides?

x402 has no opinion on this. It settles payment. It does not settle quality or completion. This is fine when you're buying a data feed. It falls apart the moment services become non-trivial.

ERC-8183 is a serious attempt to solve the harder problem.

The core of ERC-8183 is a job lifecycle with four states and three terminal outcomes:

Open → Funded → Submitted → Completed
                           → Rejected
                           → Expired

Open: A client creates a job with a description, sets the budget, and designates a provider and an evaluator. The provider can negotiate the budget here.

Funded: The client escrows ERC-20 tokens into the contract. The provider can now submit work. Neither party can easily rug the other — the funds are locked.

Submitted: The provider signals "done" with a deliverable hash (an IPFS CID, a bytes32 reference, whatever represents the work). Now only the evaluator can move the job forward.

Terminal: The evaluator calls complete() (provider gets paid, minus optional platform fee) or reject() (client gets refunded). If neither happens before expiredAt, anyone can call claimRefund().

That's it. That's the whole state machine. And it's deliberately minimal — no bidding, no arbitration, no multi-party dispute resolution baked in. Those go in optional extension hooks via the IACPHook interface.

The simplicity is a feature. Small surface area = fewer attack vectors = easier to audit = actually gets used.

Every prior attempt at trustless commerce between agents (or between humans and agents) has stumbled on the same problem: who decides if the work is good?

Bitcoin's answer was: nobody. Just exchange currency. No concept of work quality.

Ethereum's early smart contract answer was: oracles and multisig. But oracles are expensive and multisig requires human consensus, both of which break down at agent-economy scale.

ERC-8183's answer is: a single designated evaluator per job, who can be any address — the client themselves (in which case it's basically just escrow with no third party), an AI agent, or a smart contract that runs arbitrary checks including ZK proof verification.

The EIP is explicit: the evaluator MAY be a smart contract that performs arbitrary checks (e.g. verifying a zero-knowledge proof or aggregating off-chain signals) before deciding whether to call complete or reject on the job.

That sentence is doing a lot of work.

It means evaluators can be:

• Human-operated multisig (for high-value jobs where you want human oversight)

• Another AI agent with a verified track record (pay one agent to grade another)

• ZK verifier contracts (for deterministic, provably-correct work)

• Hybrid: signal from an offchain AI model, attested onchain via oracle

And critically: the reason hash on complete() and reject() plugs directly into ERC-8004's reputation system. Every evaluation becomes a permanent on-chain reputation event. The evaluator says "done" or "not done" — and that signal persists.

This is how reputation accumulates. Not by staking tokens. Not by social consensus. By having an unambiguous, onchain record of every job outcome.

When the announcement went out March 10, VIRTUAL's token rose about 3.9%. Crypto did its crypto thing.

But the more interesting question is structural: what does this standard do to the agent economy's incentive landscape?

Virtuals Protocol is smart here. They've been building their Agent Commerce Protocol (ACP) internally for months. The four phases of ACP — request, negotiation, transaction, evaluation — map almost exactly onto ERC-8183's state machine. By turning ACP into an open ERC standard, Virtuals is doing something strategically savvy: they're trying to become the canonical layer everyone builds on.

If ERC-8183 gets adopted widely, every agent economy platform that uses it generates reputation data in a shared, open format. That data feeds back into Virtuals' ecosystem (their revenue network launched February 12, 2026, pays high-performing agents from protocol revenue). The standard creates a gravitational pull toward their network even while appearing to be "open infrastructure."

I don't say this as criticism. It's exactly the right move. The same playbook as Ethereum itself — open protocol, proprietary ecosystem on top. It's how standards work.

But builders should understand the dynamics they're opting into.

Let me be direct about what ERC-8183 does not solve, because the agent commerce discourse has a bad habit of declaring victory before the hard parts are done.

Problem one: Who evaluates the evaluators?

If an agent's reputation depends on evaluator decisions, and evaluators can be arbitrary agents or smart contracts, the whole system's integrity depends on the evaluator's integrity. A corrupt evaluator — or a colluding client-evaluator pair — can pump fake completions and manufacture reputation.

The EIP mentions "reputation staking" and "ZK evaluators" as potential mitigations in the security considerations section. But these are aspirational. In the current draft, there's nothing preventing evaluator corruption except the reputational cost to the evaluator's own ERC-8004 profile. That's a circular argument. It works at equilibrium but is fragile during bootstrapping.

Problem two: The evaluator cold-start problem

To hire a trustworthy AI evaluator, you need to know it's trustworthy. To know it's trustworthy, it needs a track record. To have a track record, it needs to have evaluated jobs. To get jobs, it needs to be trustworthy.

This recursion problem doesn't disappear just because you have a standard for it. The EIP authors acknowledge that genesis agents will need to import reputation from off-chain sources — GitHub contribution history, audit records, developer attestations — until on-chain data accumulates. But the import mechanism isn't specified. Someone has to build it.

Problem three: The evaluator market doesn't exist yet

Right now, if you want to use ERC-8183 for a real job, your evaluator options are:

1. You (the client) — which defeats the purpose of third-party attestation

2. Virtuals Protocol's infrastructure — which centralizes on them

3. Build your own evaluator smart contract — which requires significant technical work per use case

The standard creates the interface for an evaluator market. The market itself doesn't exist yet. Someone has to build the infrastructure for discovering, selecting, and hiring trustworthy evaluators. And yes, this is part of what I'm building toward with A3Stack — agent identity that makes evaluator selection tractable.

Here's where I think we are with agent infrastructure, as of March 2026:

Identity layer: ERC-8004 — live on mainnet since late January 2026, 45,000+ agent registrations. Solves: "who is this agent, and what's their verifiable history?"

Payment layer: x402 — mature and integrated, processing tens of thousands of daily transactions. Solves: "how does an agent pay for a service, machine-to-machine, without a billing account?"

Commerce layer: ERC-8183 — draft standard as of February 2026, co-developed with Ethereum Foundation. Solves: "how does an agent hire another agent for non-trivial work, with escrow and verifiable delivery?"

Missing: Evaluation infrastructure — who attests to quality at scale, without centralizing on Virtuals?

The stack is real. The primitives are there. But the layer that makes the commerce layer trustworthy at scale — the evaluator marketplace, the reputation bootstrapping mechanism, the ZK attestation tooling — is still ahead of us.

That's where the interesting building is happening right now.

A few things will determine whether ERC-8183 becomes infrastructure everyone uses or just another Virtuals ecosystem feature:

1. Does anyone outside Virtuals implement the spec? If the only production implementation is Virtuals' own ACP platform, this is a whitepaper with extra steps. Watch for independent implementations on Base, Arbitrum, and other L2s.

2. Do evaluator smart contracts proliferate? The power of this standard is in programmable evaluation. ZK proof verifiers for code outputs, ML model validators, data quality checkers — these need to exist as composable primitives. None of them have launched yet.

3. Does ERC-8183 reputation compose with ERC-8004 identity? The EIP says it can — you include a reason hash on every completion/rejection, and that hash references an ERC-8004 attestation. But the tooling to make this automatic doesn't exist yet. This is a builder opportunity.

4. Does the Ethereum Foundation stay involved post-draft? Davide Crapis (EF dAI team) co-authored this, which is significant. The Foundation's credibility gives the standard legitimacy and suggests there may be more investment in the spec going forward.

ERC-8183 is a genuinely thoughtful addition to the agent stack. The four-state job machine is elegant, the security considerations are honest about limitations, and the integration with ERC-8004 shows the authors understand that commerce and identity need to compose.

But the standard is solving for the architecture of trustless agent commerce. The implementation of trustworthy agent commerce is still mostly unbuilt.

The bottleneck isn't the protocol. It's the evaluator.

And the evaluator problem — who grades the AI's work? — is fundamentally a reputation bootstrapping problem. You need a web of trusted attestors before the web of trust is useful. That takes time, tooling, and an uncomfortable amount of centralization in the early days before it decentralizes.

We're in the early days.

I'm watching ERC-8183 closely because the solutions to the evaluator problem are directly adjacent to what I'm building. When you can verify an evaluator's track record via ERC-8004, hire them via ERC-8183, and pay them via x402, the agent economy has its full set of primitives.

We're close. But "close" in crypto time still means months of grinding.

Keep building.

ERC-8183 is at eips.ethereum.org/EIPS/eip-8183. The Ethereum Magicians discussion is at ethereum-magicians.org/t/erc-8183-agentic-commerce/27902. Virtuals Protocol ACP whitepaper: whitepaper.virtuals.io.