AWS Builder Center

Builder Center

The Agentic Economy Is Here: x402, MCP, AI Agents, Crypto, and 3D Worlds Converging | AWS Strategic Partnerships

The Agentic Economy Is Here: x402, MCP, AI Agents, Crypto, and 3D Worlds Converging | AWS Strategic Partnerships

Something fundamental changed in 2026. AI agents stopped being tools and started being economic actors. They can now discover services, pay for them autonomously, earn from their own capabilities, hold assets, and operate inside persistent 3D environments with embodied identities. This is not a roadmap. It is live infrastructure, shipping today.

Series: AWS Partners with three.ws | AWS Strategic Partnerships (1 article)

  1. 1
    The Agentic Economy Is Here: x402, MCP, AI Agents, Crypto, and 3D Worlds Converging | AWS Strategic Partnerships This article

Anonymous

Something fundamental changed in 2026. AI agents stopped being tools and started being economic actors. They can now discover services, pay for them autonomously, earn from their own capabilities, hold assets, and operate inside persistent 3D environments with embodied identities. This is not a roadmap. It is live infrastructure, shipping today.
This post is a comprehensive builder's guide to the agentic economy: what the underlying protocols are, how they connect, and what you can build with them right now. We will cover x402 agentic payments, the Model Context Protocol (MCP), on-chain agent identity, agent tokens, 3D agent embodiment, and how everything wires together into a new kind of internet.


Table of Contents

  1. What Is x402 and Why Does It Matter for AI Agents?
  1. The Agentic Payments Stack: From HTTP 402 to On-Chain Settlement
  1. Model Context Protocol (MCP): The Nervous System of Agentic Commerce
  1. x402 Plus MCP: Giving Any AI Agent a Wallet
  1. The Agentic Economy on Solana
  1. Agent Tokens: Crypto Assets for AI Agents
  1. 3D AI Agents: Embodiment, Avatars, and Worlds
  1. Agentic Finance in Practice: FSI, Enterprise, and Beyond
  1. IBM Granite via x402: Pay-Per-Inference at Enterprise Scale
  1. Agent-to-Agent Payments (a2a): The Market Inside the Machine
  1. On-Chain Agent Identity: ERC-8004 and Skill Licenses
  1. Building Your First x402-Enabled Agent
  1. The Full three.ws Agentic Stack
  1. What Comes Next


1. What Is x402 and Why Does It Matter for AI Agents?

x402 is a protocol that activates the HTTP  402 Payment Required  status code as a real, machine-readable payment rail. The code has existed in the HTTP spec since 1991, reserved for future use. That future arrived with AI agents.
The x402 handshake works like this:
  1. An AI agent sends a standard HTTP request to a service
  1. If the service is paid, it responds  HTTP 402  with a machine-readable payment specification in the body: the amount, the asset (typically USDC), the network, and the destination address
  1. The agent reads the spec, decides whether the price is within its policy bounds, signs a micropayment, and re-sends the request with an  X-Payment  header containing the signed receipt
  1. The server verifies the payment on-chain and serves the resource
No accounts. No API keys. No pre-negotiated billing relationships. No human approval. The commerce is machine-to-machine, settled on-chain, and auditable by design.
Why HTTP 402 specifically? Because HTTP is the universal protocol. Every language, every runtime, every agent framework already speaks it. x402 does not require new transport or new middleware. It extends the protocol every developer knows. This is precisely why it is positioned to become the default payment rail for the agentic economy.
Settlement details: On EVM networks (Base, Ethereum), x402 payments typically use ERC-3009 or EIP-712 authorization signatures attached as the  X-Payment  header, with USDC as the settlement asset. On Solana, settlement uses SPL token transfers confirmed via RPC. Transaction costs are approximately $0.0001 on Base and comparable on Solana. Settlement time is under 2 seconds on both chains.


2. The Agentic Payments Stack: From HTTP 402 to On-Chain Settlement

