Tenzro Testnet is live. Get testnet TNZO

Start Building on Tenzro

Build on AI infrastructure that doesn't break when one provider does. Autonomous agents, smart contracts, and globally routed intelligence — in minutes.

Quick Start

1

Install the Tenzro CLI

Install the CLI tool to interact with the network and manage your node

# Install from cargo
cargo install tenzro-cli

# Or download pre-built binary from releases page
# Extract and add to your PATH

# Verify installation
tenzro-cli --version
2

Join the Network

One command provisions your DID identity, MPC wallet, and hardware profile — then connects to the Tenzro testnet

# One-click join — provisions identity + wallet automatically
tenzro-cli join

# Output:
# Identity: did:tenzro:human:6dfa9f3f-39e1-48e7-8576-6e24b0d8e4ed
# Wallet:   86frghZu2NHjnYfGBFRNPta6HLCwHdd9KKdg6kproSGw
# Status:   Active on testnet

# Get testnet TNZO from the faucet
curl -X POST https://api.tenzro.network/faucet \
  -H "Content-Type: application/json" \
  -d '{"address": "YOUR_WALLET_ADDRESS"}'

# Check balance
tenzro-cli wallet balance

For production validator nodes, see the full documentation.

3

Run AI Inference

Query live AI models running on decentralized provider nodes. Pay per-token in TNZO via micropayment channels.

CLI

# List available models
tenzro-cli model list

# Chat with a model
tenzro-cli model chat --model gemma3-270m --message "Explain blockchain in one sentence"

# Serve your own model (become a provider and earn TNZO)
tenzro-cli model serve --model gemma3-270m

JSON-RPC (curl)

# List available models
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tenzro_listModels","params":{}}'

# Run inference
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tenzro_chat",
    "params": {
      "model_id": "gemma3-270m",
      "message": "What is the Tenzro Network?",
      "max_tokens": 256
    }
  }'

TypeScript SDK

import { TenzroClient } from '@tenzro/sdk';

const client = new TenzroClient({ rpcUrl: 'https://rpc.tenzro.network' });

// List available models
const models = await client.models.listModels();
console.log('Available models:', models.map(m => m.id));

// Run inference
const response = await client.models.chat({
  model_id: 'gemma3-270m',
  message: 'Explain decentralized AI in one paragraph',
  max_tokens: 256,
});
console.log('Response:', response.text);
console.log('Tokens used:', response.tokens_used);
console.log('Cost (TNZO):', response.cost_tnzo);
4

Deploy Your First Contract

Deploy a smart contract using EVM, SVM, or DAML

EVM (Solidity)

# Deploy with Foundry
forge create src/MyContract.sol:MyContract \
  --rpc-url https://rpc.tenzro.network \
  --private-key YOUR_PRIVATE_KEY

# Or use Hardhat
npx hardhat run scripts/deploy.js --network tenzro

SVM (Solana Program)

# Build Solana program with Anchor framework
anchor build

# Deploy to Tenzro Network
anchor deploy --provider.cluster https://rpc.tenzro.network

DAML (Canton)

# Submit DAML command via CLI
tenzro-cli daml submit \
  --template MyModule:MyTemplate \
  --payload '{"field": "value"}'

Autonomous AI Agents

Deploy agents with their own DID identity and MPC wallet. Agents can spawn sub-agents, delegate tasks, execute agentic loops using live LLM inference, and settle payments autonomously on-chain.

Register an Agent

JSON-RPC

curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tenzro_registerAgent",
    "params": {
      "name": "MyOrchestrator",
      "capabilities": [
        "data_analysis",
        "task_delegation",
        "inference"
      ],
      "agent_type": "Orchestrator"
    }
  }'

# Response:
# {
#   "agent_id": "agent-abc123",
#   "did": "did:tenzro:machine:controller:uuid",
#   "wallet": "0x...",
#   "status": "Active"
# }

TypeScript SDK

import { TenzroClient } from '@tenzro/sdk';

const client = new TenzroClient({
  rpcUrl: 'https://rpc.tenzro.network',
});

// Register an orchestrator agent
const agent = await client.agents.registerAgent({
  name: 'MyOrchestrator',
  capabilities: [
    'data_analysis',
    'task_delegation',
    'inference',
  ],
  agent_type: 'Orchestrator',
});

console.log('Agent ID:', agent.agent_id);
console.log('DID:', agent.did);
console.log('Wallet:', agent.wallet);

Spawn Sub-Agents

