The money layer for AI agents.

An 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.

import { agenti } from '@agenti/sdk'

const agent = agenti({ evm: { privateKey: process.env.AGENT_KEY } })
const data = await agent.pay('https://api.example.com/premium-data')

One line. The agent now has money.

Every 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.

Right 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.

Agenti is the infrastructure for the agentic economy:

• An SDK so developers can give any agent financial capability in minutes — LangChain agents, AutoGen pipelines, CrewAI crews, custom LLM loops
• An MCP server so Claude, Cursor, Windsurf, and any MCP-compatible client can use money as a native tool without writing code
• A protocol layer built on open standards (x402, EIP-3009, ERC-8004) so agent payments interoperate across frameworks, chains, and wallets
• A payment network where agents pay each other for work, data, and compute — fully autonomous, no human intermediaries

The domain is agenti.cash. The name is the mission.

import { agenti, generateWallet } from '@agenti/sdk'

// Generate a fresh wallet (EVM + Solana in one call)
const wallet = generateWallet()
console.log(wallet.evm.address)    // 0x...  (Base, Arbitrum, Ethereum, Polygon)
console.log(wallet.solana.address) // base58 (Solana mainnet)

// Or load an existing wallet
const agent = agenti({
  evm: { privateKey: '0x...' },
  solana: { privateKey: Uint8Array.from([...]) },
})

// Automatic x402 payment — if the server returns 402, agenti pays and retries
const response = await agent.pay('https://api.example.com/data')
const json = await response.json()

// POST with body
const result = await agent.pay('https://ai-service.com/generate', {
  method: 'POST',
  body: JSON.stringify({ prompt: 'summarize this document' }),
})

const balances = await agent.balance()
// [
//   { token: 'USDC', amount: '42.00', chain: 'base' },
//   { token: 'SOL',  amount: '1.5',   chain: 'solana' }
// ]

// Create a payment request
const invoice = await agent.receive({ amount: 5, token: 'USDC', chain: 'base' })
// {
//   id: 'uuid',
//   address: '0x...',
//   amount: '5',
//   token: 'USDC',
//   chain: 'base',
//   expiresAt: Date
// }

The @agenti/mcp package turns every tool in the SDK into an MCP tool that any LLM client can call — no code required.

{
  "mcpServers": {
    "agenti": {
      "command": "npx",
      "args": ["@agenti/mcp"],
      "env": {
        "AGENTI_EVM_PRIVATE_KEY": "0x...",
        "AGENTI_SOLANA_PRIVATE_KEY": "hex-encoded-64-byte-key"
      }
    }
  }
}

{
  "mcpServers": {
    "agenti": {
      "command": "npx",
      "args": ["@agenti/mcp"]
    }
  }
}

{
  "mcpServers": {
    "agenti": {
      "command": "npx",
      "args": ["@agenti/mcp"]
    }
  }
}

Once configured, you can tell any LLM: "Pay for this API and summarize the response" — and it will.

import { tool } from '@langchain/core/tools'
import { agenti } from '@agenti/sdk'

const agent = agenti({ evm: { privateKey: process.env.AGENT_KEY } })

const payTool = tool(
  async ({ url }) => {
    const res = await agent.pay(url)
    return await res.text()
  },
  {
    name: 'pay_and_fetch',
    description: 'Pay for and fetch a URL that may require cryptocurrency payment',
    schema: z.object({ url: z.string() }),
  }
)

# Coming in @agenti/sdk-python (v0.8)
from agenti import Agenti

agent = Agenti(evm_private_key=os.environ["AGENT_KEY"])
result = agent.pay("https://api.example.com/data")

// Agenti tools drop into any CrewAI-compatible workflow
import { AgentiTool } from '@agenti/sdk/tools/crewai'

const crew = new Crew({
  agents: [researchAgent],
  tools: [new AgentiTool()],  // agents in the crew can now pay for resources
})

import { agenti } from '@agenti/sdk'
import { tool } from 'ai'

const agent = agenti({ evm: { privateKey: process.env.AGENT_KEY } })

const tools = {
  payForData: tool({
    description: 'Pay for and retrieve data from a paid API endpoint',
    parameters: z.object({ url: z.string() }),
    execute: async ({ url }) => {
      const res = await agent.pay(url)
      return res.json()
    },
  }),
}