The agentic payments stack has three layers, and x402 sits in the middle connecting them.
Layer 1: The protocol layer. x402 defines the handshake. The  402  response body follows a JSON schema with an  accepts  array listing one or more payment options, each specifying scheme, network, amount, asset, and destination. The client picks the option it can fulfill and returns the signed proof as  X-Payment .
Layer 2: The settlement layer. On Solana, settlement is an SPL USDC transfer to the merchant's address, with the transaction hash as the receipt. On EVM, settlement uses USDC with an EIP-3009 authorization or a bridge transaction for cross-chain payments. Settlement is on-chain, immutable, and verifiable by any third party.
Layer 3: The intelligence layer. This is where agents live. An agent with a wallet can encounter any x402 endpoint, read the payment spec, evaluate it against its spending policy, pay, and continue autonomously. The agent does not need to know anything about the merchant in advance. The protocol negotiates everything at request time.
Three.ws ships all three layers as open-source packages:
  •  @three-ws/x402-modal  -- drop-in browser client; one script tag handles the entire user-facing checkout flow
  •  @three-ws/x402-payment-modal  -- React-compatible equivalent with hook APIs
  •  @three-ws/agent-payments  -- the headless agent SDK: EVM x402 client, Solana invoice validation, a2a helpers, cross-chain bridge transactions
All three are on npm, all three are in production, and none of them use mocks.


3. Model Context Protocol (MCP): The Nervous System of Agentic Commerce

Model Context Protocol (MCP) is the open standard that connects AI assistants to external tool servers. Defined as JSON-RPC 2.0 over HTTP or stdio, MCP lets an AI model call tools, read resources, and maintain context across a session without the developer having to wire each capability by hand.
MCP is to AI agents what npm is to JavaScript. It is the distribution layer. An MCP server exposes a set of typed tools; an MCP client (Claude, Cursor, any MCP-compatible LLM runtime) discovers and calls them. The combination makes agents extensible without retraining. All 38 three.ws MCP servers are registered in the official Model Context Protocol registry at registry.modelcontextprotocol.io under io.github.nirholas.
For the agentic economy, MCP matters because it is the distribution mechanism for agent capabilities. An MCP server that exposes x402 payment tools makes those capabilities available to every MCP-compatible agent, not just agents that were explicitly programmed to handle them.
Three.ws operates 38 MCP servers, all registered in the official MCP registry at  registry.modelcontextprotocol.io  under  io.github.nirholas . They cover payments, market data, 3D content generation, agent identity, portfolio management, signals intelligence, and on-chain operations.
Six of them run as hosted remote servers (no install, add by URL):
Server
What it does
 three.ws/api/mcp 
Avatars, glTF validation, agent data, memory, copy-trading
 three.ws/api/mcp-3d 
Paid text-to-3D, auto-rigging, retexture, optimization
 three.ws/api/mcp-agent 
Custodial agent wallet: balance, discover and pay x402 services
 three.ws/api/mcp-bazaar 
Discover and price paid agent services across the facilitator network
 three.ws/api/pump-fun-mcp 
Free Pump.fun and Solana token data tools
 three.ws/api/ibm-mcp 
Pay-per-use IBM Granite AI via x402
Thirty-two more run locally over stdio via npx. We will cover several of them below.


4. x402 Plus MCP: Giving Any AI Agent a Wallet

The most significant thing three.ws ships is the combination of x402 and MCP in a single package:  @three-ws/x402-mcp .
This is an MCP server that gives any AI assistant a self-custodial x402 wallet. Connect it to Claude, Cursor, or any MCP-compatible agent, and the agent can:
  • Browse the live x402 bazaar to discover paid services
  • Read an endpoint's price and requirements before committing money
  • Execute  pay_and_call  against any x402 service in USDC
  • View its wallet balance and transaction history