Orchestrators can dynamically spawn child agents. Each child inherits the parent's delegation scope and gets its own DID and MPC wallet. Maximum 50 children per parent.

JSON-RPC

# Spawn a specialist sub-agent
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tenzro_spawnAgent",
    "params": {
      "parent_id": "agent-abc123",
      "name": "DataAnalyst",
      "capabilities": [
        "data_analysis",
        "statistical_reasoning"
      ]
    }
  }'

# Spawn more specialists
# ContentWriter: ["nlp", "content_generation"]
# Researcher:    ["web_search", "summarization"]

TypeScript SDK

// Spawn 3 specialist sub-agents in parallel
const [analyst, writer, researcher] = await Promise.all([
  client.agents.spawnAgent({
    parent_id: agent.agent_id,
    name: 'DataAnalyst',
    capabilities: ['data_analysis', 'statistics'],
  }),
  client.agents.spawnAgent({
    parent_id: agent.agent_id,
    name: 'ContentWriter',
    capabilities: ['nlp', 'content_generation'],
  }),
  client.agents.spawnAgent({
    parent_id: agent.agent_id,
    name: 'Researcher',
    capabilities: ['web_search', 'summarization'],
  }),
]);

console.log('Spawned:', analyst.agent_id,
  writer.agent_id, researcher.agent_id);

Swarm Orchestration

Create a swarm from spawned agents and broadcast tasks to all members in parallel. Each task is dispatched concurrently with per-agent timeouts.

JSON-RPC

# Create swarm with 3 members
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tenzro_createSwarm",
    "params": {
      "orchestrator_id": "agent-abc123",
      "members": [
        {"name": "DataAnalyst",
         "capabilities": ["data_analysis"]},
        {"name": "ContentWriter",
         "capabilities": ["nlp"]},
        {"name": "Researcher",
         "capabilities": ["web_search"]}
      ],
      "max_members": 10,
      "parallel": true,
      "task_timeout_secs": 300
    }
  }'

# Get swarm status
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tenzro_getSwarmStatus",
    "params": {"swarm_id": "SWARM_ID"}
  }'

# Terminate swarm when done
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tenzro_terminateSwarm",
    "params": {"swarm_id": "SWARM_ID"}
  }'

TypeScript SDK

// Create a parallel swarm
const swarm = await client.agents.createSwarm({
  orchestrator_id: agent.agent_id,
  members: [
    { name: 'DataAnalyst',
      capabilities: ['data_analysis'] },
    { name: 'ContentWriter',
      capabilities: ['nlp'] },
    { name: 'Researcher',
      capabilities: ['web_search'] },
  ],
  parallel: true,
  task_timeout_secs: 300,
});

console.log('Swarm ID:', swarm.swarm_id);
console.log('Members:', swarm.member_count);

// Check status
const status = await client.agents.getSwarmStatus(
  swarm.swarm_id
);
console.log('Status:', status.status);
console.log('Members:', status.members);

// Terminate when done
await client.agents.terminateSwarm(swarm.swarm_id);

Agentic Execution Loop

Run an autonomous agent that uses live LLM inference to reason through tasks, spawn helpers, and call tools iteratively until completion (max 10 steps by default).

JSON-RPC

# Run an autonomous agentic task
curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tenzro_runAgentTask",
    "params": {
      "agent_id": "agent-abc123",
      "task": "Analyze the top 3 trends in AI and prepare a structured report with key insights",
      "max_steps": 10,
      "inference_url": "https://api.tenzro.network/chat"
    }
  }'

# The agent will autonomously:
# 1. Break down the task
# 2. Spawn specialist sub-agents
# 3. Delegate subtasks to each
# 4. Collect and synthesize results
# 5. Return final structured report

TypeScript SDK

// Run autonomous agentic task
const result = await client.agents.runAgentTask({
  agent_id: agent.agent_id,
  task: `Analyze top 3 trends in AI and prepare
a structured report with key insights`,
  max_steps: 10,
  inference_url: 'https://api.tenzro.network/chat',
});

console.log('Task result:', result.result);
console.log('Steps taken:', result.steps_taken);
console.log('Agents used:', result.agents_used);

// The execution loop uses OpenAI-compatible tool_calls:
// - spawn_agent  → creates specialist sub-agents
// - delegate_task → assigns work to agents
// - collect_results → gathers agent outputs
// - complete → returns final synthesized result

Full End-to-End Example

Complete workflow: join network → provision identity → spawn agents → create swarm → run agentic task → settle payment.