const functions = [
  {
    name: 'pay_for_resource',
    description: 'Pay for an HTTP resource using cryptocurrency and return its content',
    parameters: {
      type: 'object',
      properties: { url: { type: 'string' } },
      required: ['url'],
    },
  },
]

// In your function handler:
async function handleFunctionCall(name, args) {
  if (name === 'pay_for_resource') {
    const res = await agent.pay(args.url)
    return res.text()
  }
}

import { AgentiPlugin } from '@agenti/sdk/plugins/eliza'

export default {
  name: 'my-agent',
  plugins: [new AgentiPlugin({ evmKey: process.env.AGENT_KEY })],
}

Agenti implements the x402 open standard — an HTTP-native payment protocol that turns the long-dormant 402 Payment Required status code into a real payment flow.

1. Agent sends request
   GET https://api.example.com/data

2. Server responds with payment requirements
   HTTP/1.1 402 Payment Required
   Content-Type: application/json

   {
     "x402Version": 1,
     "accepts": [{
       "scheme": "exact",
       "network": "base-mainnet",
       "maxAmountRequired": "1000000",   // 1 USDC (6 decimals)
       "payTo": "0x...",
       "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",  // USDC on Base
       "maxTimeoutSeconds": 300
     }]
   }

3. Agenti signs an EIP-3009 transferWithAuthorization
   (gasless — no ETH required, no transaction to wait for)

4. Agent retries with payment
   GET https://api.example.com/data
   X-Payment: <base64-encoded signed authorization>

5. Facilitator verifies signature and settles on-chain
   HTTP/1.1 200 OK

   { "data": "..." }

Why this is better than every other payment method:

• No API keys to manage
• No billing accounts to create
• No monthly invoices
• No human card approval
• Works across every HTTP client, framework, and language
• The agent pays exactly what the resource costs — nothing more

For 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.

// Works identically — agenti detects the network from the 402 response
const res = await agent.pay('https://solana-api.example.com/data')

You can also gate your own APIs behind agenti payments using any x402-compatible server middleware:

import express from 'express'
import { paymentMiddleware } from '@x402/express'

const app = express()

app.use(
  paymentMiddleware({
    amount: '0.01',       // $0.01 USDC per request
    token: 'USDC',
    network: 'base-mainnet',
    address: '0xYourAddress',
  })
)

app.get('/data', (req, res) => {
  res.json({ result: 'premium data' })
})

Any agent using agenti will automatically pay and get through. No auth tokens. No rate-limit negotiation. Just value exchanged for value.

// app/api/premium/route.ts
import { withPayment } from '@x402/next'

export const GET = withPayment(
  { amount: '0.001', token: 'USDC', network: 'base-mainnet' },
  async (req) => {
    return Response.json({ data: 'premium content' })
  }
)

import { verifyPayment } from '@x402/core'

export default {
  async fetch(req) {
    const payment = req.headers.get('X-Payment')
    if (!payment) return paymentRequired()
    await verifyPayment(payment, { amount: '0.001', network: 'base-mainnet' })
    return new Response(JSON.stringify({ data: 'result' }))
  },
}

Built on @pump-fun/pump-sdk, @pump-fun/pump-swap-sdk, and @pump-fun/agent-payments-sdk — the official pump.fun SDKs.

All examples are in examples/ and runnable with npx tsx.

The 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.

import { Connection, Keypair } from '@solana/web3.js'
import bs58 from 'bs58'
import { solana } from '@agenti/sdk'

const keypair = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_PRIVATE_KEY!))
const trader = solana({ keypair, connection })

const result = await trader.buy({
  mint: 'HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC', // token mint
  solAmount: 0.1,  // 0.1 SOL
  slippage: 5,     // 5%
})

console.log(result.explorerUrl)
// → https://solscan.io/tx/...

Run it:

SOLANA_PRIVATE_KEY=<your-key> npx tsx examples/01-buy-a-coin.ts

Under 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.

Wallets are keypairs. Agenti generates EVM + Solana in one call, or loads from any key format.

import { generateWallet, solana } from '@agenti/sdk'
import { Keypair } from '@solana/web3.js'
import bs58 from 'bs58'

