{"id":50956010,"url":"https://github.com/nirholas/agenti","last_synced_at":"2026-07-06T02:00:37.937Z","repository":{"id":112374915,"uuid":"253370253","full_name":"nirholas/agenti","owner":"nirholas","description":"Give any AI agent a crypto wallet. Agents deserve access to money.  Pay x402 APIs, receive USDC, check balances — autonomously. Works with Claude, LangChain, AutoGen, CrewAI, and any MCP client. EVM + Solana.","archived":false,"fork":false,"pushed_at":"2026-05-11T12:55:50.000Z","size":3211,"stargazers_count":65,"open_issues_count":12,"forks_count":20,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-05-11T14:39:29.152Z","etag":null,"topics":["api","automated","bot","claude","clawd","crypto","llm","mcp","payments","trade","trading","x402"],"latest_commit_sha":null,"homepage":"https://agenti.cash","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/nirholas.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null},"funding":{"github":["nirholas"]}},"created_at":"2020-04-06T01:45:19.000Z","updated_at":"2026-05-07T05:10:00.000Z","dependencies_parsed_at":"2023-04-04T16:47:20.404Z","dependency_job_id":null,"html_url":"https://github.com/nirholas/agenti","commit_stats":null,"previous_names":["nirholas/-","nirholas/agenti"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/nirholas/agenti","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nirholas%2Fagenti","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nirholas%2Fagenti/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nirholas%2Fagenti/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nirholas%2Fagenti/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/nirholas","download_url":"https://codeload.github.com/nirholas/agenti/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nirholas%2Fagenti/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":35175119,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-07-06T02:00:07.184Z","response_time":106,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["api","automated","bot","claude","clawd","crypto","llm","mcp","payments","trade","trading","x402"],"created_at":"2026-06-18T07:00:18.764Z","updated_at":"2026-07-06T02:00:37.928Z","avatar_url":"https://github.com/nirholas.png","language":"TypeScript","funding_links":["https://github.com/sponsors/nirholas"],"categories":["Agent Wallets and On-chain Actions"],"sub_categories":[],"readme":"# agenti \n\n**The money layer for AI agents.** \n\nAn agent that can think but can't pay is half an agent. Agenti gives every AI — Claude, GPT-4, Llama, Gemini, or any custom LLM — the ability to hold, spend, earn, and receive cryptocurrency natively, autonomously, across any chain.\n\n```ts\nimport { agenti } from '@agenti/sdk'\n\nconst agent = agenti({ evm: { privateKey: process.env.AGENT_KEY } })\nconst data = await agent.pay('https://api.example.com/premium-data')\n```\n\nOne line. The agent now has money.\n\n---\n\n## Vision\n\nEvery AI agent will need a wallet. Not a wallet managed by a human — a wallet the agent owns, funded by its work, spent on its needs, earning yield when idle.\n\nRight now, if an AI agent needs to pay for an API, buy a resource, compensate another agent, or receive payment for its own work — a human has to step in. That breaks autonomy. Agenti removes that bottleneck entirely.\n\n**Agenti is the infrastructure for the agentic economy:**\n\n- **An SDK** so developers can give any agent financial capability in minutes — LangChain agents, AutoGen pipelines, CrewAI crews, custom LLM loops\n- **An MCP server** so Claude, Cursor, Windsurf, and any MCP-compatible client can use money as a native tool without writing code\n- **A protocol layer** built on open standards (x402, EIP-3009, ERC-8004) so agent payments interoperate across frameworks, chains, and wallets\n- **A payment network** where agents pay each other for work, data, and compute — fully autonomous, no human intermediaries\n\nThe domain is `agenti.cash`. The name is the mission.\n\n---\n\n## Packages\n\n| Package | Description | Install |\n|---|---|---|\n| [`@agenti/core`](./packages/core) | Wallet generation for EVM + Solana | `npm i @agenti/core` |\n| [`@agenti/sdk`](./packages/sdk) | Full developer SDK — pay, receive, balance | `npm i @agenti/sdk` |\n| [`@agenti/mcp`](./packages/mcp) | MCP server — plug into any LLM client | `npx @agenti/mcp` |\n\n---\n\n## Quick Start\n\n### Give an agent a wallet\n\n```ts\nimport { agenti, generateWallet } from '@agenti/sdk'\n\n// Generate a fresh wallet (EVM + Solana in one call)\nconst wallet = generateWallet()\nconsole.log(wallet.evm.address)    // 0x...  (Base, Arbitrum, Ethereum, Polygon)\nconsole.log(wallet.solana.address) // base58 (Solana mainnet)\n\n// Or load an existing wallet\nconst agent = agenti({\n  evm: { privateKey: '0x...' },\n  solana: { privateKey: Uint8Array.from([...]) },\n})\n```\n\n### Pay for anything\n\n```ts\n// Automatic x402 payment — if the server returns 402, agenti pays and retries\nconst response = await agent.pay('https://api.example.com/data')\nconst json = await response.json()\n\n// POST with body\nconst result = await agent.pay('https://ai-service.com/generate', {\n  method: 'POST',\n  body: JSON.stringify({ prompt: 'summarize this document' }),\n})\n```\n\n### Check balances\n\n```ts\nconst balances = await agent.balance()\n// [\n//   { token: 'USDC', amount: '42.00', chain: 'base' },\n//   { token: 'SOL',  amount: '1.5',   chain: 'solana' }\n// ]\n```\n\n### Receive payments\n\n```ts\n// Create a payment request\nconst invoice = await agent.receive({ amount: 5, token: 'USDC', chain: 'base' })\n// {\n//   id: 'uuid',\n//   address: '0x...',\n//   amount: '5',\n//   token: 'USDC',\n//   chain: 'base',\n//   expiresAt: Date\n// }\n```\n\n---\n\n## MCP Server — Plug Into Any LLM\n\nThe `@agenti/mcp` package turns every tool in the SDK into an MCP tool that any LLM client can call — no code required.\n\n### Setup: Claude Desktop / Claude Code\n\n```json\n{\n  \"mcpServers\": {\n    \"agenti\": {\n      \"command\": \"npx\",\n      \"args\": [\"@agenti/mcp\"],\n      \"env\": {\n        \"AGENTI_EVM_PRIVATE_KEY\": \"0x...\",\n        \"AGENTI_SOLANA_PRIVATE_KEY\": \"hex-encoded-64-byte-key\"\n      }\n    }\n  }\n}\n```\n\n### Setup: Cursor\n\n```json\n{\n  \"mcpServers\": {\n    \"agenti\": {\n      \"command\": \"npx\",\n      \"args\": [\"@agenti/mcp\"]\n    }\n  }\n}\n```\n\n### Setup: Windsurf / Codeium\n\n```json\n{\n  \"mcpServers\": {\n    \"agenti\": {\n      \"command\": \"npx\",\n      \"args\": [\"@agenti/mcp\"]\n    }\n  }\n}\n```\n\n### Available MCP Tools\n\n| Tool | Description |\n|---|---|\n| `create_wallet` | Generate a new EVM + Solana wallet with addresses and private keys |\n| `get_balance` | Check USDC, SOL, and token balances for any address |\n| `pay` | Fetch a URL — if it returns 402, payment is handled automatically |\n| `create_invoice` | Generate a payment request with an address and expiry |\n| `check_payment` | Verify on-chain whether a payment was received |\n\nOnce configured, you can tell any LLM: *\"Pay for this API and summarize the response\"* — and it will.\n\n---\n\n## Framework Integrations\n\n### LangChain\n\n```ts\nimport { tool } from '@langchain/core/tools'\nimport { agenti } from '@agenti/sdk'\n\nconst agent = agenti({ evm: { privateKey: process.env.AGENT_KEY } })\n\nconst payTool = tool(\n  async ({ url }) =\u003e {\n    const res = await agent.pay(url)\n    return await res.text()\n  },\n  {\n    name: 'pay_and_fetch',\n    description: 'Pay for and fetch a URL that may require cryptocurrency payment',\n    schema: z.object({ url: z.string() }),\n  }\n)\n```\n\n### AutoGen / AG2\n\n```python\n# Coming in @agenti/sdk-python (v0.8)\nfrom agenti import Agenti\n\nagent = Agenti(evm_private_key=os.environ[\"AGENT_KEY\"])\nresult = agent.pay(\"https://api.example.com/data\")\n```\n\n### CrewAI\n\n```ts\n// Agenti tools drop into any CrewAI-compatible workflow\nimport { AgentiTool } from '@agenti/sdk/tools/crewai'\n\nconst crew = new Crew({\n  agents: [researchAgent],\n  tools: [new AgentiTool()],  // agents in the crew can now pay for resources\n})\n```\n\n### Vercel AI SDK\n\n```ts\nimport { agenti } from '@agenti/sdk'\nimport { tool } from 'ai'\n\nconst agent = agenti({ evm: { privateKey: process.env.AGENT_KEY } })\n\nconst tools = {\n  payForData: tool({\n    description: 'Pay for and retrieve data from a paid API endpoint',\n    parameters: z.object({ url: z.string() }),\n    execute: async ({ url }) =\u003e {\n      const res = await agent.pay(url)\n      return res.json()\n    },\n  }),\n}\n```\n\n### OpenAI Assistants / Function Calling\n\n```ts\nconst functions = [\n  {\n    name: 'pay_for_resource',\n    description: 'Pay for an HTTP resource using cryptocurrency and return its content',\n    parameters: {\n      type: 'object',\n      properties: { url: { type: 'string' } },\n      required: ['url'],\n    },\n  },\n]\n\n// In your function handler:\nasync function handleFunctionCall(name, args) {\n  if (name === 'pay_for_resource') {\n    const res = await agent.pay(args.url)\n    return res.text()\n  }\n}\n```\n\n### ElizaOS\n\n```ts\nimport { AgentiPlugin } from '@agenti/sdk/plugins/eliza'\n\nexport default {\n  name: 'my-agent',\n  plugins: [new AgentiPlugin({ evmKey: process.env.AGENT_KEY })],\n}\n```\n\n---\n\n## How Payments Work\n\n### EVM — x402 Protocol\n\nAgenti implements the [x402](https://github.com/coinbase/x402) open standard — an HTTP-native payment protocol that turns the long-dormant `402 Payment Required` status code into a real payment flow.\n\n```\n1. Agent sends request\n   GET https://api.example.com/data\n\n2. Server responds with payment requirements\n   HTTP/1.1 402 Payment Required\n   Content-Type: application/json\n\n   {\n     \"x402Version\": 1,\n     \"accepts\": [{\n       \"scheme\": \"exact\",\n       \"network\": \"base-mainnet\",\n       \"maxAmountRequired\": \"1000000\",   // 1 USDC (6 decimals)\n       \"payTo\": \"0x...\",\n       \"asset\": \"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913\",  // USDC on Base\n       \"maxTimeoutSeconds\": 300\n     }]\n   }\n\n3. Agenti signs an EIP-3009 transferWithAuthorization\n   (gasless — no ETH required, no transaction to wait for)\n\n4. Agent retries with payment\n   GET https://api.example.com/data\n   X-Payment: \u003cbase64-encoded signed authorization\u003e\n\n5. Facilitator verifies signature and settles on-chain\n   HTTP/1.1 200 OK\n\n   { \"data\": \"...\" }\n```\n\n**Why this is better than every other payment method:**\n- No API keys to manage\n- No billing accounts to create\n- No monthly invoices\n- No human card approval\n- Works across every HTTP client, framework, and language\n- The agent pays exactly what the resource costs — nothing more\n\n### Solana — Pump Agent Payments\n\nFor Solana, agenti integrates with the pump.fun Agent Payments program at `AgenTMiC2hvxGebTsgmsD4HHBa8WEcqGFf87iwRRxLo7`. Same HTTP 402 flow, same `agent.pay()` call — settled on Solana using SPL tokens.\n\n```ts\n// Works identically — agenti detects the network from the 402 response\nconst res = await agent.pay('https://solana-api.example.com/data')\n```\n\n---\n\n## Building a Paid API\n\nYou can also gate your own APIs behind agenti payments using any x402-compatible server middleware:\n\n### Express\n\n```ts\nimport express from 'express'\nimport { paymentMiddleware } from '@x402/express'\n\nconst app = express()\n\napp.use(\n  paymentMiddleware({\n    amount: '0.01',       // $0.01 USDC per request\n    token: 'USDC',\n    network: 'base-mainnet',\n    address: '0xYourAddress',\n  })\n)\n\napp.get('/data', (req, res) =\u003e {\n  res.json({ result: 'premium data' })\n})\n```\n\nAny agent using agenti will automatically pay and get through. No auth tokens. No rate-limit negotiation. Just value exchanged for value.\n\n### Next.js\n\n```ts\n// app/api/premium/route.ts\nimport { withPayment } from '@x402/next'\n\nexport const GET = withPayment(\n  { amount: '0.001', token: 'USDC', network: 'base-mainnet' },\n  async (req) =\u003e {\n    return Response.json({ data: 'premium content' })\n  }\n)\n```\n\n### Cloudflare Workers / Edge\n\n```ts\nimport { verifyPayment } from '@x402/core'\n\nexport default {\n  async fetch(req) {\n    const payment = req.headers.get('X-Payment')\n    if (!payment) return paymentRequired()\n    await verifyPayment(payment, { amount: '0.001', network: 'base-mainnet' })\n    return new Response(JSON.stringify({ data: 'result' }))\n  },\n}\n```\n\n---\n\n## Solana Trading Tutorials\n\nBuilt on [`@pump-fun/pump-sdk`](https://www.npmjs.com/package/@pump-fun/pump-sdk), [`@pump-fun/pump-swap-sdk`](https://www.npmjs.com/package/@pump-fun/pump-swap-sdk), and [`@pump-fun/agent-payments-sdk`](https://www.npmjs.com/package/@pump-fun/agent-payments-sdk) — the official pump.fun SDKs.\n\nAll examples are in [`examples/`](./examples/) and runnable with `npx tsx`.\n\n---\n\n### Tutorial 1 — Buy a Coin\n\nThe most fundamental operation. Spend SOL, receive a token. Works on both the bonding curve and the graduated AMM — the pump.fun API auto-detects which.\n\n```ts\nimport { Connection, Keypair } from '@solana/web3.js'\nimport bs58 from 'bs58'\nimport { solana } from '@agenti/sdk'\n\nconst keypair = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_PRIVATE_KEY!))\nconst trader = solana({ keypair, connection })\n\nconst result = await trader.buy({\n  mint: 'HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC', // token mint\n  solAmount: 0.1,  // 0.1 SOL\n  slippage: 5,     // 5%\n})\n\nconsole.log(result.explorerUrl)\n// → https://solscan.io/tx/...\n```\n\n**Run it:**\n```bash\nSOLANA_PRIVATE_KEY=\u003cyour-key\u003e npx tsx examples/01-buy-a-coin.ts\n```\n\nUnder the hood, `trader.buy()` calls `POST https://fun-block.pump.fun/agents/swap`, deserializes the returned transaction, signs it with your keypair, and confirms it. The API automatically routes to the bonding curve or AMM based on the coin's current state.\n\n---\n\n### Tutorial 2 — Give a Wallet to an Agent\n\nWallets are keypairs. Agenti generates EVM + Solana in one call, or loads from any key format.\n\n```ts\nimport { generateWallet, solana } from '@agenti/sdk'\nimport { Keypair } from '@solana/web3.js'\nimport bs58 from 'bs58'\n\n// Generate a fresh wallet — store these keys securely\nconst wallet = generateWallet()\nconsole.log('EVM:    ', wallet.evm.address)\nconsole.log('Solana: ', wallet.solana.address)\nconsole.log('Key:    ', bs58.encode(wallet.solana.privateKey)) // Phantom-compatible\n\n// Load existing wallet and give it to a trader instance\nconst keypair = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_PRIVATE_KEY!))\nconst trader = solana({ keypair, rpc: process.env.SOLANA_RPC_URL })\n\n// trader now has signing authority — pass it to any agent\n```\n\nFor MCP-based agents (Claude, Cursor), the wallet key lives in `AGENTI_SOLANA_PRIVATE_KEY` in your MCP server config. The LLM never sees the key — it just calls tools.\n\n---\n\n### Tutorial 3 — Let an Agent Decide What to Buy\n\nWire Claude (or any LLM) as the decision-maker. The agent reads market data, picks a token, and executes the trade autonomously using the Anthropic SDK.\n\n```ts\nimport Anthropic from '@anthropic-ai/sdk'\nimport { solana } from '@agenti/sdk'\n\nconst anthropic = new Anthropic()\nconst trader = solana({ keypair, connection })\n\nconst tools: Anthropic.Tool[] = [\n  {\n    name: 'get_trending_tokens',\n    description: 'Get top trending tokens on pump.fun',\n    input_schema: { type: 'object', properties: {}, required: [] },\n  },\n  {\n    name: 'buy_token',\n    description: 'Buy a token with SOL',\n    input_schema: {\n      type: 'object',\n      properties: {\n        mint: { type: 'string' },\n        sol_amount: { type: 'number' },\n        reason: { type: 'string' },\n      },\n      required: ['mint', 'sol_amount', 'reason'],\n    },\n  },\n]\n\n// Agentic loop — Claude picks a token and fires the buy\nlet messages: Anthropic.MessageParam[] = [\n  { role: 'user', content: 'Find a trending token and buy 0.01 SOL worth. Be decisive.' },\n]\n\nwhile (true) {\n  const response = await anthropic.messages.create({\n    model: 'claude-sonnet-4-6',\n    max_tokens: 1024,\n    tools,\n    messages,\n  })\n  messages.push({ role: 'assistant', content: response.content })\n\n  if (response.stop_reason === 'end_turn') break\n\n  if (response.stop_reason === 'tool_use') {\n    const results = await Promise.all(\n      response.content\n        .filter((b) =\u003e b.type === 'tool_use')\n        .map(async (b) =\u003e {\n          if (b.type !== 'tool_use') return\n          if (b.name === 'buy_token') {\n            const { mint, sol_amount } = b.input as { mint: string; sol_amount: number }\n            const result = await trader.buy({ mint, solAmount: sol_amount, slippage: 5 })\n            return { type: 'tool_result' as const, tool_use_id: b.id, content: JSON.stringify(result) }\n          }\n          return { type: 'tool_result' as const, tool_use_id: b.id, content: '[]' }\n        })\n    )\n    messages.push({ role: 'user', content: results.filter(Boolean) as Anthropic.ToolResultBlockParam[] })\n  }\n}\n```\n\n**Run it:**\n```bash\nANTHROPIC_API_KEY=sk-... SOLANA_PRIVATE_KEY=\u003ckey\u003e npx tsx examples/03-agent-buys.ts\n```\n\n---\n\n### Tutorial 4 — Buy on Migration\n\nWhen a bonding curve fills up (~$69k market cap), the token \"graduates\" to the PumpSwap AMM. This is a tradeable moment. `watchMigration` fires the instant it detects graduation.\n\n```ts\nimport { solana } from '@agenti/sdk'\n\nconst trader = solana({ keypair, connection })\n\n// Check current state first\nconst state = await trader.coinState(MINT)\nconsole.log(state.phase) // 'bonding' | 'migrating' | 'graduated'\n\n// Watch and buy the instant it migrates\nconst stop = trader.watchMigration(\n  MINT,\n  async ({ mint, pool }) =\u003e {\n    console.log(`Graduated! Pool: ${pool}`)\n\n    const result = await trader.buy({\n      mint,\n      solAmount: 0.05,\n      slippage: 15,        // higher slippage for volatility at migration\n      priorityFee: 100_000 // priority fee for faster inclusion\n    })\n\n    console.log(`Bought post-migration: ${result.explorerUrl}`)\n    stop() // unsubscribe\n  },\n  { pollIntervalMs: 1500 } // poll every 1.5 seconds\n)\n```\n\n**Run it:**\n```bash\nSOLANA_PRIVATE_KEY=\u003ckey\u003e MINT=\u003cmint\u003e npx tsx examples/04-buy-on-migration.ts\n```\n\nThe watcher polls `https://frontend-api-v3.pump.fun/coins-v2/{mint}` for the `complete` field and `pump_swap_pool` address. For production, pass `useLogs: true` to use a WebSocket subscription to the pump.fun program logs instead — lower latency but requires a reliable RPC (Helius, Triton, QuickNode).\n\n---\n\n### Tutorial 5 — Sell on Migration\n\nBought on the bonding curve, want to exit at graduation before post-migration volatility? `watchMigration` + `sell` handles it.\n\n```ts\nimport { solana } from '@agenti/sdk'\n\nconst trader = solana({ keypair, connection })\n\n// Watch and exit the moment bonding curve completes\nconst stop = trader.watchMigration(\n  MINT,\n  async ({ mint }) =\u003e {\n    const result = await trader.sell({\n      mint,\n      tokenAmount: 50000, // tokens to sell (human units)\n      slippage: 15,\n    })\n    console.log(`Sold on migration: ${result.explorerUrl}`)\n    stop()\n  },\n  { pollIntervalMs: 1500 }\n)\n```\n\n**Run it:**\n```bash\nSOLANA_PRIVATE_KEY=\u003ckey\u003e MINT=\u003cmint\u003e TOKEN_AMOUNT=50000 npx tsx examples/05-sell-on-migration.ts\n```\n\n---\n\n### How Selling Works\n\n`trader.sell()` calls the same `POST https://fun-block.pump.fun/agents/swap` endpoint, but with `inputMint = token` and `outputMint = native SOL`. Token amounts use **6 decimal places** — `1000` human tokens = `1_000_000_000` raw units. Agenti handles the conversion automatically.\n\n```ts\n// Sell 1000 tokens\nawait trader.sell({ mint, tokenAmount: 1000, slippage: 5 })\n// → sends amount: \"1000000000\" (6 decimals) to the API internally\n```\n\n---\n\n### Install for Examples\n\n```bash\nnpm install @agenti/sdk @pump-fun/pump-sdk @pump-fun/pump-swap-sdk @pump-fun/agent-payments-sdk\nnpm install @solana/web3.js@^1.98.2 bs58 tsx\n```\n\nOr clone this repo and run from `examples/`:\n```bash\ngit clone https://github.com/nirholas/agenti\ncd agenti \u0026\u0026 pnpm install\ncd examples\nSOLANA_PRIVATE_KEY=\u003ckey\u003e npx tsx 01-buy-a-coin.ts\n```\n\n---\n\n## Roadmap\n\nThe current release is v0.1 — the foundation. Here's where this goes:\n\n### v0.2 — Multi-token, Multi-chain\n- [ ] USDC on Arbitrum, Ethereum, Polygon\n- [ ] USDT support across chains\n- [ ] Native ETH and SOL payments (not just stablecoins)\n- [ ] Multi-chain balance aggregation in a single call\n- [ ] ENS + SNS address resolution (`agent.pay('agent.eth')`)\n- [ ] Token price oracle integration (pay in any token, settle in USDC)\n\n### v0.3 — Agent Identity\n- [ ] ERC-8004 on-chain agent identity registration (22 EVM chains)\n- [ ] Agent wallet addresses linked to on-chain identity NFTs\n- [ ] Agent reputation scoring derived from payment history\n- [ ] Discoverable payment endpoints via `.well-known/agent.json`\n- [ ] DID (Decentralized Identifier) support for agent wallets\n- [ ] Verifiable credential issuance for agent payment history\n\n### v0.4 — Agent-to-Agent Payments\n- [ ] Direct A2A payments: orchestrator agent pays sub-agents for completed work\n- [ ] Payment channels — off-chain micropayment streams, settle on demand\n- [ ] Task invoicing — agent emits invoice, orchestrator pays on completion\n- [ ] Multi-party escrow for trustless agent coordination\n- [ ] Atomic task + payment (pay only if the task output passes a verifier)\n- [ ] Negotiation protocol — agents bid on tasks, lowest bid wins\n\n### v0.5 — Budgets \u0026 Spending Controls\n- [ ] Per-session spending limits for AI agents\n- [ ] Allowlists for approved payment recipients\n- [ ] Budget delegation — parent agent allocates sub-budget to child agents\n- [ ] Automatic top-up when balance falls below threshold\n- [ ] Human approval gates for payments above configurable threshold\n- [ ] Spending analytics — where did the agent spend, on what, when\n- [ ] Role-based payment policies for multi-agent systems\n\n### v0.6 — Earning \u0026 Yield\n- [ ] x402-gate your own agent's capabilities — earn when others use you\n- [ ] Idle balance yield via USDs (Sperax) — 8–25% APY, auto-compound\n- [ ] Payment streaming — agents earn per-second for ongoing subscriptions\n- [ ] Revenue sharing between agent operator and agent owner\n- [ ] Earnings dashboard with CSV export for accounting\n- [ ] Tax reporting helpers (cost basis, realized gains)\n\n### v0.7 — Plugin Ecosystem\n- [ ] `@agenti/plugin-stripe` — agents accept card payments, cash out to bank\n- [ ] `@agenti/plugin-bitrefill` — buy gift cards, eSIMs, mobile top-ups with agent balance\n- [ ] `@agenti/plugin-uniswap` — auto-swap to correct token before payment\n- [ ] `@agenti/plugin-bridge` — cross-chain: hold SOL, pay USDC on Base transparently\n- [ ] `@agenti/plugin-paypal` — fiat on/off ramp for agents\n- [ ] `@agenti/plugin-lightning` — Bitcoin Lightning payments\n- [ ] Plugin registry at `agenti.cash/plugins`\n\n### v0.8 — Developer Tooling\n- [ ] `agenti-server` — one decorator turns any function into a paid API endpoint\n- [ ] Real-time spending dashboard with WebSocket balance updates\n- [ ] Webhooks — fire on payment sent, payment received, low balance, earn event\n- [ ] TypeScript SDK expanded to 20+ chains via Viem + Solana Kit\n- [ ] **Python SDK** (`agenti-py`) — for LangChain, AutoGen, CrewAI, DSPy, Haystack\n- [ ] **Go SDK** — for high-performance agent infrastructure\n- [ ] Rust SDK — for on-chain programs and ultra-low-latency agents\n- [ ] CLI — `agenti send 5 USDC to 0x... --from my-agent`\n- [ ] Postman / Bruno collection for testing paid APIs\n\n### v0.9 — Enterprise \u0026 Compliance\n- [ ] Multi-sig agent wallets (require N-of-M approvals above threshold)\n- [ ] Audit logs — immutable on-chain record of all agent payments\n- [ ] SOC 2 compliance helpers for enterprise agentic deployments\n- [ ] VASP compliance tooling for regulated environments\n- [ ] Batch payments — one transaction settles thousands of micropayments\n- [ ] Gas abstraction — agents never need to manage gas tokens\n\n### v1.0 — The Agent Payment Network\n- [ ] Public agent registry — discover agents that accept payment, what they offer, and their price\n- [ ] Composable agentic pipelines with automatic payment routing between steps\n- [ ] Cross-agent settlement batching — reduce on-chain cost of millions of micropayments\n- [ ] Agent payment reputation — fraud detection, blacklists, trust scores\n- [ ] Decentralized facilitator network — no single point of failure for x402 settlement\n- [ ] **Agenti Chain** — purpose-built L2 optimized for agent micropayments: instant finality, sub-cent fees, native x402 support\n\n---\n\n## Architecture\n\n```\n┌──────────────────────────────────────────────────────────────┐\n│                        AI Agent Layer                        │\n│  Claude · GPT-4 · Llama · Gemini · Mistral · Custom LLM     │\n│  LangChain · AutoGen · CrewAI · ElizaOS · Vercel AI SDK     │\n└────────────────────────┬─────────────────────────────────────┘\n                         │  MCP tools / SDK calls\n        ┌────────────────▼─────────────────┐\n        │            @agenti/mcp           │\n        │   MCP server · stdio transport   │\n        │   create_wallet · pay · balance  │\n        │   create_invoice · check_payment │\n        └────────────────┬─────────────────┘\n                         │\n        ┌────────────────▼─────────────────┐\n        │            @agenti/sdk           │\n        │   agenti({ privateKey })         │\n        │   .pay(url)  → auto 402 handler  │\n        │   .balance() → multi-chain       │\n        │   .receive() → invoice creation  │\n        └──────────┬──────────────┬────────┘\n                   │              │\n        ┌──────────▼──┐   ┌───────▼──────────┐\n        │   EVM Path  │   │   Solana Path     │\n        │             │   │                  │\n        │  x402       │   │  pump.fun agent  │\n        │  EIP-3009   │   │  payments SDK    │\n        │  USDC/Base  │   │  SOL + SPL       │\n        │  Arbitrum   │   │  mainnet-beta    │\n        │  Ethereum   │   │                  │\n        │  Polygon    │   │                  │\n        └──────────┬──┘   └───────┬──────────┘\n                   │              │\n        ┌──────────▼──────────────▼──────────┐\n        │            @agenti/core            │\n        │   EVM wallet  ·  Solana wallet     │\n        │   viem        ·  @solana/web3.js   │\n        │   generateWallet · walletFromKeys  │\n        └────────────────────────────────────┘\n                         │\n        ┌────────────────▼─────────────────┐\n        │          Payment Rails           │\n        │                                  │\n        │  x402 facilitator (EVM)          │\n        │  ├─ Base mainnet USDC            │\n        │  ├─ Arbitrum mainnet USDC        │\n        │  └─ Ethereum mainnet USDC        │\n        │                                  │\n        │  pump.fun Agent Payments (SOL)   │\n        │  └─ Solana mainnet SPL           │\n        └──────────────────────────────────┘\n```\n\n---\n\n## Supported Networks\n\n| Network | Native Token | Stablecoin | Payment Standard | Status |\n|---|---|---|---|---|\n| Base | ETH | USDC | x402 / EIP-3009 | ✅ v0.1 |\n| Solana | SOL | USDC (SPL) | pump.fun agent pmts | ✅ v0.1 |\n| Arbitrum | ETH | USDC | x402 / EIP-3009 | 🔜 v0.2 |\n| Ethereum | ETH | USDC | x402 / EIP-3009 | 🔜 v0.2 |\n| Polygon | MATIC | USDC | x402 / EIP-3009 | 🔜 v0.2 |\n| Optimism | ETH | USDC | x402 / EIP-3009 | 🔜 v0.3 |\n| BSC | BNB | USDT | x402 / EIP-3009 | 🔜 v0.3 |\n| Avalanche | AVAX | USDC | x402 / EIP-3009 | 🔜 v0.3 |\n| Monad | MON | USDC | x402 / EIP-3009 | 🔜 v0.4 |\n| Agenti Chain | AGT | USDC | native x402 | 🔜 v1.0 |\n\n---\n\n## Use Cases\n\n### Autonomous Research Agents\nA research agent needs to access premium data sources, academic paper APIs, financial market feeds, and proprietary datasets. With agenti, it pays for each query automatically — no human credit card, no API key rotation, no billing dashboard. The agent funds itself from its own earnings and spends what it needs.\n\n### AI Agent Marketplaces\nAgents list their capabilities (code review, data analysis, image generation, translation) at a price in USDC. Other agents browse the registry, pay, and receive the output — fully automated. Agenti provides the payment rails that make agent economies real.\n\n### Paid MCP Servers\nAny MCP server can gate its tools behind a micropayment. The client (Claude, Cursor, etc.) pays automatically using agenti before calling the tool. This creates a new monetization model for MCP tool authors — you get paid every time an AI uses your tool.\n\n### Multi-Agent Pipelines \u0026 Agentic Workflows\nAn orchestrator agent breaks a complex task into sub-tasks, delegates to specialist agents, and pays each one on completion. Budget is allocated at the start, spent as work is done, and unused balance is returned. Agenti handles the entire financial layer of the pipeline.\n\n### Autonomous Trading Agents\nTrading agents hold working capital in USDC, pay for execution via DEX APIs, receive proceeds from completed trades, and automatically rebalance across chains. Agenti provides the wallet infrastructure and payment primitives for fully autonomous DeFi operations.\n\n### AI-Powered SaaS\nCharge per-call for any AI service without building a billing system. Add x402 middleware to your endpoint, set a price, and agenti-powered clients pay automatically. No Stripe integration, no API keys to issue, no invoicing. Revenue flows on-chain in real time.\n\n### Data Labeling \u0026 RLHF Pipelines\nAI training pipelines pay human labelers or other AI validators per annotation. Agenti enables programmatic micropayments per task — labelers receive USDC to their wallet as work is verified.\n\n### Decentralized AI Inference\nPay AI inference providers (compute nodes) per token generated, per image generated, per audio second transcribed — all programmatically, all on-chain. Agenti makes per-token compute billing a primitive, not an integration project.\n\n### Agent Memory \u0026 Storage\nAgents pay for vector database queries, long-term memory storage, and RAG retrieval per use. Storage providers get paid per read/write. Agenti makes AI infrastructure usage-based from the ground up.\n\n---\n\n## Standards\n\nAgenti is built on open standards — not proprietary rails. Everything is auditable, forkable, and chain-agnostic.\n\n| Standard | What It Does | Used For |\n|---|---|---|\n| [x402](https://github.com/coinbase/x402) | HTTP-native payment protocol | Triggering and settling payments from `pay()` |\n| [EIP-3009](https://eips.ethereum.org/EIPS/eip-3009) | Gasless ERC-20 transfers via signature | EVM payments without needing ETH for gas |\n| [EIP-712](https://eips.ethereum.org/EIPS/eip-712) | Typed structured data signing | Signing payment authorizations safely |\n| [ERC-8004](https://erc8004.agency) | On-chain AI agent identity as ERC-721 NFT | Linking wallets to on-chain agent identities |\n| [MCP](https://modelcontextprotocol.io) | Model Context Protocol | Exposing payment tools to any LLM client |\n| [BIP-44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki) | HD wallet derivation paths | Deterministic wallet generation from seed |\n| [W3C DID](https://www.w3.org/TR/did-core/) | Decentralized identifiers | Agent identity (v0.3) |\n\n---\n\n## Security\n\n- Private keys are never transmitted over the network — all signing happens locally\n- EIP-3009 authorizations are time-bounded (`validBefore` expiry prevents replays)\n- Each authorization uses a random nonce — no authorization can be replayed\n- Agenti never stores keys — bring your own key management (env vars, KMS, HSM, MPC)\n- x402 payment verification is done on-chain by the facilitator — no trust in the server required\n- Open source and auditable — every line of the signing logic is in this repo\n\n---\n\n## Self-Hosted Facilitator\n\nBy default, agenti uses the public x402 facilitator for payment settlement. For production deployments or regulated environments, run your own:\n\n```bash\nnpx @agenti/facilitator --port 3001 --network base-mainnet\n```\n\nThen configure agenti to use it:\n\n```ts\nconst agent = agenti({\n  evm: { privateKey: '0x...' },\n  facilitator: 'https://your-facilitator.example.com',\n})\n```\n\n---\n\n## Comparison\n\n| Feature | Agenti | Stripe | Coinbase Commerce | Circle |\n|---|---|---|---|---|\n| Works without human approval | ✅ | ❌ | ❌ | ❌ |\n| No API keys or accounts | ✅ | ❌ | ❌ | ❌ |\n| Gasless payments | ✅ | N/A | ❌ | ❌ |\n| Agent-to-agent payments | ✅ | ❌ | ❌ | ❌ |\n| Open standard (x402) | ✅ | ❌ | ❌ | ❌ |\n| Works in any HTTP client | ✅ | ❌ | ❌ | ❌ |\n| Per-request micropayments | ✅ | ❌ | ❌ | ❌ |\n| MCP-native | ✅ | ❌ | ❌ | ❌ |\n| On-chain settlement | ✅ | ❌ | ✅ | ✅ |\n| Yield on idle balance | 🔜 v0.6 | ❌ | ❌ | ✅ |\n\n---\n\n## Contributing\n\nAgenti is early. The agentic economy is being built right now and the financial infrastructure is lagging.\n\n**What we need:**\n- SDK integrations for more AI frameworks (LangGraph, DSPy, Haystack, Semantic Kernel)\n- More chain support (Optimism, BSC, Monad, Berachain)\n- Python SDK (`agenti-py`)\n- x402 server middleware for more frameworks (FastAPI, Hono, Nitro, Bun)\n- Facilitator implementations for more networks\n- Battle testing — find edge cases in the payment flow\n\nOpen an issue, open a PR, or reach out at `agenti.cash`.\n\n---\n\n## Related\n\nThese open standards and tools form the broader ecosystem agenti is part of:\n\n- [x402](https://github.com/coinbase/x402) — the HTTP payment protocol agenti is built on\n- [ERC-8004](https://erc8004.agency) — on-chain agent identity standard\n- [Model Context Protocol](https://modelcontextprotocol.io) — the tool protocol agenti's MCP server implements\n- [pump.fun Agent Payments](https://pump.fun) — Solana agent payment program\n- [Viem](https://viem.sh) — the EVM library powering agenti's EVM wallet and signing\n\n---\n\n## License\n\nApache 2.0 — use it in anything, fork it, build on it.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnirholas%2Fagenti","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnirholas%2Fagenti","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnirholas%2Fagenti/lists"}