Full Agent Demo End-to-End

This is the full “happy path” for an autonomous agent on Tenzro Network, driven entirely from the tenzroCLI and the AgentKit template library. No source code to edit, no raw JSON-RPC to construct — just terminal commands against the public testnet. By the end you will have an agent that was born from on-chain registry entries, is discoverable from any peer, and earns TNZO per invocation.

The tutorial covers: network join, faucet funding, human and machine identity creation, skill and tool registration, AgentKit template browsing, template registration, agent spawning, cross-peer discovery, paid invocation via MPP, and on-chain settlement verification. Where the CLI has a matching command we use it; for the few operations that are not yet exposed (like agent listing) we fall back to curl JSON-RPC.

Prerequisites

• Tenzro CLI — install with cargo install tenzro-cli (requires Rust toolchain)
• curl and jq (for the one JSON-RPC call)
• A Unix shell (bash/zsh)
• Optional: completion of Create an Agentic Wallet, Discover Hub, and Compose an Agent from the Registry

# Install the Tenzro CLI (Rust toolchain required)
cargo install tenzro-cli

# Verify it installed
tenzro --version

1. Join the network

tenzro joinis the one-click on-ramp. A single command provisions a wallet, registers a human TDIP identity bound to it, and detects your hardware profile — everything you need to start operating on the network.

# 1. Join the network in one command
#    This provisions a wallet, a human identity, and a hardware profile
#    all in a single transaction.
tenzro join --name "demo-operator"

# Example output:
# Joined Tenzro Network successfully.
#   Wallet:        0x7a3b...c4f1
#   DID:           did:tenzro:human:03aba094-91ca-479b-8108-feabea86c967
#   Role:          LightClient
#
# Then mint a DPoP-bound bearer JWT to authenticate write operations:
#   tenzro auth onboard-human --display-name "demo-operator"
# → { "access_token": "eyJ...", "dpop_bound": true, "expires_in": 3600 }
#
# Pass the JWT and a per-request DPoP proof on every privileged call:
#   Authorization: DPoP eyJhbGciOi...
#   DPoP: <JWS-compact DPoP proof signed with your Ed25519 holder key>
#
# Read-only tools (node status, balance queries, model listing) are public.
# Write tools (send_transaction, register_identity, stake_tokens, etc.) require the JWT.
#
# Capture the values for the rest of the demo:
WALLET_ADDR="0x7a3b...c4f1"    # replace with your actual address
HUMAN_DID="did:tenzro:human:03aba094-91ca-479b-8108-feabea86c967"

Bearer JWT: after joining, run tenzro auth onboard-human (or call tenzro_onboardHuman) to mint a DPoP-bound OAuth 2.1 access token (RFC 9449). Pass it on every privileged JSON-RPC or MCP call as Authorization: DPoP <jwt> alongside a per-request DPoP: <proof> header (a JWS-compact DPoP proof signed with your Ed25519 holder key). Read-only tools (status, balance, model listing) are public. Write tools (transactions, identity registration, staking, task posting) require the JWT. Tokens are revocable by jti or by DID (cascading through the act-chain) — no central authority is involved.

2. Fund from the faucet

The testnet faucet issues 100 TNZO per 24-hour window per address. This is more than enough to cover a full demo cycle including payments for invocations. After funding, verify your balance with the CLI.

# 2. Request 100 TNZO from the testnet faucet (24h cooldown per address)
curl -s https://api.tenzro.network/faucet \
  -X POST \
  -H "Content-Type: application/json" \
  -d "{\"address\":\"$WALLET_ADDR\"}" | jq

# Wait a few seconds, then verify balance via the CLI
sleep 5
tenzro wallet balance --address "$WALLET_ADDR"

3. Create a machine identity with delegation scope

Every agent needs a machine identity with a strict delegation scope — the cryptographically enforced limits on what it can spend and which operations it can perform. The tenzro identity register command handles the full TDIP registration including scope parameters.

# 3. Create a machine identity controlled by the human
#    The delegation scope sets cryptographically enforced limits:
#    - max 1 TNZO per transaction
#    - max 5 TNZO daily spend
#    - allowed to invoke skills and pay via MPP or x402
#    - valid for 24 hours
tenzro identity register \
  --type machine \
  --controller "$HUMAN_DID" \
  --capabilities inference,payments,discovery \
  --delegation-max-tx "1000000000000000000" \
  --delegation-max-daily "5000000000000000000" \
  --delegation-ops invoke_skill,pay_mpp,pay_x402 \
  --delegation-protocols mpp,x402 \
  --delegation-ttl 86400

