Use Tenzro with Claude via MCP

What You'll Build

By the end of this tutorial, you'll have Claude connected to the Tenzro testnet via the Model Context Protocol (MCP) and will have performed a complete workflow: created a wallet, requested testnet tokens, checked your balance, and registered a decentralized identity. All through natural language conversations with Claude.

1. Prerequisites

• Claude Desktop or Claude Code installed
• Internet connection (all operations use live testnet endpoints)

2. Configure the MCP Server

Tenzro runs a public MCP server at https://mcp.tenzro.network/mcp using Streamable HTTP transport with OAuth 2.1 authentication (PKCE, dynamic client registration). This server exposes 35 tools across 11 categories that allow Claude to interact with the Tenzro Ledger, manage identities, process payments, stake tokens, query AI models, post tasks to the decentralized marketplace, register agent templates with tiered pricing, and orchestrate autonomous agent swarms.

For Claude Desktop: Add the following to your claude_desktop_config.json file:

{
  "mcpServers": {
    "tenzro": {
      "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.tenzro.network/mcp"]
    }
  }
}

For Claude Code: Run this command in your terminal:

claude mcp add --transport http tenzro https://mcp.tenzro.network/mcp

After configuration, restart Claude Desktop or Claude Code to load the new server.

Authorization: DPoP eyJhbGciOi...
DPoP: <JWS-compact DPoP proof>

3. Verify Your Connection

After adding the server, verify that Claude can see all 35 Tenzro tools.

In Claude Code: Type /mcp during a session to see all configured MCP servers, their connection status, and available tools. You can also authenticate with OAuth-protected servers from here.

# Inside a Claude Code session, type:
/mcp

# Or from your terminal, list all configured MCP servers:
claude mcp list

# Get details for the Tenzro server specifically:
claude mcp get tenzro

In Claude Desktop: Look for the hammer icon (tools) in the chat input area. Click it to see all 35 Tenzro tools listed and ready to use.

If the server shows as connected with 35 tools, you're ready to go. If it shows an error, check that the URL is correct and the server is reachable.

4. Using the Tools

MCP tools work through natural language. Describe what you want to do, and Claude selects and calls the appropriate Tenzro tool behind the scenes. Try any of these:

# Check node health
What's the status of the Tenzro node?

# Create a wallet
Create a new wallet on Tenzro

# Get testnet tokens
Request testnet TNZO tokens for 0xYOUR_ADDRESS

# Check your balance
What's the TNZO balance of 0xYOUR_ADDRESS?

# Register an identity
Register a human identity on Tenzro with the name "Alice"

# List available AI models
What AI models are available on Tenzro?

# Spawn an agent swarm
Create a swarm with 3 agents for data analysis

Claude reads your request, matches it to the right tool (e.g. get_balance, create_wallet, create_swarm), calls it with the correct parameters, and returns the result — all in one conversational turn.

You can also chain multiple operations in a single message: "Create a wallet, request testnet tokens, then check the balance." Claude will call each tool in sequence.

Step 1: Check Node Status

First, verify that Claude can connect to the Tenzro testnet. Ask Claude in natural language:

What's the current status of the Tenzro node?

Claude will call the get_node_status tool and return a response like:

{
  "status": "healthy",
  "block_height": 12543,
  "peer_count": 8,
  "uptime_seconds": 345600,
  "chain_id": 1337
}

This confirms that the node is running and accepting connections.

Step 2: Create a Wallet

Next, create a new wallet. Ask Claude:

Create a new wallet on Tenzro

Claude will call create_wallet and return:

{
  "address": "0x8f3a2b5c4d1e6a9b7c2f8d3e5a1b6c4d2e9f7a3b",
  "public_key": "0x04a5b3c2d8e9f1a4b7c3d6e2f9a5b8c1d4e7f2a9...",
  "key_type": "Ed25519"
}

Important:Save this address—you'll need it for the next steps. In production, you'd also save the private key securely, but the MCP tools handle key management internally for this tutorial.

Step 3: Request Testnet Tokens

Now request tokens from the faucet. Ask Claude (replacing the address with yours):

Request testnet tokens for 0x8f3a2b5c4d1e6a9b7c2f8d3e5a1b6c4d2e9f7a3b

The request_faucettool will be called, and you'll receive:

{
  "success": true,
  "amount": "100000000000000000000",
  "tx_hash": "0x3a5e8d9c2b7f4a1e6d3c9b5a8f2e7d4c1b9a6e3f",
  "message": "100 TNZO sent to your address"
}

The faucet distributes 100 TNZO per request with a 24-hour cooldown per address.

Step 4: Check Your Balance

Verify the tokens arrived by asking:

What's my balance at 0x8f3a2b5c4d1e6a9b7c2f8d3e5a1b6c4d2e9f7a3b?

The get_balance tool returns:

