DEV Community

Cover image for MCP + Wallet: When AI Agents Can Actually Pay
Wallet Guy
Wallet Guy

Posted on

MCP + Wallet: When AI Agents Can Actually Pay

#web3 #ai #opensource #tutorial

Claude can now read your screen, run Python code, and access your local files. But it still can't send you cryptocurrency or trade on your behalf. What if your AI agent could actually execute onchain transactions, not just talk about them?

Why AI Agents Need Real Financial Capabilities

We're at an inflection point. AI agents are becoming sophisticated enough to make financial decisions — analyzing market data, identifying arbitrage opportunities, managing DeFi positions. But they hit a wall when it comes to execution. They can tell you to "buy ETH" but can't actually buy ETH.

The missing piece is secure wallet infrastructure designed for AI agents. Traditional wallets assume human interaction — clicking confirm buttons, manually copying addresses, approving each transaction. AI agents need programmatic access with built-in safeguards.

This is where WAIaaS (Wallet-as-a-Service for AI agents) bridges the gap, especially through its native Model Context Protocol (MCP) integration.

MCP: The Missing Link for AI Wallet Integration

If you're already using Claude Desktop, you're probably familiar with MCP servers. They extend Claude's capabilities by providing tools the AI can call directly. Want Claude to read your Git commits? Add an MCP server. Want it to query your database? Another MCP server.

WAIaaS takes this same approach for blockchain interactions. It's an MCP server that exposes 45 wallet and DeFi tools to your AI agent. One configuration change, and Claude can check balances, send payments, execute swaps, and manage DeFi positions.

Here's what that looks like in practice:

You: "Check my Solana wallet balance"

Claude: Calls get_balance tool → "You have 12.45 SOL (~$2,156 USD)"

You: "Swap 1 SOL for USDC on Jupiter"

Claude: Calls execute_action with jupiter-swap → "Swap submitted. Transaction: 3x7K...9mP2"

You: "Show my current DeFi positions"

Claude: Calls get_defi_positions → "You're earning 8.2% APY on 1,000 USDC in Aave..."

The agent isn't just telling you what to do — it's actually doing it.

Setting Up WAIaaS as an MCP Server

The setup is surprisingly straightforward. WAIaaS runs as a local daemon that Claude connects to via MCP.

First, start the WAIaaS daemon:

npm install -g @waiaas/cli
waiaas init
waiaas start                       # Sets master password on first run
waiaas quickset --mode mainnet     # Creates wallets + MCP sessions
Enter fullscreen mode Exit fullscreen mode

This creates both EVM and Solana wallets, generates session tokens for AI access, and outputs the MCP configuration you need.

Next, add WAIaaS to your Claude Desktop configuration. Edit claude_desktop_config.json:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_SESSION_TOKEN": "wai_sess_<your-token>",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Restart Claude Desktop, and you'll see the WAIaaS tools appear in the MCP connection status. Your agent now has access to 45 financial tools spanning wallets, DeFi protocols, NFTs, and cross-chain bridging.

Security Without Friction

This is where WAIaaS differs from traditional wallet solutions. It's built specifically for AI agent use cases, with 3-layer security that doesn't require constant human intervention:

Layer 1: Session Authentication — AI agents use JWT tokens with configurable time limits and renewal policies. No private keys in agent memory.

Layer 2: Policy Engine — 21 policy types create guardrails around agent behavior. Spending limits, recipient whitelists, time restrictions, and default-deny token policies.

Layer 3: Human Oversight — Large transactions trigger delays or require approval via WalletConnect, Telegram, or push notifications.

Here's an example policy that allows small transactions instantly but requires approval for larger amounts:

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 300,
      "daily_limit_usd": 500
    }
  }'
Enter fullscreen mode Exit fullscreen mode

The agent can execute small trades immediately, gets notifications for medium trades, faces delays for larger trades, and needs explicit approval for anything above the daily limit.

Beyond Basic Payments: DeFi Integration

What makes WAIaaS particularly powerful is its integration with 14 DeFi protocols. Your Claude agent doesn't just send tokens — it can participate in the entire DeFi ecosystem.

The supported protocols include:

  • DEX trading: Jupiter (Solana), 0x (Ethereum)
  • Lending: Aave v3, Kamino
  • Liquid staking: Lido (Ethereum), Jito (Solana)
  • Cross-chain bridging: LI.FI, Across
  • Derivatives: Hyperliquid perpetuals
  • Prediction markets: Polymarket

Each protocol exposes its functionality through simple MCP tools. Want your agent to manage a leveraged position on Hyperliquid? The hyperliquid tool handles authentication, position management, and risk monitoring.

Here's how an agent might execute a DeFi strategy:

You: "I think ETH will outperform SOL. Move some funds accordingly."

Claude:

  1. Calls get_defi_positions to see current allocations
  2. Calls execute_action with jupiter-swap to convert SOL → USDC
  3. Calls execute_action with lifi to bridge USDC from Solana to Ethereum
  4. Calls execute_action with aave-v3 to supply USDC and borrow ETH
  5. Reports the new leveraged ETH position

All of this happens through natural language instructions, with the agent handling the technical details of multi-protocol interactions.

Multi-Wallet Agent Management

For more complex setups, WAIaaS supports multiple wallets with separate MCP server instances. This is useful when you want specialized agents for different purposes:

{
  "mcpServers": {
    "waiaas-trading": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
        "WAIAAS_AGENT_NAME": "trading-agent"
      }
    },
    "waiaas-payments": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c4cd2-86e8-758f-a61e-9c560307c788",
        "WAIAAS_AGENT_NAME": "payment-wallet"
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Each agent gets its own wallet, policies, and capabilities. Your trading agent might have higher spending limits and access to derivatives, while your payment agent has stricter limits and only basic transfer capabilities.

Try It Now

Ready to give your Claude agent financial superpowers? Here's the fastest path:

  1. Start WAIaaS: npm install -g @waiaas/cli && waiaas init && waiaas start
  2. Create wallets: waiaas quickset --mode mainnet
  3. Add MCP config: Copy the output to claude_desktop_config.json
  4. Restart Claude Desktop and watch the MCP tools connect
  5. Test it: Ask Claude to check your wallet balance

The entire setup takes less than 5 minutes, and you'll have a working AI agent with wallet capabilities on both Ethereum and Solana.

What's Next

This is just the beginning. WAIaaS provides the infrastructure for AI agents to interact with the financial world safely and programmatically. From here, you can explore advanced DeFi strategies, cross-chain arbitrage, or automated portfolio management — all through natural language instructions to your AI agent.

Get started with the code and documentation at https://github.com/minhoyoo-iotrust/WAIaaS, or learn more about the project at https://waiaas.ai.

Top comments (0)