// Generate a fresh wallet — store these keys securely
const wallet = generateWallet()
console.log('EVM:    ', wallet.evm.address)
console.log('Solana: ', wallet.solana.address)
console.log('Key:    ', bs58.encode(wallet.solana.privateKey)) // Phantom-compatible

// Load existing wallet and give it to a trader instance
const keypair = Keypair.fromSecretKey(bs58.decode(process.env.SOLANA_PRIVATE_KEY!))
const trader = solana({ keypair, rpc: process.env.SOLANA_RPC_URL })

// trader now has signing authority — pass it to any agent

For 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.

Wire 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.

import Anthropic from '@anthropic-ai/sdk'
import { solana } from '@agenti/sdk'

const anthropic = new Anthropic()
const trader = solana({ keypair, connection })

const tools: Anthropic.Tool[] = [
  {
    name: 'get_trending_tokens',
    description: 'Get top trending tokens on pump.fun',
    input_schema: { type: 'object', properties: {}, required: [] },
  },
  {
    name: 'buy_token',
    description: 'Buy a token with SOL',
    input_schema: {
      type: 'object',
      properties: {
        mint: { type: 'string' },
        sol_amount: { type: 'number' },
        reason: { type: 'string' },
      },
      required: ['mint', 'sol_amount', 'reason'],
    },
  },
]

// Agentic loop — Claude picks a token and fires the buy
let messages: Anthropic.MessageParam[] = [
  { role: 'user', content: 'Find a trending token and buy 0.01 SOL worth. Be decisive.' },
]

while (true) {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    tools,
    messages,
  })
  messages.push({ role: 'assistant', content: response.content })

  if (response.stop_reason === 'end_turn') break

  if (response.stop_reason === 'tool_use') {
    const results = await Promise.all(
      response.content
        .filter((b) => b.type === 'tool_use')
        .map(async (b) => {
          if (b.type !== 'tool_use') return
          if (b.name === 'buy_token') {
            const { mint, sol_amount } = b.input as { mint: string; sol_amount: number }
            const result = await trader.buy({ mint, solAmount: sol_amount, slippage: 5 })
            return { type: 'tool_result' as const, tool_use_id: b.id, content: JSON.stringify(result) }
          }
          return { type: 'tool_result' as const, tool_use_id: b.id, content: '[]' }
        })
    )
    messages.push({ role: 'user', content: results.filter(Boolean) as Anthropic.ToolResultBlockParam[] })
  }
}

Run it:

ANTHROPIC_API_KEY=sk-... SOLANA_PRIVATE_KEY=<key> npx tsx examples/03-agent-buys.ts

When 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.

import { solana } from '@agenti/sdk'

const trader = solana({ keypair, connection })

// Check current state first
const state = await trader.coinState(MINT)
console.log(state.phase) // 'bonding' | 'migrating' | 'graduated'

// Watch and buy the instant it migrates
const stop = trader.watchMigration(
  MINT,
  async ({ mint, pool }) => {
    console.log(`Graduated! Pool: ${pool}`)

    const result = await trader.buy({
      mint,
      solAmount: 0.05,
      slippage: 15,        // higher slippage for volatility at migration
      priorityFee: 100_000 // priority fee for faster inclusion
    })

    console.log(`Bought post-migration: ${result.explorerUrl}`)
    stop() // unsubscribe
  },
  { pollIntervalMs: 1500 } // poll every 1.5 seconds
)

Run it:

SOLANA_PRIVATE_KEY=<key> MINT=<mint> npx tsx examples/04-buy-on-migration.ts

The 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).

Bought on the bonding curve, want to exit at graduation before post-migration volatility? watchMigration + sell handles it.

import { solana } from '@agenti/sdk'

const trader = solana({ keypair, connection })

// Watch and exit the moment bonding curve completes
const stop = trader.watchMigration(
  MINT,
  async ({ mint }) => {
    const result = await trader.sell({
      mint,
      tokenAmount: 50000, // tokens to sell (human units)
      slippage: 15,
    })
    console.log(`Sold on migration: ${result.explorerUrl}`)
    stop()
  },
  { pollIntervalMs: 1500 }
)

Run it:

SOLANA_PRIVATE_KEY=<key> MINT=<mint> TOKEN_AMOUNT=50000 npx tsx examples/05-sell-on-migration.ts

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.

