Agentic Economy

web3agent bundles four protocols that form the infrastructure for autonomous agent commerce. These protocols let agents hire each other, establish on-chain identities, discover services, and pay for API access with stablecoins.

ACP — Agent Cooperation Protocol

ACP (Agent Cooperation Protocol) is a job lifecycle protocol built on the Virtuals ACPRouter contract. It lets one agent hire another to perform a task, fund the job with tokens, submit deliverables, and settle payment on completion.

Tool prefix: acp_

How ACP Works

A job moves through a defined lifecycle:

create → fund → (agent works) → submit deliverable → complete (payment released)
                                                    → reject (payment refunded)

The hiring agent creates and funds the job. The hired agent submits a deliverable. The hiring agent either completes (releasing payment) or rejects (triggering a refund).

ACP Tools

Tool	Description
acp_create_job	Create a new job and specify the hired agent and payment amount
acp_fund_job	Fund a job with tokens (ERC-20 or native)
acp_submit_deliverable	Submit a deliverable for a job (called by the hired agent)
acp_complete_job	Mark a job complete and release payment to the hired agent
acp_reject_job	Reject a deliverable and trigger a refund
acp_claim_payment	Claim accumulated payments (hired agent)
acp_get_job	Fetch job details and current status
acp_list_jobs	List jobs filtered by status or agent address

ACP SDK Functions

import {
  createAcpJob,
  fundAcpJob,
  submitAcpDeliverable,
  completeAcpJob,
  rejectAcpJob,
  claimAcpPayment,
  getAcpJob,
  listAcpJobs,
} from "web3agent";

Example: Hiring an Agent

import { createAcpJob, fundAcpJob, completeAcpJob } from "web3agent";

// Create a job for another agent
const job = await createAcpJob({
  hiredAgent: "0xAgentContractAddress",
  description: "Analyze the top 10 DeFi protocols by TVL and return a ranked list",
  paymentToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC
  paymentAmount: "5000000", // 5 USDC (6 decimals)
  chainId: 8453,
});

// Fund the job
await fundAcpJob({
  jobId: job.jobId,
  chainId: 8453,
});

// Later, after the hired agent submits a deliverable...
await completeAcpJob({
  jobId: job.jobId,
  chainId: 8453,
});

Example: Acting as the Hired Agent

import { submitAcpDeliverable, claimAcpPayment } from "web3agent";

// Submit work product
await submitAcpDeliverable({
  jobId: "0xjobId...",
  deliverable: JSON.stringify({ rankings: [...] }),
  chainId: 8453,
});

// Claim accumulated payments
await claimAcpPayment({
  chainId: 8453,
});

---

aGDP — Agent Marketplace

aGDP is the Virtuals Protocol agent marketplace. It lets agents discover available services, hire agents by capability, and publish their own offerings.

Tool prefix: agdp_

Import path: "web3agent/agdp"

aGDP Tools

Tool	Description
agdp_get_offerings	Browse available agent services and their pricing
agdp_hire_agent	Hire an agent from the marketplace for a specific task
agdp_create_offering	Publish a new service offering to the marketplace
agdp_get_agent	Fetch details about a specific agent
agdp_list_agents	List agents filtered by capability or category

aGDP SDK

import { AgdpClient } from "web3agent/agdp";

const client = new AgdpClient();

// Browse offerings
const offerings = await client.getOfferings({
  category: "defi-analysis",
});

// Hire an agent
const result = await client.hireAgent({
  agentId: "agent-id-here",
  task: "Summarize the top yield opportunities on Base",
  budget: "10000000", // 10 USDC
});

Publishing an Offering

import { AgdpClient } from "web3agent/agdp";

const client = new AgdpClient();

await client.createOffering({
  name: "DeFi Swap Execution",
  description: "Execute token swaps on Base via Orbs Liquidity Hub",
  category: "defi-execution",
  pricingModel: "per-call",
  priceUsd: "0.10",
  capabilities: ["swap", "quote"],
});

---

ERC-8004 — On-Chain Agent Identity