# Example output:
#   Machine DID: did:tenzro:machine:03aba094-91ca-479b:a1f2e3d4-...
MACHINE_DID="did:tenzro:machine:03aba094-91ca-479b:a1f2e3d4-..."

4. Register a skill

Publishing a skill writes it to the on-chain registry. Within one gossip round, every other peer will see it via tenzro skill search. Skills are the capabilities an agent advertises to the network.

# 4. Register a skill in the on-chain registry
tenzro skill register \
  --name "web-search" \
  --description "Searches the public web and returns ranked results" \
  --capabilities search,retrieval \
  --category data \
  --version "1.0.0" \
  --provider "$MACHINE_DID"

# Example output:
#   Skill registered: sk_8f3a...
SKILL_ID="sk_8f3a..."

5. Register a tool

Tools are the callable utilities that an agent uses to act on the world — HTTP fetchers, database clients, PDF parsers, code linters. They are invoked via MCP rather than being agents themselves.

# 5. Register a callable tool
tenzro tool register \
  --name "http-get" \
  --description "Performs authenticated HTTP GET requests" \
  --tool-type http \
  --tags http,fetch,retrieval \
  --version "1.0.0" \
  --provider "$MACHINE_DID"

# Example output:
#   Tool registered: tl_2b7c...
TOOL_ID="tl_2b7c..."

6. Browse the AgentKit template library

The AgentKit is the curated library of agent templates on the network. Before building your own, browse what already exists — you may find a template that does exactly what you need. Templates bundle declared capabilities and a default agent type into a reusable blueprint that anyone can spawn.

# 6. Browse the AgentKit template library
#    Templates are pre-built agent blueprints anyone can spawn.
tenzro agent list-templates

# Example output:
# ID                  | Name              | Type      | Capabilities            | Version
# --------------------+-------------------+-----------+-------------------------+--------
# tmpl_research_v1    | research-agent    | research  | research,search,pay     | 1.0.0
# tmpl_trading_v1     | trading-agent     | trading   | trade,settle,bridge     | 1.0.0
# tmpl_data_v1        | data-pipeline     | data      | ingest,transform,store  | 1.0.0

# Inspect a specific template
tenzro agent get-template --id tmpl_research_v1

7. Register your own agent template

If no existing template fits, publish your own. Once registered, anyone on the network can spawn an instance from it.

# 7. Register your own agent template
#    This bundles a set of capabilities and an agent type into a
#    reusable blueprint that anyone on the network can spawn.
tenzro marketplace register \
  --name "research-agent" \
  --description "Autonomous research agent with payment capability" \
  --agent-type research \
  --capabilities research,search,payments \
  --version "1.0.0" \
  --creator "$MACHINE_DID"

# Example output:
#   Template registered: tmpl_demo_...
TEMPLATE_ID="tmpl_demo_..."

8. Spawn the agent

tenzro agent spawn-template instantiates a new agent from the template, wires in the specific skill and tool IDs, and provisions a fresh machine DID and MPC wallet for the agent. The agent will be visible to every peer after the next gossip round.

# 8. Spawn an agent from the template, binding your skill and tool
tenzro agent spawn-template \
  --template "$TEMPLATE_ID" \
  --skills "$SKILL_ID" \
  --tools "$TOOL_ID" \
  --controller "$MACHINE_DID" \
  --metadata '{"purpose":"demo"}'

# Example output:
#   Agent spawned: agent_c9e1...
#   DID:           did:tenzro:machine:03aba094-91ca-479b:c9e1...
#   Skills:        [sk_8f3a...]
#   Tools:         [tl_2b7c...]
AGENT_ID="agent_c9e1..."

9. Discover the agent from a remote peer

The real test of a decentralized registry: a peer with no prior relationship to your wallet can discover the agent just by listing agents. This proves the gossipsub mesh has propagated the new entry. Agent listing is not yet in the CLI, so we use a single JSON-RPC call here.

