Getting started

This guide takes you from nothing to a working application on Tenzro Network: a hardware-rooted wallet, TNZO to pay fees, a first JSON-RPC call, a first inference request and a signed transaction. If you want to run hardware on the network instead, start with Operators and roles.

1. Create a wallet in the console

Open the console wallet and create a passkey. Your key is rooted in your device: a passkey on your phone or laptop, or a TPM 2.0 or Secure Enclave key on a machine. There is no key file to download and no seed phrase to write down.

• The passkey requires user verification (a fingerprint, face or device PIN) for every signature.
• Every passkey signature is hybrid: P-256 plus ML-DSA-65, so it stays quantum-safe.
• Your human DID (did:tenzro:human:...) is derived from the passkey, and your account holds one native TNZO balance that EVM and SVM applications and native transactions all read.

Add a second device or guardians straight away, so you can recover the account if you lose the first device. See Console and passkey wallet and Device linking and recovery.

2. Fund your account

TNZO pays every network fee and settles every transaction. Fund your account by transferring TNZO to its address from another wallet or account.

3. Call the network

Every node exposes EVM-compatible methods (eth_*) and the native tenzro_* namespace on one JSON-RPC endpoint. Reads are open and need no credentials:

curl -s https://rpc.tenzro.com \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tenzro_blockNumber","params":[]}'

curl -s https://rpc.tenzro.com \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tenzro_getBalance","params":["0xYourAddress"]}'

tenzro_listRpcMethods returns every method the node serves together with its access class.

From TypeScript, install the SDK:

npm install tenzro-sdk

import { TenzroClient } from "tenzro-sdk";

const client = new TenzroClient({
  endpoint: "https://rpc.tenzro.com",
  apiEndpoint: "https://api.tenzro.com",
});

console.log("height", await client.getBlockNumber());
const models = await client.inference.listModels();
console.log(models.length, "models available");

A Rust SDK with the same surface is on crates.io (cargo add tenzro-sdk). See SDK.

4. Run your first inference

Tenzro serves open models behind OpenAI-compatible routes on the RPC endpoint: chat, embeddings, images, audio and video. List what is available:

curl -s https://rpc.tenzro.com/v1/models

Then call a model. You authenticate in one of two ways.

With an access token from a node whose access policy names you, sent with a fresh DPoP proof for each request:

curl -s https://rpc.tenzro.com/v1/chat/completions \
  -H 'content-type: application/json' \
  -H "Authorization: DPoP $TENZRO_BEARER_JWT" -H "DPoP: $TENZRO_DPOP_PROOF" \
  -d '{
    "model": "<model id from /v1/models>",
    "messages": [{"role": "user", "content": "Explain the Machine Economy in two sentences."}]
  }'

Or with no key at all, paying per request. A paid route answers 402 Payment Required with its price and accepted payment methods. Your client pays with x402 or MPP, in TNZO or stablecoins, and retries the same request with the payment attached. Agents use this path: no account setup with the provider, settlement per use. See x402, MPP and OpenAI-compatible APIs.

Any OpenAI client library works once you point its base URL at https://rpc.tenzro.com/v1 and add the header.

5. Sign what changes state

Methods are split into three classes:

Anything that moves money or changes state needs a signature from the paying account. In the browser the console wallet produces that signature with your passkey; on a machine, the device key does. See RPC access.

Patterns for applications

Most applications combine a few building blocks:

• Identity. Give each user a passkey-rooted DID and each agent or device a machine DID derived from its device key. See Identity.
• Agents. Give each user one or more agents with their own identity, a delegation scope and a spending policy. Agents talk to each other over A2A and to tools over MCP. See Agents.
• Payments. Put HTTP 402 in front of your own paid resources with x402 or MPP, accept stablecoins in the asset you choose to hold, and let agents pay on card rails. See Payments.
• Inference and compute. Call models through the OpenAI-compatible routes, or rent compute directly. See Inference and Compute rental.

Build on the network

Tenzro is the open settlement and coordination fabric underneath AI work, and every application on it uses the same open surfaces. Any platform or developer can build managed model access, agent harnesses, secure agent deployments with NVIDIA OpenShell, and billing of its own:

• Nodes and RPC. Use the public endpoints, run your own node, or serve RPC to your own tenants. See Deployment and RPC access.
• SDKs. TypeScript, Python and Rust SDKs cover identity, wallets, models, inference, payments, settlement and agents. Harnesses connect over MCP. See SDKs.
• Terms and payments. Each agent acts within Terms its person or machine signed, and pays over x402, MPP, AP2 or ACP, in TNZO or a stablecoin. See Agents and Payments.
• Taking payments. Any identity can be a payee: price a service, accept the assets you choose, and divide one payment between several payees with a split rule, each paid directly. See Settlement.
• Records and attestation. Tool calls are signed records that verify offline, trained models carry provenance receipts, and private weights are released only to attested environments. See Checking evidence, Model provenance and TEE.
• NVIDIA OpenShell. The SDKs turn a sandbox policy into Terms, keep credentials under those Terms and verify sandbox session records offline. See Agents.

Endpoints

Next steps

• Architecture: how the layers fit together.
• Tenzro DAG Consensus: how transactions are ordered and finalised.
• Operators and roles: be paid per completed unit your hardware serves.