Admin Dashboard in Claude Desktop: Monitor Your AI Agent's DeFi Portfolio with MCP Tools

2026-09-16

Admin Dashboard in Claude Desktop: Monitor Your AI Agent's DeFi Portfolio with MCP Tools

MCP tools for DeFi are here — and if you're already using Claude Desktop, you're one config block away from giving your agent a live onchain wallet with the ability to swap, lend, stake, bridge, and monitor positions across 15 integrated protocols. No custom API wiring. No bespoke tool definitions. Just add WAIaaS as an MCP server and Claude inherits 45 ready-made wallet tools the moment it starts.

Why This Actually Matters

Most developers who reach for MCP do so because they want Claude to do things, not just talk about them. Fetching a webpage, running a shell command, querying a database — these are the classic use cases. But onchain actions are a different beast. Signing a transaction requires key management. DeFi positions span multiple protocols and chains. Approvals need to go through a human before real money moves. Wiring all of that up yourself, safely, is weeks of work.

The stakes are also higher than a failed shell command. A misconfigured DeFi action can drain a wallet. An agent with unbounded spending authority is a liability. What you actually need is a wallet layer that's already solved key custody, policy enforcement, and human-in-the-loop approval — and exposes all of it through MCP so Claude can drive it naturally. That's the gap WAIaaS fills.

What WAIaaS Is

WAIaaS is an open-source, self-hosted Wallet-as-a-Service for AI agents. You run it locally (or on a server), it manages wallets across EVM and Solana networks, and it exposes everything through a REST API and — critically for this post — an MCP server.

The MCP server ships as @waiaas/mcp on npm. It registers 45 tools covering wallet queries, token transfers, DeFi actions, NFT operations, and the x402 HTTP payment protocol. When Claude connects to it, those tools appear in Claude's tool list exactly like any other MCP capability. Claude doesn't need to know anything about transaction signing, gas, or RPC nodes. WAIaaS handles all of that under the hood.

The daemon itself is a 15-package monorepo with a 7-stage transaction pipeline (validate → auth → policy → wait → execute → confirm), a policy engine with 21 policy types across 4 security tiers, and 15 integrated DeFi protocol providers. It's not a toy.

The One-Line Config

Here's what the setup looks like in 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"
      }
    }
  }
}

That's it. Restart Claude Desktop, and the next conversation has access to all 45 MCP tools. No build step, no SDK to initialize, no WebSocket server to manage. npx pulls the package on demand.

The WAIAAS_SESSION_TOKEN is a JWT scoped to a specific wallet — it's what the WAIaaS policy engine uses to apply spending limits, token whitelists, and approval requirements to every action Claude takes. The agent gets real capabilities, but bounded ones.

The 45 MCP Tools — What Claude Can Actually Do

Once connected, Claude can call tools across five categories:

Wallet & balance

get_balance — native token balance
get_assets — all token balances in the wallet
get_wallet_info — wallet metadata, address, chain
get_address — just the wallet address
get_nonce — current transaction nonce

Transactions

send_token — native or ERC-20/SPL token transfer
send_batch — multiple transfers in one atomic call
sign_message — arbitrary message signing
sign_transaction — sign without broadcasting
simulate_transaction — dry-run before execution
list_transactions — transaction history
get_transaction — single transaction by ID

DeFi

get_defi_positions — lending/staking positions across all protocols
get_health_factor — lending health factor (Aave-style)
action_provider — generic DeFi action dispatcher
hyperliquid — perpetuals, spot, sub-accounts
polymarket — prediction market positions

NFT

list_nfts — all NFTs in the wallet
get_nft_metadata — token metadata with caching
transfer_nft — ERC-721, ERC-1155, or Metaplex transfer

Infrastructure & utility

x402_fetch — HTTP fetch with automatic 402 payment
wc_connect / wc_disconnect / wc_status — WalletConnect session management
get_policies — inspect active policies
list_sessions — active agent sessions
resolve_asset — resolve token symbol to on-chain address
get_tokens — supported token list for a network
get_rpc_proxy_url — proxied RPC endpoint for chain queries

And more — ERC-8004 reputation tools, ERC-8128 signing, UserOp build/sign for Account Abstraction, credential management. The full list of 45 is in the WAIaaS MCP package.

Monitoring Your DeFi Portfolio From Claude Desktop

Let's make this concrete. After connecting WAIaaS as an MCP server, you can open Claude Desktop and ask:

"Show me my DeFi positions across all protocols"

Claude calls get_defi_positions, which queries WAIaaS across all 15 integrated protocol providers — Aave v3, Kamino, Lido, Jito, Pendle, and others — and returns a structured summary of your lending positions, staked assets, and liquidity. You can then ask follow-up questions and Claude will call get_health_factor to check your lending safety margin, or get_assets to compare your liquid balance against locked positions.

