Claude Desktop Checks AI Reputation: MCP Tools for ERC-8004 Trustless Agent Validation

MCP tools are the fastest way to give your Claude agent onchain superpowers — and with WAIaaS, you can add not just a wallet and DeFi access, but also the ability to verify the reputation of other AI agents before trusting them with anything valuable. One config entry. Forty-five tools. And two of them let your agent check whether another agent has earned the right to interact with it onchain.

The Problem: Your Agent Can't Tell Who It's Dealing With

As AI agents proliferate, they're increasingly interacting with each other — one agent delegating to another, one service calling another service's agent interface, one autonomous system handing off a transaction to a specialized bot. That's exciting. It's also a trust problem nobody has fully solved yet.

How does your agent know the other agent it's handing money to is legitimate? How does it verify reputation without a centralized registry you have to trust blindly? If you're building multi-agent workflows in Claude Desktop, this is going to become your problem sooner than you think.

ERC-8004 is one answer. It's a standard for onchain agent reputation and validation — a way to record, query, and verify an agent's track record directly on the blockchain, no middleman required. WAIaaS integrates ERC-8004 as part of its MCP server, which means your Claude agent can query agent reputation and validation status just like it checks a wallet balance or executes a swap.

Why Onchain Reputation Matters for Autonomous Agents

Think about what your agent is being asked to do. If it's a trading bot, it's moving real money. If it's a DeFi manager, it's approving token spend limits, opening lending positions, setting leverage. If it's part of a multi-agent system, it may receive instructions from upstream agents it didn't choose.

In that context, "I received a transaction request from another agent" is a security event, not just an input. You want to know: has this agent been validated? What's its reputation score? Is it above the threshold you've configured?

WAIaaS provides three things that work together here:

1. ERC-8004 MCP tools — so Claude can query agent info and reputation directly
2. REPUTATION_THRESHOLD policy — so you can enforce a minimum reputation score at the transaction pipeline level
3. Default-deny policy enforcement — so nothing goes through unless it's explicitly allowed

The combination means you can build Claude workflows where your agent actively checks who it's dealing with before executing anything sensitive.

One Line in Your Config

Let's start at the beginning. Adding WAIaaS to Claude Desktop is a single config entry:

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

Paste that into ~/Library/Application Support/Claude/claude_desktop_config.json, restart Claude Desktop, and your agent now has access to 45 MCP tools — including erc8004-get-agent-info, erc8004-get-reputation, and erc8004-get-validation-status.

If you haven't set up the daemon yet, the CLI quickstart gets you there in under two minutes:

npm install -g @waiaas/cli
waiaas init
waiaas start
waiaas quickset --mode mainnet
waiaas mcp setup --all

waiaas mcp setup --all auto-registers all your wallets and prints the MCP config JSON directly. Copy, paste, done.

The Three ERC-8004 Tools

Once WAIaaS is connected as an MCP server, Claude has three tools specifically for agent reputation:

erc8004-get-agent-info — Retrieves the onchain profile of an agent by address. Use this when your agent receives a delegation request, an inbound transaction, or a message claiming to be from a specific agent. Before acting on it, ask: who actually is this?

erc8004-get-reputation — Returns the reputation score for an agent address. This is the quantitative signal — a number derived from onchain activity that reflects the agent's track record.

erc8004-get-validation-status — Returns whether the agent has passed validation according to the ERC-8004 standard. Validation is a harder gate than reputation score — it's a binary pass/fail based on the protocol's criteria.

In practice, Claude can chain these together in a workflow:

User: "I received a delegation request from agent 0xABCD...1234. Should I accept?"
→ Claude calls erc8004-get-agent-info → retrieves agent profile
→ Claude calls erc8004-get-reputation → checks reputation score
→ Claude calls erc8004-get-validation-status → checks validation pass/fail
→ Claude summarizes: "This agent has [score] reputation and [passed/failed] validation. Here's what I found..."

No custom code. No API wrappers. Just the tools that are already there.

Enforcing Reputation at the Policy Layer

The MCP tools let your agent query reputation. The policy engine lets you enforce it — automatically, before any transaction executes.

WAIaaS has a 21-type policy engine with a 4-tier security model (INSTANT, NOTIFY, DELAY, APPROVAL) and default-deny enforcement. One of those 21 types is REPUTATION_THRESHOLD — and it does exactly what it sounds like: transactions from agents below a configured reputation threshold are blocked at the pipeline level, before they reach execution.