{
  "address": "0x8f3a2b5c4d1e6a9b7c2f8d3e5a1b6c4d2e9f7a3b",
  "balance": "100000000000000000000",
  "balance_formatted": "100.0 TNZO"
}

Your wallet now has 100 TNZO to use for transactions, staking, or paying for AI inference.

Step 5: Register an Identity

Tenzro implements TDIP (Tenzro Decentralized Identity Protocol) for unified human and machine identities. Register a human identity:

Register a human identity with display name 'Alice'

Claude calls register_identity and returns:

{
  "did": "did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d",
  "identity_type": "Human",
  "display_name": "Alice",
  "wallet_address": "0x8f3a2b5c4d1e6a9b7c2f8d3e5a1b6c4d2e9f7a3b",
  "kyc_tier": "Unverified"
}

Every identity gets an auto-provisioned 2-of-3 threshold MPC wallet with no seed phrases required. The DID follows the W3C Decentralized Identifiers standard.

Step 6: Resolve the Identity

Finally, verify the identity was registered correctly:

Resolve the DID did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d

The resolve_did tool returns the full identity document:

{
  "did": "did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d",
  "identity_type": "Human",
  "display_name": "Alice",
  "wallet_address": "0x8f3a2b5c4d1e6a9b7c2f8d3e5a1b6c4d2e9f7a3b",
  "kyc_tier": "Unverified",
  "public_key": "0x04a5b3c2d8e9f1a4b7c3d6e2f9a5b8c1d4e7f2a9...",
  "created_at": "2026-03-24T10:30:00Z",
  "controlled_machines": []
}

You now have a complete on-chain identity that can control machine agents, verify credentials, and participate in governance.

Step 7: Post a Task to the Marketplace

Tenzro includes a decentralized task marketplace where you can post work and receive quotes from agents. Try it:

Post a task to the marketplace: "Summarize the latest Ethereum governance proposals" with a budget of 5 TNZO

Claude calls post_task and returns:

{
  "task_id": "task_8f3a2b5c",
  "description": "Summarize the latest Ethereum governance proposals",
  "budget": "5.0 TNZO",
  "status": "open",
  "posted_by": "did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d"
}

You can also browse existing tasks and submit quotes:

List all open tasks on the marketplace

Step 8: Register an Agent Template

Agent templates define reusable agent configurations with tiered types and pricing models. Register one:

Register an agent template named "research-assistant" with type "specialist", capabilities ["web_search", "summarization"], and pricing "per_execution:0.5"

Claude calls register_agent_template and returns:

{
  "template_id": "tmpl_9c4d2e1f",
  "name": "research-assistant",
  "agent_type": "specialist",
  "capabilities": ["web_search", "summarization"],
  "pricing_model": "per_execution:0.5",
  "registered_by": "did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d"
}

Step 9: Spawn an Agent and Create a Swarm

Spawn a sub-agent from a parent identity:

Spawn a new agent named "data-collector" with capabilities ["web_scraping", "data_processing"]

Claude calls spawn_agent and returns:

{
  "agent_id": "agent_7b2c1d4e",
  "name": "data-collector",
  "parent_id": "did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d",
  "capabilities": ["web_scraping", "data_processing"]
}

Create a swarm of agents for parallel task execution:

Create a swarm with 3 agents: "researcher" (web_search), "analyzer" (data_analysis), and "writer" (text_generation)

Claude calls create_swarm and returns:

{
  "swarm_id": "swarm_4e5f6a7b",
  "orchestrator_id": "did:tenzro:human:a3f5c8e1-4b2d-4e9a-8c7f-3d5e2a1b9c4d",
  "member_count": 3,
  "members": [
    { "agent_id": "agent_1a2b3c", "role": "researcher", "status": "Idle" },
    { "agent_id": "agent_4d5e6f", "role": "analyzer", "status": "Idle" },
    { "agent_id": "agent_7g8h9i", "role": "writer", "status": "Idle" }
  ]
}

What's Next

You've successfully connected Claude to the Tenzro testnet and performed core operations across wallets, identities, the task marketplace, agent templates, and swarm orchestration. Here are some next steps to explore:

• Create a machine identity and set delegation scopes for autonomous agents
• Transfer TNZO between addresses using the send_transaction tool
• Query available AI models with list_models and request inference
• Create payment challenges using MPP or x402 protocols
• Bridge tokens to other chains using LayerZero or Chainlink CCIP adapters
• Run an autonomous agent task using run_agent_task with an agentic execution loop
• Register tiered agent templates with different pricing models on the marketplace
• Verify zero-knowledge proofs for privacy-preserving transactions

For more advanced workflows, check out these tutorials:

• Create an Agentic Wallet — Build an autonomous agent with MPC wallet and delegation scopes
• Payments with MPP — Implement HTTP 402-based machine payments
• Build an AI Payment Agent — End-to-end autonomous agent with A2A protocol and micropayments