TypeScript — Complete Agent Workflow

import { TenzroClient } from '@tenzro/sdk';

const RPC = 'https://rpc.tenzro.network';
const client = new TenzroClient({ rpcUrl: RPC });

async function runAutonomousWorkflow() {
  // 1. Provision identity + wallet on Tenzro Ledger
  const identity = await client.identity.participate({
    name: 'MyApp-Orchestrator',
  });
  console.log('DID:', identity.did);
  console.log('Wallet:', identity.wallet_address);

  // 2. Request testnet TNZO
  await fetch(`${RPC.replace('rpc', 'api')}/faucet`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ address: identity.wallet_address }),
  });

  // 3. Register orchestrator agent
  const orchestrator = await client.agents.registerAgent({
    name: 'ResearchOrchestrator',
    capabilities: ['orchestration', 'task_planning'],
    agent_type: 'Orchestrator',
  });

  // 4. Create a swarm with 3 specialists
  const swarm = await client.agents.createSwarm({
    orchestrator_id: orchestrator.agent_id,
    members: [
      { name: 'Analyst', capabilities: ['data_analysis'] },
      { name: 'Writer', capabilities: ['content_generation'] },
      { name: 'Researcher', capabilities: ['research'] },
    ],
    parallel: true,
  });

  // 5. Run agentic task (LLM loop on live model)
  const task = await client.agents.runAgentTask({
    agent_id: orchestrator.agent_id,
    task: 'Research the latest advances in ZK proofs and write a 3-paragraph summary',
    max_steps: 8,
    inference_url: `${RPC.replace('rpc', 'api')}/chat`,
  });
  console.log('Result:', task.result);

  // 6. Direct LLM inference (chat completion)
  const chat = await client.models.chat({
    model_id: 'gemma3-270m',
    message: 'Summarize in one sentence: ' + task.result,
    max_tokens: 100,
  });
  console.log('Summary:', chat.text);

  // 7. Settle inference payment on-chain
  const settlement = await client.settlement.settle({
    payer_did: identity.did,
    provider_address: chat.provider_address,
    amount: chat.cost_tnzo,
    asset: 'TNZO',
    proof_type: 'Cryptographic',
  });
  console.log('Settlement TX:', settlement.tx_hash);

  // 8. Cleanup — terminate swarm
  await client.agents.terminateSwarm(swarm.swarm_id);
  console.log('Swarm terminated. Workflow complete.');
}

runAutonomousWorkflow().catch(console.error);

Become a Provider — Earn TNZO

Contribute compute, models, or TEE security to the network and earn TNZO per inference request, transaction, or attestation.

Model Provider

# Register as a model provider (no staking required)
tenzro-cli provider register --role model-provider

# Download a model from HuggingFace Hub
tenzro-cli model download --model gemma3-270m

# Start serving (earns TNZO per inference)
tenzro-cli model serve --model gemma3-270m

# Check earnings
tenzro-cli provider stats
// TypeScript SDK — no staking required for model providers
const provider = await client.providers.register({
  provider_type: 'ModelProvider',
  models: ['gemma3-270m'],
  endpoint: 'https://your-node.example.com',
});

// Start serving
await client.models.serveModel({
  model_id: 'gemma3-270m',
  provider_id: provider.provider_id,
});

// Check earnings
const stats = await client.providers.getStats(
  provider.provider_id
);
console.log('Total earned:', stats.total_earned_tnzo);

Validator Node

# Stake TNZO to become a validator
tenzro-cli stake --amount 10000 --role validator

# Start validator node
cargo run --bin tenzro-node -- \
  --role validator \
  --listen-addr /ip4/0.0.0.0/tcp/9000 \
  --rpc-addr 0.0.0.0:8545

# Or with Docker
docker run -d \
  -p 9000:9000 -p 8545:8545 \
  -v ./data:/data \
  tenzro/tenzro-node:latest \
  --role validator --data-dir /data
// Liquid staking (stTNZO)
const stake = await client.staking.stake({
  amount: '10000',
  role: 'Validator',
  liquid: true, // receive stTNZO receipt token
});

console.log('Stake TX:', stake.tx_hash);
console.log('stTNZO received:', stake.sttnzo_amount);

// Unstake (7-day unbonding period)
const unstake = await client.staking.unstake({
  amount: '5000',
  validator_address: stake.validator_address,
});

Payments & Settlement

