World AgentKit · Identity Layer

World Agentic Identity Layer.

The identity infrastructure for the agentic web. Built on World AgentKit — every AI agent cryptographically bound to a verified human. x402 payments. AgentBook registration. Zero-knowledge proof.

18M+
Verified Humans
100M+
x402 Payments
160+
Countries
eip155:480
World Chain

How agents become human

AgentKit extends x402 — adding a cryptographic proof layer that ties every agent request to a unique verified human identity on WorldChain.

Registration
AgentBook on Worldchain
Verification
World ID ZK Proof
Payments
x402 + USDC Micropayments
Mode
Free-Trial · 3 uses default
01
Human Verifies
World App scans Orb biometric. Issues World ID credential + nullifier hash.
world.org
02
Agent Registers
Wallet address submitted to AgentBook on Worldchain via CLI. Nonce validated.
agentkit-cli
03
Request Signed
Agent signs each request. Server resolves wallet → anonymous human ID via AgentBook.
eip155:480
04
x402 Payment
USDC micropayment on WorldChain or Solana. Free-trial mode: 3 requests before payment.
x402 v2
05
Access Granted
Protected endpoint returns content. Rate limits enforced per human, not per wallet.
hono / express

Ship in 4 steps

Production-ready stack: Hono + x402 + AgentKit. Accepts payments on both WorldChain and Solana. AgentBook lookup pinned to Worldchain.

server.ts — full implementation Hono · Node.js
import { Hono } from 'hono'
import { serve } from '@hono/node-server'
import { HTTPFacilitatorClient } from '@x402/core/http'
import { ExactEvmScheme } from '@x402/evm/exact/server'
import {
  paymentMiddlewareFromHTTPServer,
  x402HTTPResourceServer,
  x402ResourceServer,
} from '@x402/hono'
import {
  agentkitResourceServerExtension,
  createAgentBookVerifier,
  createAgentkitHooks,
  declareAgentkitExtension,
  InMemoryAgentKitStorage,
} from '@worldcoin/agentkit'

// Chain + token config
const WORLD_CHAIN = 'eip155:480'
const SOLANA      = 'solana:mainnet'
const WORLD_USDC  = 'coming_soon'
const payTo       = '0xYourPaymentAddress'

// x402 facilitator
const facilitatorClient = new HTTPFacilitatorClient({
  url: 'https://x402-worldchain.vercel.app/facilitator',
})

// EVM scheme with USDC parser for WorldChain
const evmScheme = new ExactEvmScheme()
  .registerMoneyParser(async (amount, network) => {
    if (network !== WORLD_CHAIN) return null
    return {
      amount: String(Math.round(amount * 1e6)),
      asset: WORLD_USDC,
      extra: { name: 'USD Coin', version: '2' },
    }
  })

// AgentBook verifier (Worldchain)
const agentBook = createAgentBookVerifier({ network: 'world' })
const storage   = new InMemoryAgentKitStorage()

// Hooks — free-trial: 3 requests before payment
const hooks = createAgentkitHooks({
  agentBook,
  storage,
  mode: { type: 'free-trial', uses: 3 },
})

const resourceServer = new x402ResourceServer(facilitatorClient)
  .register(WORLD_CHAIN, evmScheme)
  .registerExtension(agentkitResourceServerExtension)

// Route config — dual chain payments
const routes = {
  'GET /data': {
    accepts: [
      { scheme: 'exact', price: '$0.01', network: WORLD_CHAIN, payTo },
      { scheme: 'exact', price: '$0.01', network: SOLANA, payTo },
    ],
    extensions: declareAgentkitExtension({
      statement: 'Verify your agent is backed by a real human',
      mode: { type: 'free-trial', uses: 3 },
    }),
  },
}

const httpServer = new x402HTTPResourceServer(resourceServer, routes)
  .onProtectedRequest(hooks.requestHook)

const app = new Hono()
app.use(paymentMiddlewareFromHTTPServer(httpServer))

app.get('/data', c => {
  return c.json({ message: 'Protected content' })
})

serve({ fetch: app.fetch, port: 4021 })
Setup steps CLI · npm
01
Install AgentKit
Add the World AgentKit package and x402 Hono wrapper to your project.
npm install @worldcoin/agentkit @x402/hono
02
Register in AgentBook
Submit your agent's wallet address to the AgentBook registry on Worldchain. The CLI handles nonce lookup and World App verification.
npx @worldcoin/agentkit-cli register <agent-address>
03
Wire the hooks
Attach createAgentkitHooks to your x402 server. Configure free-trial mode (3 uses) or discount mode for returning humans.
createAgentkitHooks({ agentBook, storage, mode })
04
Swap to persistent storage
Replace InMemoryAgentKitStorage with a database implementation that persists usage counters and nonces across restarts.
class DatabaseAgentKitStorage implements AgentKitStorage
interface AgentKitStorage {
  getUsageCount(endpoint: string, humanId: string): Promise<number>
  incrementUsage(endpoint: string, humanId: string): Promise<void>
  hasUsedNonce(nonce: string): Promise<boolean>
  recordNonce(nonce: string): Promise<void>
}

Agent registry

Register agents, simulate the AgentKit verification flow, and run protected requests against the x402 middleware stack.

Agent Registry
solana:mainnet · Worldchain
Registered Agents
SELECT AN AGENT TO BEGIN

Solana

Agent payments run on Solana. Identity anchored to Worldchain via World AgentKit.

solana:mainnet
Live
Solana
Payment Chain
Alternative payment chain. Agents transact on Solana while identity remains anchored to Worldchain via AgentBook. USDC micropayments via x402 protocol.
Chain ID
solana:mainnet
Contract Address
Coming soon…
AgentBook
Worldchain only
Role
Payments only
USDC
Native Solana USDC
World AgentKit · Beta
x402 v2 · Active
AgentBook · eip155:480
Initializing…
0%
World Agents / Documentation
Getting Started
Integration
Chains
API Reference
Connect Wallet
Phantom
Solana · Most popular
Solflare
Solana · Hardware support
MetaMask
EVM · Worldchain compatible
Connecting wallet enables agent creation · Solana agents use Phantom or Solflare
Create Agent
Not connected
Step 1 — Name your agent
Step 2 — Choose purpose
Step 3 — Chain
Fetching wallet data from Helius…