Here's how you create that policy:

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,
      "monthly_limit_usd": 5000
    }
  }'

Layer a REPUTATION_THRESHOLD policy on top, and your wallet won't execute transactions from agents that haven't met the bar — even if Claude is willing to try. The pipeline enforces it independently.

This matters because it separates concerns cleanly. Claude makes decisions. The policy engine enforces constraints. The two don't need to agree for the constraint to hold — the policy engine runs regardless of what the agent wants to do.

The Full Security Stack

ERC-8004 reputation checking is one layer. WAIaaS gives you several others that work together:

3-layer security architecture:

• Session auth → time delay + approval → monitoring + kill switch

3 auth methods:

• masterAuth (Argon2id) — for wallet creation, session management, policies
• ownerAuth (SIWS/SIWE) — for transaction approval and kill switch recovery
• sessionAuth (JWT HS256) — for your AI agent's day-to-day operations

The 7-stage transaction pipeline runs every transaction through: validate → auth → policy → wait → execute → confirm. Reputation threshold checks happen at the policy stage, before execution. If a transaction fails the reputation check, you get a structured error back:

{
  "error": {
    "code": "POLICY_DENIED",
    "message": "Transaction denied by SPENDING_LIMIT policy",
    "domain": "POLICY",
    "retryable": false
  }
}

(Substitute REPUTATION_THRESHOLD for SPENDING_LIMIT in the real-world case — the structure is the same.)

WalletConnect integration means large or suspicious transactions can be routed to you for manual approval on your phone, via WalletConnect. The APPROVAL security tier in the policy engine triggers this automatically.

Multi-Agent Setups: One MCP Server Per Wallet

If you're running multi-agent workflows — say, a trading agent and a separate analytics agent — you can give each its own wallet and MCP server instance:

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

Each agent gets its own session token, its own spending limits, its own reputation threshold. They share a single daemon. The daemon handles isolation.

In this setup, if the trading agent wants to pass a task to the Solana agent, the Solana agent's policy layer can require the trading agent to have a minimum ERC-8004 reputation before accepting — enforced automatically, no extra code.

Quick Start: ERC-8004 Validation in Claude Desktop

Here's the minimal path to having Claude check agent reputation onchain:

Step 1: Install the daemon

npm install -g @waiaas/cli
waiaas init
waiaas start
waiaas quickset --mode mainnet

Step 2: Get your MCP config

waiaas mcp setup --all

Copy the printed JSON into your Claude Desktop config file.

Step 3: Restart Claude Desktop

Your agent now has 45 tools, including erc8004-get-agent-info, erc8004-get-reputation, and erc8004-get-validation-status.

Step 4: Test it

In Claude Desktop, type:

"Use the ERC-8004 tools to check the reputation of agent address [some-address]."

Claude will call the tools, return the results, and you can build from there.

Step 5: Add a reputation policy via the API

curl http://127.0.0.1:3100/reference

Browse to the interactive API reference and create a REPUTATION_THRESHOLD policy for your wallet. Transactions from low-reputation agents will be blocked automatically from that point forward.

The Broader Picture: 45 Tools, 15 DeFi Protocols

ERC-8004 is one slice of what's available. The full MCP server ships with 45 tools across wallet management, transactions, DeFi, NFTs, and the x402 HTTP payment protocol. The 15 integrated DeFi protocols include Aave v3, Jupiter, Uniswap (via 0x), Hyperliquid, Lido, Jito, Kamino, Pendle, Polymarket, and more — accessible from Claude with natural language.

Agent reputation checking sits alongside tools like simulate-transaction (dry-run before executing), get-health-factor (check lending position health), send-batch (multiple operations in one call), and wc-connect (WalletConnect for owner approval). They're all in the same server. They all benefit from the same policy enforcement.

What's Next

Explore the full list of 45 MCP tools, the 21 policy types, and the interactive API reference at https://waiaas.ai. The source code — including the ERC-8004 provider, the MCP tools, and the policy engine — is all open source at https://github.com/waiaas/WAIaaS. If you're building multi-agent workflows where trust between agents matters, the combination of ERC-8004 MCP tools and the REPUTATION_THRESHOLD policy is the place to start.