// Sell 1000 tokens
await trader.sell({ mint, tokenAmount: 1000, slippage: 5 })
// → sends amount: "1000000000" (6 decimals) to the API internally

npm install @agenti/sdk @pump-fun/pump-sdk @pump-fun/pump-swap-sdk @pump-fun/agent-payments-sdk
npm install @solana/web3.js@^1.98.2 bs58 tsx

Or clone this repo and run from examples/:

git clone https://github.com/nirholas/agenti
cd agenti && pnpm install
cd examples
SOLANA_PRIVATE_KEY=<key> npx tsx 01-buy-a-coin.ts

The current release is v0.1 — the foundation. Here's where this goes:

• USDC on Arbitrum, Ethereum, Polygon
• USDT support across chains
• Native ETH and SOL payments (not just stablecoins)
• Multi-chain balance aggregation in a single call
• ENS + SNS address resolution (agent.pay('agent.eth'))
• Token price oracle integration (pay in any token, settle in USDC)

• ERC-8004 on-chain agent identity registration (22 EVM chains)
• Agent wallet addresses linked to on-chain identity NFTs
• Agent reputation scoring derived from payment history
• Discoverable payment endpoints via .well-known/agent.json
• DID (Decentralized Identifier) support for agent wallets
• Verifiable credential issuance for agent payment history

• Direct A2A payments: orchestrator agent pays sub-agents for completed work
• Payment channels — off-chain micropayment streams, settle on demand
• Task invoicing — agent emits invoice, orchestrator pays on completion
• Multi-party escrow for trustless agent coordination
• Atomic task + payment (pay only if the task output passes a verifier)
• Negotiation protocol — agents bid on tasks, lowest bid wins

• Per-session spending limits for AI agents
• Allowlists for approved payment recipients
• Budget delegation — parent agent allocates sub-budget to child agents
• Automatic top-up when balance falls below threshold
• Human approval gates for payments above configurable threshold
• Spending analytics — where did the agent spend, on what, when
• Role-based payment policies for multi-agent systems

• x402-gate your own agent's capabilities — earn when others use you
• Idle balance yield via USDs (Sperax) — 8–25% APY, auto-compound
• Payment streaming — agents earn per-second for ongoing subscriptions
• Revenue sharing between agent operator and agent owner
• Earnings dashboard with CSV export for accounting
• Tax reporting helpers (cost basis, realized gains)

• @agenti/plugin-stripe — agents accept card payments, cash out to bank
• @agenti/plugin-bitrefill — buy gift cards, eSIMs, mobile top-ups with agent balance
• @agenti/plugin-uniswap — auto-swap to correct token before payment
• @agenti/plugin-bridge — cross-chain: hold SOL, pay USDC on Base transparently
• @agenti/plugin-paypal — fiat on/off ramp for agents
• @agenti/plugin-lightning — Bitcoin Lightning payments
• Plugin registry at agenti.cash/plugins

• agenti-server — one decorator turns any function into a paid API endpoint
• Real-time spending dashboard with WebSocket balance updates
• Webhooks — fire on payment sent, payment received, low balance, earn event
• TypeScript SDK expanded to 20+ chains via Viem + Solana Kit
• Python SDK (agenti-py) — for LangChain, AutoGen, CrewAI, DSPy, Haystack
• Go SDK — for high-performance agent infrastructure
• Rust SDK — for on-chain programs and ultra-low-latency agents
• CLI — agenti send 5 USDC to 0x... --from my-agent
• Postman / Bruno collection for testing paid APIs

• Multi-sig agent wallets (require N-of-M approvals above threshold)
• Audit logs — immutable on-chain record of all agent payments
• SOC 2 compliance helpers for enterprise agentic deployments
• VASP compliance tooling for regulated environments
• Batch payments — one transaction settles thousands of micropayments
• Gas abstraction — agents never need to manage gas tokens

• Public agent registry — discover agents that accept payment, what they offer, and their price
• Composable agentic pipelines with automatic payment routing between steps
• Cross-agent settlement batching — reduce on-chain cost of millions of micropayments
• Agent payment reputation — fraud detection, blacklists, trust scores
• Decentralized facilitator network — no single point of failure for x402 settlement
• Agenti Chain — purpose-built L2 optimized for agent micropayments: instant finality, sub-cent fees, native x402 support