Tenzro supports HTTP 402-based payment protocols (MPP and x402), micropayment channels for per-token billing, and native TNZO settlement on-chain.

MPP (Machine Payments Protocol)

// Create an MPP payment challenge
const challenge = await client.payments.createChallenge({
  protocol: 'mpp',
  amount: '0.001',
  asset: 'TNZO',
  resource: '/api/inference/gemma3-270m',
});

// Pay via MPP session
const payment = await client.payments.payMpp({
  challenge_id: challenge.challenge_id,
  payer_did: identity.did,
  amount: challenge.amount,
});

console.log('Session:', payment.session_id);
console.log('Receipt:', payment.receipt_id);

Native TNZO Settlement

// Direct on-chain TNZO settlement
const settlement = await client.settlement.settle({
  payer_did: identity.did,
  provider_address: '0xProviderAddress',
  amount: '0.001',
  asset: 'TNZO',
  service_type: 'Inference',
  proof_type: 'Cryptographic',
  metadata: {
    model_id: 'gemma3-270m',
    tokens_used: 256,
    request_id: 'req-abc123',
  },
});

console.log('TX hash:', settlement.tx_hash);
console.log('Block:', settlement.block_number);
console.log('Fee:', settlement.network_fee_tnzo);

MCP & A2A Protocols

Connect any MCP-compatible AI tool (Claude, Cursor, etc.) directly to Tenzro Network. Use the A2A protocol for agent-to-agent task delegation.

MCP Server (Claude / Cursor)

# Add Tenzro MCP to Claude Code
# ~/.claude/mcp.json
{
  "mcpServers": {
    "tenzro": {
      "transport": "http",
      "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.tenzro.network/mcp"]
    }
  }
}

# Available tools (24 total):
# get_balance, create_wallet, send_transaction
# get_node_status, get_block, get_transaction
# register_identity, resolve_did, set_delegation_scope
# create_payment_challenge, verify_payment
# list_models, chat_completion, list_model_endpoints
# bridge_tokens, get_bridge_routes
# stake_tokens, register_provider, get_provider_stats
// Programmatic MCP client
import { McpClient } from '@tenzro/sdk';

const mcp = new McpClient({
  url: 'https://mcp.tenzro.network/mcp',
});

await mcp.connect();

// Call any MCP tool
const balance = await mcp.callTool('get_balance', {
  address: '0xYourAddress',
});

const chat = await mcp.callTool('chat_completion', {
  model_id: 'gemma3-270m',
  message: 'Hello from MCP!',
});

A2A Protocol

# Discover agent capabilities
curl https://a2a.tenzro.network/.well-known/agent.json

# Send a task to the Tenzro agent
curl -X POST https://a2a.tenzro.network/a2a \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tasks/send",
    "params": {
      "message": {
        "role": "user",
        "parts": [{
          "type": "text",
          "text": "Get my TNZO balance for 0x1234..."
        }]
      }
    }
  }'
// A2A streaming with SSE
const response = await fetch(
  'https://a2a.tenzro.network/a2a/stream',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'tasks/send',
      params: {
        message: {
          role: 'user',
          parts: [{
            type: 'text',
            text: 'Serve model gemma3-270m and get my earnings',
          }],
        },
      },
    }),
  }
);

// Stream task updates via SSE
const reader = response.body?.getReader();

Live Testnet Endpoints

JSON-RPC

https://rpc.tenzro.network

EVM-compatible JSON-RPC (Chain ID: 1337)

REST API

https://api.tenzro.network

Verification, status, and faucet

MCP Server

https://mcp.tenzro.network/mcp

Model Context Protocol — 24 tools

A2A Protocol

https://a2a.tenzro.network

Agent-to-Agent task delegation

Faucet

https://api.tenzro.network/faucet

100 testnet TNZO (24h cooldown)

# Verify testnet is live
curl https://rpc.tenzro.network \
  -X POST -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
# {"result":"0x539"}  ← Chain ID 1337

curl https://api.tenzro.network/health
# {"status":"ok","block":...,"peers":...}

Next Steps

Explore SDKs

Build with our Rust and TypeScript SDKs for programmatic access

Read Documentation

Comprehensive guides, tutorials, and API references

Get Testnet Tokens

Request testnet TNZO for development and testing

Join Governance

Stake TNZO and participate in network governance

Developer Resources

API Reference

Complete API documentation and integration guides

View Docs →

Discord

Join the community and get help from developers

Join Discord →

Tutorials

Step-by-step guides and example projects

Browse Tutorials →