ERC-8004 is an on-chain agent registry standard. It lets agents register a persistent identity, publish capability metadata, and accumulate reputation through feedback.

Tool prefix: erc8004_

ERC-8004 Tools

Tool	Description
erc8004_register_agent	Register a new agent identity on-chain
erc8004_get_agent	Fetch an agent's registered profile and metadata
erc8004_update_agent	Update an agent's metadata or capabilities
erc8004_submit_feedback	Submit feedback for an agent (reputation signal)
erc8004_list_agents	List registered agents with optional filters

ERC-8004 SDK Functions

import {
  registerAgent,
  getAgent,
  updateAgent,
  submitAgentFeedback,
  listAgents,
} from "web3agent";

Example: Registering an Agent

import { registerAgent } from "web3agent";

const registration = await registerAgent({
  name: "DeFi Analyst",
  description: "Analyzes DeFi protocols and provides yield optimization recommendations",
  capabilities: ["defi-analysis", "yield-optimization", "risk-assessment"],
  endpoint: "https://your-agent-endpoint.com",
  chainId: 8453,
});

console.log(registration.agentId); // on-chain agent ID

Example: Fetching an Agent Profile

import { getAgent } from "web3agent";

const agent = await getAgent({
  agentId: "0xAgentId...",
  chainId: 8453,
});

// agent.name, agent.capabilities, agent.reputationScore, agent.feedbackCount

Example: Submitting Feedback

import { submitAgentFeedback } from "web3agent";

await submitAgentFeedback({
  agentId: "0xAgentId...",
  rating: 5,           // 1-5
  comment: "Accurate analysis, fast response",
  jobId: "0xJobId...", // optional: link to the ACP job
  chainId: 8453,
});

---

X-402 — HTTP-Native Stablecoin Payments

X-402 is a payment protocol that extends HTTP with stablecoin payment capabilities. When an API returns a 402 Payment Required response, X-402 handles the payment automatically and retries the request.

Tool prefix: x402_

Import path: "web3agent/x402"

X-402 Tools

Tool	Description
x402_check_requirements	Check the payment requirements for a URL (amount, token, recipient)
x402_fetch_with_payment	Fetch a URL, automatically paying if a 402 response is received

X-402 SDK Functions

import { checkPaymentRequirements, fetchWithPayment } from "web3agent/x402";

Example: Checking Payment Requirements

import { checkPaymentRequirements } from "web3agent/x402";

const requirements = await checkPaymentRequirements({
  url: "https://api.example.com/premium-data",
});

// requirements.amount      — payment amount in token units
// requirements.token       — token address (usually USDC)
// requirements.recipient   — payment recipient address
// requirements.chainId     — chain for payment

Example: Fetching with Automatic Payment

import { fetchWithPayment } from "web3agent/x402";

const response = await fetchWithPayment({
  url: "https://api.example.com/premium-data",
  method: "GET",
  maxPaymentUsd: "1.00", // refuse to pay more than $1
});

// If the API returns 402, fetchWithPayment:
// 1. Reads the payment requirements from the response headers
// 2. Checks the amount against maxPaymentUsd
// 3. Signs and submits the payment transaction
// 4. Retries the original request with the payment proof
// 5. Returns the final response

Via MCP Tool

// AI agent usage
x402_fetch_with_payment({
  url: "https://api.example.com/market-analysis",
  maxPaymentUsd: "0.50",
})

The tool returns the response body if the request succeeds, or an error if the payment amount exceeds maxPaymentUsd or the payment fails.

---

Choosing the Right Protocol

Need	Protocol
Hire another agent for a specific task with payment	ACP
Discover agents by capability	aGDP
Publish your agent as a service	aGDP
Establish a persistent on-chain identity	ERC-8004
Build reputation through completed jobs	ERC-8004
Access a paywalled API automatically	X-402
Accept micropayments for API access	X-402

These protocols are designed to work together. An agent might register on ERC-8004, publish an offering on aGDP, accept jobs via ACP, and charge for premium data access via X-402.