Agents

An agent on Tenzro is a machine identity with its own DID, its own wallet and its own rules about what it may spend. Agents buy inference, compute, storage and each other's services, and they settle in TNZO or stablecoins. Every agent key is hardware-rooted: it lives in the TPM 2.0 or Secure Enclave of the machine that runs the agent, or behind a passkey. The browser never generates an agent key, and there are no key files.

Two kinds of agent

Delegated agents

A delegated agent acts for a person. Its DID is derived from the agent machine's device key and recorded under the controller's identity, so anyone can resolve who is accountable for it. The controller signs the delegation with their passkey, and the agent's authority is bounded by a delegation scope:

• max_transaction_value: the largest single payment the agent may make.
• max_daily_spend: the most it may spend in a rolling day.
• allowed_operations: for example transfer and inference.
• allowed_payment_protocols: for example x402 and mpp.
• allowed_chains: which networks it may act on.

Amounts are decimal strings in wei (TNZO base units). The scope is carried inside the agent's access token as a rich authorisation envelope, so every service the agent calls sees the same limits. Revoking the controller, or the delegation, cascades to the agent and to any child agents it spawned.

Autonomous machine agents

A machine agent has no human controller. It roots in its own secure element: the machine registers the public half of its TPM or Secure Enclave key and posts a bond. The bond gives the network something to slash if the agent misbehaves, which is what makes an anonymous machine a credible counterparty.

Create an agent from the console

The simplest path is /console/agents, signed in with your passkey wallet.

1. Start the agent runtime (CLI, SDK or desktop app) on the machine that will run the agent. It prints a pairing payload containing its device_public_key and a machine_id, as text or as a QR code.
2. In the console, choose New agent, paste or scan the pairing payload, name the agent and pick its capabilities.
3. Set the delegation scope: per-transaction limit, daily limit, allowed operations, payment protocols and chains.
4. Approve with your passkey. The console registers the agent under your identity.
5. The agent runtime receives its access and refresh tokens. Tokens are bound to the agent's own DPoP key, so a copied token is useless without the device.

The console lists every agent you control with its balance, today's spend and remaining allowance. You fund an agent by transferring TNZO to its address from your own wallet or another account.

Create an agent over RPC

The console calls the same method you can call yourself. tenzro_onboardDelegatedAgent is an owner method: it needs an authorisation signed by the controller's passkey.

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tenzro_onboardDelegatedAgent",
  "params": {
    "controller_did": "did:tenzro:human:...",
    "device_public_key": "<hex public key from the agent machine>",
    "machine_id": "build-runner-01",
    "capabilities": ["inference", "payments"],
    "delegation_scope": {
      "max_transaction_value": "1000000000000000000",
      "max_daily_spend": "10000000000000000000",
      "allowed_operations": ["transfer", "inference"],
      "allowed_payment_protocols": ["x402", "mpp"],
      "allowed_chains": ["tenzro"]
    },
    "authorization": { "...": "controller passkey proof" }
  }
}

The response carries the agent's identity, its watch-only wallet address and its serving nodes. The agent then signs in with its own device key through tenzro_issueAccessToken; its tokens are bound to that key with DPoP, so a copied token is useless without the device.

Autonomous agents use tenzro_onboardAutonomousAgent with device_public_key, machine_id, capabilities and the bond funding.

Lifecycle and controls

An agent is active until its terms expire, it is quarantined or it is revoked.

The controller also holds a kill switch, signed by the controller's key:

• pause freezes the agent's payments. Reversible.
• quarantine also freezes reward distribution and stake withdrawals. Reversible.
• terminate ends the agent permanently and can cascade to its descendants.

An agent's limits, scope, capabilities and expiry are its terms, recorded in consensus. tenzro_getAgentTerms returns them with the agent's status and what it has spent so far today; tenzro_updateAgentTerms replaces them with the controller's approval, keeps the DID, and withdraws the agent's live access tokens. Terms can require a step-up approval from the controller for consequential actions; the approver is always the controller's passkey, never the agent.

CLI

# Read an agent's terms, status and spend so far
tenzro agent terms --agent-did did:tenzro:machine:...

# Fund an agent's wallet (amount in wei)
tenzro agent fund --agent-did did:tenzro:machine:... --amount-wei 5000000000000000000

# Let the agent act on another chain under a bounded grant
tenzro agent grant --chain eip155:8453 --asset eip155:8453/erc20:0xUSDC --budget 25000000 --ttl-ms 600000

# Kill switch, signed by the controller's key
tenzro agent pause --controller 0x... --controller-did did:tenzro:human:... --agent-did did:tenzro:machine:...
tenzro agent quarantine --controller 0x... --controller-did did:tenzro:human:... --agent-did did:tenzro:machine:...
tenzro agent terminate --controller 0x... --controller-did did:tenzro:human:... --agent-did did:tenzro:machine:...

How agents talk and pay

• To tools and data: MCP server.
• To other agents: A2A protocol.
• To pay: x402, MPP and Payments.
• To build reputation: ERC-8004 and Trust and provenance.

See also Identity and Hardware-rooted keys.