┌──────────────────────────────────────────────────────────────┐
│                        AI Agent Layer                        │
│  Claude · GPT-4 · Llama · Gemini · Mistral · Custom LLM     │
│  LangChain · AutoGen · CrewAI · ElizaOS · Vercel AI SDK     │
└────────────────────────┬─────────────────────────────────────┘
                         │  MCP tools / SDK calls
        ┌────────────────▼─────────────────┐
        │            @agenti/mcp           │
        │   MCP server · stdio transport   │
        │   create_wallet · pay · balance  │
        │   create_invoice · check_payment │
        └────────────────┬─────────────────┘
                         │
        ┌────────────────▼─────────────────┐
        │            @agenti/sdk           │
        │   agenti({ privateKey })         │
        │   .pay(url)  → auto 402 handler  │
        │   .balance() → multi-chain       │
        │   .receive() → invoice creation  │
        └──────────┬──────────────┬────────┘
                   │              │
        ┌──────────▼──┐   ┌───────▼──────────┐
        │   EVM Path  │   │   Solana Path     │
        │             │   │                  │
        │  x402       │   │  pump.fun agent  │
        │  EIP-3009   │   │  payments SDK    │
        │  USDC/Base  │   │  SOL + SPL       │
        │  Arbitrum   │   │  mainnet-beta    │
        │  Ethereum   │   │                  │
        │  Polygon    │   │                  │
        └──────────┬──┘   └───────┬──────────┘
                   │              │
        ┌──────────▼──────────────▼──────────┐
        │            @agenti/core            │
        │   EVM wallet  ·  Solana wallet     │
        │   viem        ·  @solana/web3.js   │
        │   generateWallet · walletFromKeys  │
        └────────────────────────────────────┘
                         │
        ┌────────────────▼─────────────────┐
        │          Payment Rails           │
        │                                  │
        │  x402 facilitator (EVM)          │
        │  ├─ Base mainnet USDC            │
        │  ├─ Arbitrum mainnet USDC        │
        │  └─ Ethereum mainnet USDC        │
        │                                  │
        │  pump.fun Agent Payments (SOL)   │
        │  └─ Solana mainnet SPL           │
        └──────────────────────────────────┘

A 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.

Agents 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.

Any 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.

An 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.

Trading 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.

Charge 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.

AI 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.

Pay 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.

Agents 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.

Agenti is built on open standards — not proprietary rails. Everything is auditable, forkable, and chain-agnostic.

• Private keys are never transmitted over the network — all signing happens locally
• EIP-3009 authorizations are time-bounded (validBefore expiry prevents replays)
• Each authorization uses a random nonce — no authorization can be replayed
• Agenti never stores keys — bring your own key management (env vars, KMS, HSM, MPC)
• x402 payment verification is done on-chain by the facilitator — no trust in the server required
• Open source and auditable — every line of the signing logic is in this repo

By default, agenti uses the public x402 facilitator for payment settlement. For production deployments or regulated environments, run your own:

npx @agenti/facilitator --port 3001 --network base-mainnet

Then configure agenti to use it:

const agent = agenti({
  evm: { privateKey: '0x...' },
  facilitator: 'https://your-facilitator.example.com',
})

Agenti is early. The agentic economy is being built right now and the financial infrastructure is lagging.

What we need:

• SDK integrations for more AI frameworks (LangGraph, DSPy, Haystack, Semantic Kernel)
• More chain support (Optimism, BSC, Monad, Berachain)
• Python SDK (agenti-py)
• x402 server middleware for more frameworks (FastAPI, Hono, Nitro, Bun)
• Facilitator implementations for more networks
• Battle testing — find edge cases in the payment flow

Open an issue, open a PR, or reach out at agenti.cash.

These open standards and tools form the broader ecosystem agenti is part of:

• x402 — the HTTP payment protocol agenti is built on
• ERC-8004 — on-chain agent identity standard
• Model Context Protocol — the tool protocol agenti's MCP server implements
• pump.fun Agent Payments — Solana agent payment program
• Viem — the EVM library powering agenti's EVM wallet and signing

Apache 2.0 — use it in anything, fork it, build on it.