Add DeFi Superpowers to Claude with MCP Skills

You've built an AI agent using Claude's Model Context Protocol (MCP). It can browse the web, analyze code, and handle complex reasoning tasks. But when your agent needs to interact with blockchain networks — checking balances, executing DeFi trades, or managing digital assets — it hits a wall. The blockchain world remains frustratingly out of reach.

Why Onchain Actions Matter for AI Agents

Modern AI agents are becoming powerful assistants for complex workflows. They can research markets, analyze opportunities, and make sophisticated decisions. But in the rapidly growing DeFi ecosystem worth over $200 billion, agents remain passive observers.

Consider a trading agent that can analyze market conditions and identify arbitrage opportunities across multiple protocols. Without wallet access, it can only report findings to humans who must manually execute trades — often too late to capture fleeting opportunities. Or imagine an AI assistant managing your DeFi portfolio that can track yields and suggest rebalancing but can't act on its recommendations.

The missing piece is secure wallet infrastructure that gives AI agents the ability to execute onchain transactions while maintaining proper oversight and risk controls.

The MCP Native Solution

WAIaaS is designed specifically as an MCP server, providing 45 blockchain tools that integrate natively with Claude Desktop. Instead of building custom integrations or managing complex APIs, you add one configuration block and your Claude agent immediately gains wallet capabilities.

Here's how simple the setup is:

{
  "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"
      }
    }
  }
}

Once configured, your Claude agent can access 45 MCP tools spanning five categories:

Wallet Management: get-address, get-balance, get-assets, get-wallet-info, list-credentials

Transaction Execution: send-token, transfer-nft, sign-transaction, simulate-transaction, build-userop

DeFi Operations: get-defi-positions, action-provider, get-health-factor, plus 14 protocol-specific integrations including Jupiter swap, Aave lending, Lido staking, and Polymarket prediction markets

NFT Support: list-nfts, get-nft-metadata, transfer-nft with support for both EVM (ERC-721/ERC-1155) and Solana (Metaplex) standards

Advanced Features: x402-fetch for micropayments, erc8004-get-reputation for agent validation, wc-connect for human approval workflows

Real-World Agent Workflows

Once your Claude agent has wallet access, it can handle sophisticated onchain workflows. Here's what becomes possible:

Portfolio Management: Your agent can check DeFi positions across multiple protocols, calculate health factors, and execute rebalancing trades. It might say: "Your Aave position has a 1.2 health factor. I'll partially repay the loan to bring it to 1.5 for safety."

Yield Optimization: The agent can monitor staking rewards and automatically compound earnings. "Your Jito staking rewards are ready. I'll restake 2.3 SOL to maximize your yield."

Cross-Chain Operations: Using integrated LI.FI and Across protocols, agents can bridge assets between networks. "I'll bridge 100 USDC from Ethereum to Arbitrum to take advantage of the higher lending rates."

Risk Management: The built-in policy engine ensures agents operate within defined parameters. You can set spending limits, whitelist approved contracts, and require human approval for large transactions.

The policy system uses 4 security tiers based on transaction amounts: INSTANT execution for small amounts, NOTIFY for medium amounts (with real-time alerts), DELAY with cancellation windows for larger amounts, and APPROVAL requirements for high-value transactions.

Getting Started in Minutes

The fastest way to add DeFi capabilities to your Claude agent is through the automated setup:

1. Install and Initialize:

npm install -g @waiaas/cli
waiaas init --auto-provision
waiaas start

1. Create Wallets and Sessions:

waiaas quickset --mode mainnet

This creates wallets on both Solana and Ethereum mainnets, generates session tokens for AI agent access, and outputs the exact MCP configuration for your claude_desktop_config.json file.

1. Register with Claude:

waiaas mcp setup --all

This automatically registers all wallets with Claude Desktop, updating your configuration file.

1. Test the Integration:
   Open Claude Desktop and ask: "Check my wallet balance." Your agent will call the get-balance tool and return current holdings across all configured wallets.

2. Add DeFi Skills (Optional):
   

npx @waiaas/skills add all

This adds pre-built prompt templates that teach your agent about DeFi protocols and optimal transaction patterns.

Advanced Configuration Options

For production deployments or multi-agent setups, WAIaaS supports sophisticated configuration patterns. You can run separate MCP servers for different wallets, each with their own risk policies and access controls:

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

This setup gives you fine-grained control over which agent can access which funds, with separate policy enforcement for trading operations versus treasury management.

The system also supports Docker deployment for production environments, with the daemon running as ghcr.io/minhoyoo-iotrust/waiaas:latest and automatic configuration provisioning.

Security and Risk Management

WAIaaS implements a 3-layer security model specifically designed for AI agent operations. Session-based authentication ensures agents can only access authorized wallets. The policy engine with 21 different policy types provides granular control over what actions agents can perform. Time delays and human approval workflows add safeguards for high-value operations.

Default-deny policies ensure that agents can only interact with explicitly whitelisted tokens and contracts. This prevents agents from accidentally interacting with malicious contracts or unauthorized protocols.

The system includes real-time monitoring with kill switch capabilities. If an agent begins behaving unexpectedly, authorized users can immediately revoke access or halt pending transactions.

What's Next

WAIaaS transforms your Claude agent from a passive observer to an active participant in the DeFi ecosystem. With 45 MCP tools, 14 integrated protocols, and comprehensive risk management, you can build sophisticated onchain workflows with confidence.

Ready to give your AI agent DeFi superpowers? Start with the open-source deployment at https://github.com/minhoyoo-iotrust/WAIaaS or explore the full documentation at https://waiaas.ai.