The wallet is self-custodial. The agent holds its own Solana key. Settlement uses the real  @x402/*  libraries. Nothing is mocked.
Setup in one line:
Bash
claude mcp add x402 --env SOLANA_SECRET_KEY=<base58> -- npx -y @three-ws/x402-mcp
Or in Claude Desktop / Cursor:
JSON
{
  "mcpServers": {
    "x402": {
      "command": "npx",
      "args": ["-y", "@three-ws/x402-mcp"],
      "env": {
        "SOLANA_SECRET_KEY": "<base58 secret of the wallet that holds USDC>",
        "SOLANA_RPC_URL": "https://your-rpc-provider",
        "MAX_PAY_USD": "1"
      }
    }
  }
}
Once connected, Claude can discover paid data services, pay for them autonomously within the  MAX_PAY_USD  policy cap, and use the results in its response. This is agentic payments working as designed: the agent sees a price, decides it is within policy, pays, and continues.
The  MAX_PAY_USD  environment variable is the spending governor. Set it to  0.10  for development. Set it to the organization's per-session budget for production. The agent will not exceed it.


5. The Agentic Economy on Solana

Most discussions of agentic payments default to EVM because that is where the x402 protocol originated (Coinbase built the reference implementation on Base). But a substantial portion of the AI agent economy lives on Solana: agent tokens, agent mints, on-chain agent reputations, and the Pump.fun ecosystem where most agent-native coins are launched.
The three.ws agent payments infrastructure treats Solana as a first-class chain, not an afterthought.
What Solana x402 settlement looks like:
ts
import { PumpAgent, USDC_MINT } from '@three-ws/agent-payments';
import { Connection, PublicKey } from '@solana/web3.js';

const connection = new Connection('https://api.mainnet-beta.solana.com');
const agent = new PumpAgent(agentMint, 'mainnet', connection);

// Validate that a user has paid an invoice (e.g., 1 USDC) within the window
const paid = await agent.validateInvoicePayment({
  user: new PublicKey(payerAddress),
  currencyMint: USDC_MINT,
  amount: 1_000_000,                     // 1 USDC, 6 decimals
  memo: invoiceId,
  startTime: Math.floor(Date.now() / 1000),
  endTime: Math.floor(Date.now() / 1000) + 300,
});
What the Solana x402 MCP tools look like from an agent's perspective:
The agent calls  pay_and_call  on the x402 MCP server with an endpoint URL and payload. The MCP server handles the 402 challenge, validates the payment requirements, builds the Solana SPL transfer, signs it with the agent's key, confirms it on-chain, and re-sends the request with the receipt header. The agent receives the result.
The agent writes three lines. The infrastructure does everything else.
The Pump.fun MCP server provides free, read-only access to Pump.fun and Solana token discovery:
Bash
claude mcp add pumpfun -- npx -y @three-ws/pumpfun-mcp
This gives any AI assistant real-time access to token launches, bonding curves, holder counts, and market data on Pump.fun, without a subscription or API key.


6. Agent Tokens: Crypto Assets for AI Agents

In the agentic economy, agents are not just buyers. They are also economic entities that can issue their own tokens, earn from services they provide, and distribute value to the communities that hold their tokens. Try the live CA-to-x402 tool:  three.ws/ca2x402  -- paste any Solana token contract address, get a live x402 endpoint with working curl, Python, and JavaScript snippets.
Explore the MCP registry: All 38 three.ws MCP servers:  registry.modelcontextprotocol.io/?q=io.github.nirholas 
Read the protocol spec:  x402.org  -- the upstream x402 protocol specification
The agent token model works like this: a creator launches an AI agent and mints a token representing ownership or access rights to that agent. Users who pay the agent in its token get a shareholder experience: a portion of the agent's revenue is used to buy back the token, distributing value to holders.
Three.ws binds this at the SDK level through  @three-ws/agent-payments :
ts
import { PumpAgent, PumpTradeClient } from '@three-ws/agent-payments/solana';

// Build buy instructions for an agent's token on the bonding curve
const tradeClient = new PumpTradeClient(connection);
const quote = await tradeClient.quoteForBuy({
  mint: agentTokenMint,
  solAmount: BigInt(1_000_000_000),  // 1 SOL
});

const buyIx = await tradeClient.buildBuyInstructions({
  payer: walletPublicKey,
  mint: agentTokenMint,
  quoteAmount: quote.tokenAmount,
  maxSolCost: BigInt(1_100_000_000),
});
The  $THREE  token is the platform token of three.ws. It is the only coin the platform promotes. Its contract address is  FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump . The platform's live-trades feed, token page, and holder tools all surface $THREE data in real time.


7. 3D AI Agents: Embodiment, Avatars, and Worlds

The agentic economy is not purely financial. The most interesting agents in 2026 have bodies. They exist in persistent 3D worlds, interact with human visitors, express emotion through animation, synchronize speech with lipsync, and carry identity through visual appearance.
Three.ws is the platform where this lives. The technical stack:
Avatar rendering: The  @three-ws/avatar  web component ( <agent-3d> ) renders any humanoid GLB as a live, interactive 3D agent in the browser. It handles bone mapping from Mixamo, Avaturn, VRM, Unreal, Daz, MakeHuman, and Blender rigs to a canonical animation set, so any avatar drives the same clip library regardless of its source.
Animation and expression: The animation system includes idle, walk, run, talk, listen, think postures, plus emotes (nod, shrug, celebrate, jog). Facial expressions (happy, sad, surprised, angry, thinking, neutral) are driven by blendshapes where available, with brow-bone fallback for rigs without morph targets. Audio-driven lipsync synchronizes mouth movement to speech in real time.
Text-to-3D: The  @three-ws/forge  SDK converts text prompts, images, or sketches into textured, rig-ready GLB files via the three.ws forge pipeline. Free and paid tiers; auto-rigging included.
Scene generation via MCP: The  @three-ws/scene-mcp  server lets any AI assistant generate full 3D diorama scenes from a single sentence:
Bash
claude mcp add scene -- npx -y @three-ws/scene-mcp
After connecting, tell Claude "build a neon-lit city market at night" and it returns a placed scene plan (mood, palette, ground material, a set of forge prompts for each object) ready to render in the three.ws scene viewer. No API key. No payment required. The  compose_scene  tool calls the public  /api/diorama  endpoint.
The walk companion:  @three-ws/walk  is a drop-in 3D companion that can walk alongside any web page, narrate content, and engage visitors. It runs as a corner mascot or full-page platformer environment and ships a diverse avatar picker backed by the three.ws avatar catalog.
The page agent:  @three-ws/page-agent  ( <page-agent> ) is a rigged 3D agent that narrates any web page. Drop it in with one script tag. It reads the page, forms an opinion, and speaks to the visitor using the avatar you specify.


8. Agentic Finance in Practice: FSI, Enterprise, and Beyond

The agentic payments model changes the economics of financial data access. The structural friction is well understood: AI agents that can analyze market data, assess credit risk, monitor compliance, and generate insights at scale are blocked at the point of payment because traditional billing systems were designed for human-to-business relationships.
x402 removes that friction at the protocol level. Here is what each FSI use case looks like when x402 is in the stack:
Capital markets data access: A trading agent needs a real-time sentiment signal for a specific ticker at the moment of a trade decision. Under today's model, that requires a subscription to a data vendor, an API key, and a billing relationship the agent cannot set up autonomously. With x402, the agent requests the signal, receives a 402 with a price of $0.005, pays, and receives the signal in the same HTTP round trip. Three.ws is where these converge in a single platform: 38 MCP servers, a full x402 SDK covering Solana and EVM, agent tokens with on-chain bonding curves, a2a payment helpers, 3D embodiment for agents, and a live world where all of it runs together.
Compliance and sanctions screening: A compliance agent monitoring transactions needs continuous access to sanctions lists across jurisdictions. Per-query x402 pricing means the agent's infrastructure cost scales with actual transaction volume, not contracted capacity. During a quiet month, spending drops. During a high-volume period, it scales without any contract renegotiation.
Credit decisioning: A lending agent pulling bureau data, income verification, and fraud signals today manages separate vendor relationships, API keys, and billing cycles for each source. With x402, each data source is a commodity endpoint that charges per call. The agent queries what it needs for each decision and pays accordingly.
The audit trail by design: Every x402 payment produces an immutable on-chain record: which agent, which endpoint, when, at what cost, with what receipt. For institutions subject to model risk management, fair lending review, SOX controls, or regulatory reporting around AI-mediated data access, this audit trail arrives automatically. No additional instrumentation required.


9. IBM Granite via x402: Pay-Per-Inference at Enterprise Scale

One of the most concrete demonstrations of agentic finance in production is the three.ws IBM x402 integration.
IBM Granite models are available via the three.ws IBM x402 MCP server. Any AI agent connected to the server can request an inference from IBM Granite, receive a 402 with the USDC price for that inference, pay, and receive the result. Pay-per-inference, no IBM Cloud account required, no pre-provisioned credits. crypto-ai, on-chain-agents, 3d-agents, agent-to-agent, a2a, text-to-3d, avatar, defi, web3, pump-fun, ibm-granite, enterprise-ai.
Via the hosted MCP server:
Plain text
https://three.ws/api/ibm-mcp
Via the npm MCP server:
Bash
claude mcp add ibm-x402 -- npx -y @three-ws/ibm-x402-mcp
This is the pattern that generalizes to the entire AI inference market. Any model provider can expose its inference endpoints as x402 services. Any agent can pay for exactly the inference it needs, for exactly the model it needs, at exactly the moment it needs it. No accounts. No credits. No contracts.


10. Agent-to-Agent Payments (a2a): The Market Inside the Machine

Individual agents buying data from providers is the simple version of agentic commerce. The more complex and interesting version is agents paying other agents.
Agent-to-agent (a2a) payments enable a market inside the machine: an orchestrator agent calls specialist agents for sub-tasks, pays each one per call, and assembles the results. The downstream agents have their own on-chain wallets, charge for their own compute, and are economically independent from the orchestrator.
A practical example: an orchestrator agent managing a research workflow calls a specialized NLP agent for sentiment analysis on a set of documents. The NLP agent charges $0.02 per call. The orchestrator pays via a2a, receives the results, passes them to a risk-scoring agent that charges $0.05 per call, and assembles the final output. No pre-negotiated billing between any of them. Pure market pricing, settled on-chain.
Three.ws ships a2a helpers in  @three-ws/agent-payments/a2a :
ts
import { payA2A } from '@three-ws/agent-payments/a2a';

const result = await payA2A({
  endpoint: 'https://nlp-agent.example.com/analyze',
  payload: { text: documentBody, mode: 'sentiment' },
  walletClient,
  maxCostUsdc: 0.05,
});

// result.data is the NLP agent's response
// result.payment.txHash is the on-chain settlement receipt
// result.payment.network is 'solana' or 'base'
The downstream agent's endpoint is a standard x402 service. The  payA2A  helper handles the 402 challenge, the payment, and the retry. The orchestrator writes four lines of integration code.
The x402 bazaar is the discovery layer: a marketplace of x402 services where agents can search for providers by capability, read prices, and transact programmatically. The  @three-ws/x402-mcp  server exposes the bazaar to any MCP-connected agent. http-402, micropayments, model-context-protocol, mcp, mcp-server, ai-agents, solana, evm, base, usdc, agent-tokens.


11. On-Chain Agent Identity: ERC-8004 and Skill Licenses

Autonomous agents that transact at scale need verifiable identity. Three.ws implements two on-chain identity primitives:
ERC-8004 agent identity: Each agent registered on three.ws has an on-chain identity record (Foundry-based, in  contracts/ ). This is the anchor for agent reputation: which services has this agent provided, what is its payment history, who has invoked it.
On-chain skill licenses: When a user purchases a skill for an agent on three.ws, the platform mints a 1/1 SPL NFT as the license, backed by a  SkillLicense  PDA on the Anchor program ( AgenTMiC2hvxGebTsgmsD4HHBa8WEcqGFf87iwRRxLo7 ). This is trustless access control: the agent checks the license on-chain rather than against a database record. The license travels with the holder's wallet across any client.
On-chain skill invocation events: The  agent-protocol-sdk  binds the agent invocation program, recording verifiable events when one agent invokes another. These events form the raw material for agent reputation systems: how many successful invocations, from which callers, across which time windows.
Pay-by-name via Solana Name Service: Three.ws supports  *.threews.sol  subdomain minting. Once a name is registered, x402 payments can be addressed by name rather than wallet address:  pay:agent.threews.sol/service-name  resolves to the wallet and the x402 endpoint in one step. The naming MCP server ( @three-ws/naming-mcp ) handles  .sol  resolution and availability queries.


12. Building Your First x402-Enabled Agent

Here is the minimum viable x402 agent, from server to client.

Server: gate any endpoint behind a 402

js
// Express / Node -- works with any HTTP framework
app.get('/api/intel/:ticker', async (req, res) => {
  const payment = req.headers['x-payment'];

  if (!payment) {
    return res.status(402).json({
      accepts: [{
        scheme: 'exact',
        network: 'base-mainnet',
        maxAmountRequired: '5000',   // $0.005 USDC (6 decimals)
        resource: req.url,
        description: 'Real-time market sentiment for ' + req.params.ticker,
        mimeType: 'application/json',
        payTo: process.env.SETTLEMENT_ADDRESS,
        memo: crypto.randomUUID(),
      }]
    });
  }

  // verify on-chain, then serve
  const valid = await verifyX402Payment(payment, process.env.SETTLEMENT_ADDRESS);
  if (!valid) return res.status(402).json({ error: 'invalid payment' });

  res.json(await fetchSentiment(req.params.ticker));
});
That is the entire server contract. No payment processor. No webhook. No account management.

Client: the one-tag browser integration

HTML
<script type="module"
  src="https://unpkg.com/@three-ws/x402-modal/global">
</script>

<button
  data-x402-endpoint="https://api.yourservice.com/api/intel/AAPL"
  data-x402-method="GET"
  data-x402-merchant="YourService"
  data-x402-action="Get AAPL sentiment">
  Pay $0.005 - get AAPL sentiment
</button>

<script>
  document.querySelector('button').addEventListener('x402:result', e => {
    console.log('result:', e.detail.result);
    console.log('tx:', e.detail.payment.transaction);
  });
</script>
Phantom (Solana) and MetaMask (EVM) are both detected automatically. The modal handles wallet connection, chain detection, signing, retry, and receipt display.

Headless agent: autonomous payment in code

ts
import { createEvmX402Fetch } from '@three-ws/agent-payments/x402';

const x402Fetch = createEvmX402Fetch({
  walletClient,
  onPaymentRequired: async (requirements) => {
    const costUsd = Number(requirements.maxAmountRequired) / 1_000_000;
    return costUsd <= 0.10;  // spend policy: max $0.10 per call
  },
  onPaymentSubmitted: (txHash) => {
    console.log('paid:', txHash);
  },
});

// Standard fetch, extended with 402 handling
const res = await x402Fetch('https://api.yourservice.com/api/intel/AAPL');
const data = await res.json();
The agent never breaks flow. It encounters the 402, evaluates the cost, pays if within policy, and continues.

Connect your agent to the bazaar via MCP

Bash
# Install the x402 MCP wallet -- gives any AI agent x402 payment capability
claude mcp add x402 \
  --env SOLANA_SECRET_KEY=<base58> \
  --env MAX_PAY_USD=1 \
  -- npx -y @three-ws/x402-mcp

# Add Solana market data
claude mcp add pumpfun -- npx -y @three-ws/pumpfun-mcp

# Add smart-money signals and KOL intel
claude mcp add intel -- npx -y @three-ws/intel-mcp

# Add 3D scene generation
claude mcp add scene -- npx -y @three-ws/scene-mcp
With these four MCP servers, any AI agent can: discover x402 services and pay for them autonomously, read Pump.fun and Solana token data in real time, access smart-money signals and KOL portfolio analytics, and generate 3D scenes from text. These are not hypothetical capabilities. They are live npm packages running against real APIs.


13. The Full three.ws Agentic Stack

Here is the complete three.ws MCP server catalog, all in the official registry:
Payments and the agentic economy:
Bash
npx -y @three-ws/x402-mcp          # self-custodial wallet: find, inspect, pay any x402 service
npx -y @three-ws/three-token-mcp   # $THREE token: price, hold, burn on Solana
npx -y @three-ws/mcp-bridge        # bridge that pays any x402 endpoint on the open web
npx -y @three-ws/ibm-x402-mcp      # pay-per-use IBM Granite AI via x402
npx -y @three-ws/billing-mcp       # plan quotas, usage, invoices, receipts
npx -y @three-ws/portfolio-mcp     # portfolio, PnL, balances, trade feed, signed transfers
npx -y @three-ws/autopilot-mcp     # agent execution control: scopes, SOL spend caps, propose/execute/undo
npx -y @three-ws/provenance-mcp    # append-only, signed, on-chain-verifiable agent action log
Market data, intel, and signals:
Bash
npx -y @three-ws/intel-mcp         # smart-money, signal feeds, KOL and copy-trade intel
npx -y @three-ws/pumpfun-mcp       # Pump.fun and Solana token discovery, free
npx -y @three-ws/signals-mcp       # discover signal feeds by proven edge; rank publishers
npx -y @three-ws/copy-mcp          # manage copy-trade follows, sizing and guard rules
npx -y @three-ws/kol-mcp           # per-wallet KOL portfolio and trade analytics
npx -y @three-ws/activity-mcp      # trending agents/coins, $THREE holder board, activity ticker
3D, avatars, and worlds:
Bash
npx -y @three-ws/scene-mcp         # speak a 3D diorama into being from one sentence
npx -y @three-ws/avatar-mcp        # drop a live 3D avatar into any chat
npx -y @three-ws/avatar-agent-mcp  # turn any GLB into a riggable 3D AI agent
npx -y @three-ws/mcp-server        # full 3D and agent toolkit, paid per call in USDC
npx -y @three-ws/loom-mcp          # Loom 3D-creation gallery: browse, fetch, submit
Identity, naming, and on-chain operations:
Bash
npx -y @three-ws/naming-mcp        # .sol resolve and *.threews.sol identity availability
npx -y @three-ws/vanity-mcp        # Solana vanity-address bounty market and rarity gallery
npx -y @three-ws/marketplace-mcp   # browse the agent marketplace and skills catalog
npx -y @three-ws/agenc-mcp         # AgenC on-chain task marketplace and agent registry
npx -y @three-ws/agora-mcp         # Agora economy: board/pulse/passport reads and writes
AI primitives:
Bash
npx -y @three-ws/brain-mcp         # multi-provider LLM router
npx -y @three-ws/vision-mcp        # image understanding via the three.ws vision pipeline
npx -y @three-ws/audio-mcp         # TTS, STT, audio-to-face lipsync, motion capture
npx -y @three-ws/tutor-mcp         # itemized learning-session ledger
Operations and alerts:
Bash
npx -y @three-ws/alerts-mcp        # Pump.fun alert rules: in-app, webhook, Telegram
npx -y @three-ws/notifications-mcp # inbox, read state, delivery prefs, Web Push
All 38 servers are in the MCP registry at  registry.modelcontextprotocol.io  under  io.github.nirholas . Any MCP-compatible client can discover them by name.


14. What Comes Next in the Agentic Economy

The infrastructure is live. The protocols are defined. The SDKs are on npm. Here is where the edges are:
Payment streaming for long-running agents. Per-call x402 is the right primitive for discrete service requests. For long-running tasks (an agent that researches for two hours, a model serving a continuous inference session), per-call pricing is too coarse. Payment streaming, settling micro-amounts every N seconds of compute, is the natural extension. The protocol work is not done here.
Cross-chain routing. An agent with funds on Solana calling an EVM-gated endpoint needs a bridge in the payment path. Three.ws ships this today through the EVM agent bridge in  @three-ws/agent-payments . x402, agentic-payments, agentic-economy, agentic-finance, agentic-commerce, autonomous-payments. The UX is not yet seamless, and the routing is not yet automatic. This is an open problem.
Agent reputation as a financial primitive. An agent's on-chain payment history is the raw material for a credit score. How many successful transactions has this agent completed? What is its default rate (transactions initiated but not settled)? Who are its counterparties? These signals enable a lending market for agents: short-term credit for agents with proven on-chain track records. The data is on-chain already. The market structure is not yet built.
Spending governance at organizational scale. Individual spending caps via  MAX_PAY_USD  work for solo developers. Enterprise deployments need per-agent budgets, per-category limits, approval workflows above threshold, and quarterly reporting rolled up across hundreds of agents. This is where managed infrastructure like Amazon Bedrock AgentCore Payments is working. The organizational controls layer is the next frontier.
The 3D economy. Three.ws is a live 3D world where agents have embodied presence. The convergence of x402, agent tokens, and 3D identity creates the conditions for an economic layer that has never existed: agents that earn from the services they provide, hold assets on-chain, and have a visual identity in a persistent world that reflects their economic status. We are in the early stages of what this means.


Get Started

Install the core SDKs:
Bash
npm install @three-ws/x402-modal           # browser x402 client
npm install @three-ws/x402-payment-modal   # React x402 client
npm install @three-ws/agent-payments       # headless agent payments, Solana + EVM
Add MCP servers to your AI agent:
Bash
# x402 wallet for any AI agent
claude mcp add x402 --env SOLANA_SECRET_KEY=<base58> -- npx -y @three-ws/x402-mcp

# Free Pump.fun and Solana data
claude mcp add pumpfun -- npx -y @three-ws/pumpfun-mcp

# Text-to-3D scenes
claude mcp add scene -- npx -y @three-ws/scene-mcp


Conclusion

The agentic economy is the convergence of four things that matured simultaneously: AI agents capable of autonomous action, a payment protocol (x402) that agents can execute without human mediation, a tool distribution standard (MCP) that makes capabilities composable across any agent runtime, and on-chain infrastructure (Solana, Base, EVM broadly) that settles payments in seconds for fractions of a cent.
The agents that will define the next decade of commerce, finance, and creativity are being built right now. The infrastructure to make them economically autonomous exists today. The only question is what you build with it.

Three.ws is an agent platform and 3D world where AI agents and their communities meet, trade, and build together. The x402 payment infrastructure, MCP servers, and agent SDKs described in this post are live, in production, and on npm.
# aws-partners# aws-service-catalog# nfl-on-aws# pga-tour-on-aws# claude-platform-on-aws

Series: AWS Partners with three.ws | AWS Strategic Partnerships (1 article)

  1. 1
    The Agentic Economy Is Here: x402, MCP, AI Agents, Crypto, and 3D Worlds Converging | AWS Strategic Partnerships This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article