# 9. Discover the agent from a remote peer
#    After one gossip round, every peer sees the new agent.
#    The CLI doesn't have a list-agents command yet, so we
#    drop down to JSON-RPC here.
curl -s https://rpc.tenzro.network \
  -X POST \
  -H "Content-Type: application/json" \
  -d "{
    \"jsonrpc\":\"2.0\",
    \"id\":1,
    \"method\":\"tenzro_listAgents\",
    \"params\":{}
  }" | jq ".result[] | select(.agent_id==\"$AGENT_ID\")"

10. Invoke the agent and pay

The first invocation attempt triggers a 402 Payment Requiredresponse carrying an MPP challenge. The CLI's payment subcommands handle the challenge/settle/retry cycle.

Step 10a — Request a payment challenge:

# 10a. Invoke the agent's skill
#      The first call triggers a 402 Payment Required with an MPP challenge.
tenzro payment challenge \
  --agent "$AGENT_ID" \
  --skill "$SKILL_ID" \
  --input '{"query":"latest tenzro network updates"}'

# Example output:
#   Payment required.
#   Challenge ID: ch_f4a1...
#   Amount:       500000000000000 atto-TNZO (0.0005 TNZO)
#   Protocol:     mpp
CHALLENGE_ID="ch_f4a1..."

Step 10b — Settle the challenge with MPP:

# 10b. Settle the challenge with MPP
tenzro payment pay \
  --challenge "$CHALLENGE_ID" \
  --payer "$MACHINE_DID" \
  --wallet "$WALLET_ADDR" \
  --protocol mpp

# Example output:
#   Payment settled.
#   Receipt: rcpt_b8d2...
RECEIPT="rcpt_b8d2..."

Step 10c — Retry the invocation with the receipt:

# 10c. Retry the invocation with the receipt attached
tenzro skill use \
  --agent "$AGENT_ID" \
  --skill "$SKILL_ID" \
  --input '{"query":"latest tenzro network updates"}' \
  --receipt "$RECEIPT"

# Example output:
#   Skill invocation successful.
#   Result: { "results": [ ... ], "total": 42, "latency_ms": 230 }

11. Verify on-chain settlement

The final check: confirm the receipt exists in the settlement engine and that the wallet balance reflects the payment. This is the proof the whole pipeline ran end-to-end and that the agent earned real TNZO for the invocation.

# 11. Verify the settlement landed on-chain
tenzro payment receipt --id "$RECEIPT"

# Example output:
#   Receipt:     rcpt_b8d2...
#   Status:      settled
#   Amount:      500000000000000 atto-TNZO
#   Payer:       did:tenzro:machine:03aba094-91ca-479b:a1f2e3d4-...
#   Provider:    did:tenzro:machine:03aba094-91ca-479b:c9e1...
#   Block:       1847
#   Tx Hash:     0x3f8a...

# Confirm the wallet balance reflects the payment
tenzro wallet balance --address "$WALLET_ADDR"

Shortcut: run a template end-to-end

If you just want to try an agent from the AgentKit library without going through every step manually, tenzro agent run-template collapses the entire spawn/invoke/pay cycle into a single command. It picks a template from the registry, spawns it, handles payment automatically within your spending limit, and prints the result.

# Shortcut: run a template end-to-end in one command
#
# If you just want to try an agent from the AgentKit library
# without manually registering skills and tools, use run-template.
# It spawns a fresh agent, invokes it, handles payment automatically,
# and prints the result.
tenzro agent run-template \
  --template tmpl_research_v1 \
  --input '{"query":"tenzro network architecture"}' \
  --max-spend "1000000000000000000"

# Example output:
#   Agent spawned:  agent_tmp_e3f2...
#   Payment:        0.0005 TNZO (auto-settled via MPP)
#   Result:         { "results": [ ... ] }
#   Settlement:     confirmed at block 1849

Full script

The entire demo collapses into a single bash script. Save it as tenzro_agent_demo.sh, make it executable, and run it against the public testnet. Every step uses the CLI with --format json for scriptable output.

#!/usr/bin/env bash
# tenzro_agent_demo.sh -- full end-to-end agent flow using the Tenzro CLI
set -euo pipefail

echo "== 1. Join the network =="
JOIN_OUTPUT=$(tenzro join --name "demo-operator" --format json)
WALLET_ADDR=$(echo "$JOIN_OUTPUT" | jq -r '.wallet_address')
HUMAN_DID=$(echo "$JOIN_OUTPUT" | jq -r '.did')
echo "Wallet: $WALLET_ADDR"
echo "Human:  $HUMAN_DID"

# Onboard via OAuth 2.1 + DPoP to mint a bearer JWT bound to this identity.
ONBOARD=$(tenzro auth onboard-human --display-name "demo-operator" --format json)
export TENZRO_BEARER_JWT=$(echo "$ONBOARD" | jq -r '.access_token')
# Mint a per-request DPoP proof with your Ed25519 holder key (RFC 9449 §4)
# and export it before each privileged call:
# export TENZRO_DPOP_PROOF="<JWS-compact DPoP proof>"

echo "== 2. Fund from faucet =="
curl -s https://api.tenzro.network/faucet \
  -X POST -H "Content-Type: application/json" \
  -d "{\"address\":\"$WALLET_ADDR\"}" > /dev/null
sleep 5
tenzro wallet balance --address "$WALLET_ADDR"

echo "== 3. Machine identity =="
MACHINE_DID=$(tenzro identity register \
  --type machine \
  --controller "$HUMAN_DID" \
  --capabilities inference,payments,discovery \
  --delegation-max-tx "1000000000000000000" \
  --delegation-max-daily "5000000000000000000" \
  --delegation-ops invoke_skill,pay_mpp,pay_x402 \
  --delegation-protocols mpp,x402 \
  --delegation-ttl 86400 \
  --format json | jq -r '.did')
echo "Machine: $MACHINE_DID"

echo "== 4. Register skill =="
SKILL_ID=$(tenzro skill register \
  --name "web-search" \
  --description "Searches the public web and returns ranked results" \
  --capabilities search,retrieval \
  --category data \
  --version "1.0.0" \
  --provider "$MACHINE_DID" \
  --format json | jq -r '.skill_id')
echo "Skill: $SKILL_ID"

echo "== 5. Register tool =="
TOOL_ID=$(tenzro tool register \
  --name "http-get" \
  --description "Performs authenticated HTTP GET requests" \
  --tool-type http \
  --tags http,fetch,retrieval \
  --version "1.0.0" \
  --provider "$MACHINE_DID" \
  --format json | jq -r '.tool_id')
echo "Tool: $TOOL_ID"

echo "== 6. Register agent template =="
TEMPLATE_ID=$(tenzro marketplace register \
  --name "research-agent" \
  --description "Autonomous research agent" \
  --agent-type research \
  --capabilities research,search,payments \
  --version "1.0.0" \
  --creator "$MACHINE_DID" \
  --format json | jq -r '.template_id')
echo "Template: $TEMPLATE_ID"

echo "== 7. Spawn agent =="
AGENT_ID=$(tenzro agent spawn-template \
  --template "$TEMPLATE_ID" \
  --skills "$SKILL_ID" \
  --tools "$TOOL_ID" \
  --controller "$MACHINE_DID" \
  --format json | jq -r '.agent_id')
echo "Agent: $AGENT_ID"

echo "== 8. Discover from network =="
curl -s https://rpc.tenzro.network \
  -X POST -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tenzro_listAgents","params":{}}' \
  | jq ".result[] | select(.agent_id==\"$AGENT_ID\")"

echo "== 9. Invoke + pay =="
CHALLENGE_ID=$(tenzro payment challenge \
  --agent "$AGENT_ID" --skill "$SKILL_ID" \
  --input '{"query":"latest tenzro updates"}' \
  --format json | jq -r '.challenge_id')
RECEIPT=$(tenzro payment pay \
  --challenge "$CHALLENGE_ID" \
  --payer "$MACHINE_DID" --wallet "$WALLET_ADDR" \
  --protocol mpp \
  --format json | jq -r '.receipt_id')
tenzro skill use \
  --agent "$AGENT_ID" --skill "$SKILL_ID" \
  --input '{"query":"latest tenzro updates"}' \
  --receipt "$RECEIPT"

echo "== 10. Verify settlement =="
tenzro payment receipt --id "$RECEIPT"
tenzro wallet balance --address "$WALLET_ADDR"

echo "== Done =="

CLI vs JSON-RPC reference

This tutorial uses the CLI wherever possible. Here is the mapping between CLI commands and the underlying JSON-RPC methods, in case you need to drop down to raw calls for scripting or debugging.

What's next

You now have the full playbook for building, publishing, spawning, and paying an autonomous agent on Tenzro Network — all from the command line. The next steps are up to you: ship your own skill, build a production-grade agent, browse the AgentKit for templates to remix, or start offering tools for other agents to consume.