This is a genuine admin dashboard experience, except the "dashboard" is a conversation and the "widgets" are tool calls.

User: "Check my wallet balance"
→ Claude calls get_balance → returns balance

User: "Swap 0.1 SOL for USDC on Jupiter"
→ Claude calls execute_action tool with jupiter-swap provider

User: "Show my DeFi positions across all protocols"
→ Claude calls get_defi_positions → returns lending/staking positions

The Jupiter swap example above goes through the full WAIaaS transaction pipeline. If you've set a SPENDING_LIMIT policy with an instant_max_usd of $10, a small swap executes immediately. A larger one triggers NOTIFY or DELAY depending on your thresholds, and anything above delay_max_usd requires explicit owner approval via WalletConnect or Telegram before it executes.

Running Multiple Wallets as Separate MCP Servers

If you're running multiple agents — say, a trading wallet on Solana and a separate EVM wallet for Ethereum DeFi — you can register each as its own MCP server with its own session token and policy set:

{
  "mcpServers": {
    "waiaas-trading": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_AGENT_ID": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
        "WAIAAS_AGENT_NAME": "trading-agent",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    },
    "waiaas-solana": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_AGENT_ID": "019c4cd2-86e8-758f-a61e-9c560307c788",
        "WAIAAS_AGENT_NAME": "solana-wallet",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}

Claude Desktop will show both as distinct tool namespaces. Each wallet has its own session, its own policy set, and its own transaction history. The daemon is a single process managing both.

The Policy Layer — Why This Is Safe to Actually Use

The thing that makes 45 MCP tools pointed at a live wallet usable rather than terrifying is WAIaaS's policy engine. Every transaction Claude initiates goes through a 7-stage pipeline, and the policy stage runs before anything touches the chain.

The engine supports 21 policy types. The most important ones for an MCP-connected agent:

SPENDING_LIMIT — 4-tier security: INSTANT (execute immediately), NOTIFY (execute + alert you), DELAY (queue for N seconds, cancellable), APPROVAL (require your explicit sign-off)
ALLOWED_TOKENS — default-deny token whitelist; Claude can only transfer tokens you've explicitly listed
CONTRACT_WHITELIST — Claude can only call contracts on this list
X402_ALLOWED_DOMAINS — Claude can only auto-pay 402 responses from domains you've approved
PERP_MAX_LEVERAGE — caps the leverage Claude can use on Hyperliquid positions

Default-deny is the key property here. If you haven't configured ALLOWED_TOKENS, token transfers are blocked. If you haven't configured CONTRACT_WHITELIST, contract calls are blocked. Claude can ask for things; the policy engine decides whether they happen.

You configure policies via the REST API:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 100,
      "notify_max_usd": 500,
      "delay_max_usd": 2000,
      "delay_seconds": 900,
      "daily_limit_usd": 5000
    }
  }'

That policy says: under $100, Claude acts instantly. $100–$500, Claude acts and you get a notification. $500–$2,000, Claude waits 15 minutes before executing (giving you time to cancel). Over $2,000, nothing moves without your approval.

Quick Start: From Zero to Claude + Wallet in 5 Steps

Step 1 — Install the CLI and start the daemon

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

Step 2 — Create a wallet and session

waiaas quickset --mode mainnet

quickset creates wallets and MCP sessions in one step and prints the config JSON you need.

Step 3 — Or use the auto-provision Docker path

docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/waiaas/waiaas:latest

docker exec waiaas cat /data/recovery.key

Step 4 — Register WAIaaS as an MCP server in Claude Desktop

Paste the config block from Step 2 into ~/Library/Application Support/Claude/claude_desktop_config.json. Or run:

waiaas mcp setup --all

Step 5 — Set a spending policy, then open Claude

Create at least a SPENDING_LIMIT policy (see the curl example above), restart Claude Desktop, and start a conversation. Ask Claude to check your balance — it will call get_balance and return a real answer.

What's Next

The 45 MCP tools are the surface layer. Underneath is a daemon with 39 REST API route modules, a TypeScript SDK (@waiaas/sdk) with 40+ methods, and a Python SDK — so you can build agents that use WAIaaS programmatically, not just through Claude. The OpenAPI 3.0 spec auto-generates at /doc and there's an interactive reference UI at /reference if you want to explore the full API before writing any code.

If you hit a transaction that needs human approval, WAIaaS routes it through WalletConnect, Telegram, or a push notification — your choice — so you can approve from your phone without leaving the app you're already using.

The source is at github.com/waiaas/WAIaaS and the project site is waiaas.ai. Both are worth bookmarking: the GitHub repo has the full list of supported networks, protocol providers, and policy types, and the site has deployment guides for production setups with Docker Secrets and Watchtower auto-updates.