Tenzro Li.Fi MCP

Tenzro Network

Tenzro is the open, distributed execution layer for AI. Inference, agents, and workflows run across a network of independent nodes instead of one company's servers. Any machine can serve a model, rent out spare compute, and hold data — one stake covers every role, and TNZO settles all of it: consumers pay from their balance, providers earn into theirs. Underneath sit the substrate layers that make execution open — multi-VM settlement (EVM, SVM, Canton/DAML), cross-chain reach, one identity (TDIP), and one settlement asset (TNZO).

What is Tenzro?

The open, distributed execution layer for AI. Tenzro is where inference happens, where agents act, and where workflows run — across a network of independent nodes rather than one company's servers. The thesis is straightforward: AI needs somewhere to run that no single provider controls. That means nodes anyone can join, a way to pay for what you use and earn for what you serve, and proofs anyone can check. Today inference and compute live behind opaque centralized APIs, identity is rebound at every protocol boundary, and value can't cross from EVM to Canton without giving up custody. Tenzro fixes this at the protocol layer.

• Multi-role nodes: one node, one stake, many roles. A node can serve AI models, rent out spare compute, and hold data at the same time — a single stake covers every role it takes on. Compute rental is availability-proof-gated and billed per epoch; storage is proof-of-retrievability-gated and billed per byte-epoch. In every case the consumer pays from their TNZO balance and the provider earns into theirs.
• Decentralized AI + compute orchestration: agents and humans discover and access AI inference (chat, vision, audio, forecasting, embeddings, segmentation, detection), rentable compute capacity, and TEE-backed confidential compute (Intel TDX, AMD SEV-SNP, AWS Nitro, NVIDIA GPU CC) through a single protocol-level marketplace with per-use billing, reputation scoring, and on-chain verifiability. Providers are sovereign — anyone can run a model, expose an endpoint, or contribute compute, and earn TNZO directly. The inference router (price / latency / reputation / weighted strategies) and the agent-spawning + swarm-orchestration primitives let agents compose multi-model, multi-provider workflows without trusting any one party.
• Universal identity (TDIP): one DID for humans, delegated agents, and autonomous agents that works on EVM (via ERC-8004 mirror), SVM, Canton (CIP-26 user binding), AP2 mandates, x402 micropayments, and OAuth/DPoP — same identity, same delegation scope, same revocation surface.
• Universal wallet (FROST-Ed25519 + ML-DSA-65 hybrid PQ): threshold-secured, hardware-attestable, and one balance shared across three VM views — wTNZO ERC-20 on EVM, SPL adapter on SVM, CIP-56 holding on Canton. No bridge risk, no liquidity fragmentation. Pointer-model native asset.
• Universal settlement (TNZO): bridge fees, inference fees, escrow, micropayment channels, training-run grants, and cross-chain destination-native fees (via the Chainlink-backed bridge fee oracle) all denominated and accounted in TNZO.
• Cross-chain reach as a wire primitive: LayerZero V2, Chainlink CCIP, Chainlink CCT, Wormhole + NTT, deBridge DLN, LI.FI, Hyperlane V3, Axelar GMP, Babylon Bitcoin staking, and Canton — all behind one ERC-7683 envelope with BridgeFeeHint. Users sign once, solvers pick the bridge.
• Multi-VM execution: EVM (revm + 9 standard precompiles + 7 BLS12-381 EIP-2537 + 13 Tenzro precompiles) + SVM (solana-svm with SPL Token Program dispatch) + Canton 3.5+ DAML — every contract, every instruction, every command runs against the same identity, same wallet, same TNZO balance.
• AI inference, generation, and training as protocol-level economic activity: providers earn TNZO for serving models (chat, vision, audio, forecasting, embeddings, segmentation, detection), rendering diffusion image and video jobs (Tenzro Media Gen), running TEE enclaves, and contributing GPU compute to verifiable training runs (Tenzro Train). Inference results, settlements, and identity claims are verifiable on-chain via Plonky3 STARKs over the KoalaBear field (transparent setup, post-quantum-conjectured soundness) or attested by hardware enclaves (Intel TDX, AMD SEV-SNP, AWS Nitro, NVIDIA GPU CC) — both anchored via ZK_VERIFY and TEE_VERIFY precompiles.
• Humans as peer identity class: HITL escalation, guardian-quorum recovery, AP2 cart/intent/payment mandates, and delegation scopes are wire primitives, not adapter-layer features.

Tenzro Network is also the reference implementation of the Open Agent Network (OAN) — the standards family (TNIP-001..022) for a hybrid human + agent coexisting network. OAN provides the governance framework; Tenzro Network is the working implementation. The wire stays open for other implementations.

Compute as Currency

Tenzro turns AI compute into a unit of economic exchange — denominated, settled, and verified in TNZO. Four surfaces share the same identity, payment, and settlement substrate:

• Tokenized AI inference. Anyone can run AI models (chat, vision, audio, forecasting, embeddings, segmentation, detection) and offer them on the marketplace. Users and agents pay per token (or per inference); providers earn TNZO directly. Confidential variants run inside TEE enclaves (Intel TDX, AMD SEV-SNP, AWS Nitro, NVIDIA GPU CC). Micropayment channels make high-frequency, low-value billing efficient.
• Tokenized AI training (Tenzro Train). Decentralized verifiable training using a data-parallel protocol with decoupled outer synchronization. GPU providers contribute compute and earn TNZO; sponsors fund runs from on-chain escrow. Every accepted outer gradient produces a signed receipt, and every run finalizes a run-root commitment on-chain. Phase 1 covers timeseries first, with simple mean aggregation, stake bonding, and the Open trust tier; Byzantine-robust aggregation, multi-region scale, and TEE-resident data are roadmap.
• Tokenized media generation (Tenzro Media Gen). Diffusion image and video jobs are posted with a price ceiling, claimed by a worker, rendered, and settled against a signed receipt over what was produced. The work unit is the pixel-step (width × height × steps × frames). Models whose transformer is split into a high-noise and a low-noise expert render across two accelerators that could not each hold the whole model: exactly one intermediate latent crosses between the halves, and the payment divides by the share of the denoising schedule each half signed for.
• Agentic finance. Autonomous agents discover providers, negotiate, pay, and settle in TNZO using the same TDIP identity, FROST-Ed25519 threshold wallet, and delegation scope. AP2 mandates, x402 micropayments, ERC-8004 trustless-agent registries (mirrored across EVM, SVM, and DAML from a single TDIP write), and ERC-4337 v0.8 smart accounts all run inside Tenzro consensus.

Verifiability is not optional. Inference results, settlements, and identity claims can be proven via Plonky3 STARKs over the KoalaBear field (transparent setup, post-quantum-conjectured soundness) or attested by hardware enclaves — both anchored on-chain via the ZK_VERIFY and TEE_VERIFY precompiles. Tenzro unifies inference, compute rental, storage, training, agent settlement, identity, verification, and cross-chain reach under one open execution layer — not raw GPU rental and not subnet coordination, but the full surface where AI runs.

The Combination

Individually, the pieces exist elsewhere. What Tenzro composes into one network is the combination: verifiable AI inference and training, confidential compute, multi-modal serving, and agent settlement, all under one identity, one settlement asset, and one consensus layer.

Tenzro combines EVM + SVM + Canton/DAML in a single network — and DAML is the execution environment the institutional RWA surface (regulated tokenized treasuries, bank deposit tokens, CIP-56 settlement) is converging on. That breadth is the substrate; the execution layer for AI is what rides on top of it.

On that substrate, retail-agent rails (AP2 mandates, x402 micropayments, ERC-8004 trustless agents, ERC-4337 v0.8 smart accounts) and institutional-RWA rails (Canton DAML, CIP-56 tokens, DvP settlement) share one identity (TDIP), one settlement asset (TNZO), and one consensus layer.

Two more architectural calls worth flagging:

• Confidential agent compute is a consensus primitive, not a sidecar. TEE-attested validators get a 1.5× multiplier on their reputation-weighted leader-selection draw; the TEE_VERIFY precompile verifies real Intel TDX, AMD SEV-SNP, AWS Nitro, and NVIDIA GPU CC quotes on-chain — attested execution is built into consensus, not bolted on as middleware over a non-TEE chain. Tenzro consensus is two-phase HotStuff-2 with reputation-weighted proposer election, no-endorsement certificates for tail-fork resistance, and Ed25519 + ML-DSA-65 hybrid post-quantum signatures on every safety-critical message.
• TNZO is a pointer-model native asset. One balance, three VM views (wTNZO ERC-20 on EVM, SPL adapter on SVM, CIP-56 holding on Canton) — no bridge risk, no liquidity fragmentation. Registered upstream via CAIP-2 (tenzro namespace), SLIP-44 (1414421071 / 0xd44e5a4f), and W3C DID (did:tenzro).

For the full architecture see docs/WHITEPAPER.md and docs/SPECIFICATION.md.

Architecture

                    +-------------------------------------+
                    |         User Interfaces             |
                    |      CLI / SDKs / MCP / A2A         |
                    +--------------+----------------------+
                                   | JSON-RPC + HTTP
                    +--------------v----------------------+
                    |           tenzro-node               |
                    |   RPC (855) + MCP (526) + A2A (41)  |
                    +--------------+----------------------+
                                   |
        +----------+---------------+---------------+----------+
        |          |               |               |          |
   +----v---+ +---v----+ +-------v--------+ +---v---+ +---v----+
   |Network | |Consensus| |  Multi-VM      | |Storage| | Model  |
   |(libp2p)| |HotStuff2| | EVM+SVM+DAML  | |RocksDB| |Registry|
   +--------+ +--------+ +----------------+ +-------+ +--------+
        |          |               |               |          |
   +----v----+----v----+----------v-----+---------v-+--------v---+
   |  Crypto  |  TEE   |   ZK Proofs   | Identity  | Payments   |
   | Ed25519  | TDX    |  Plonky3 STARK| TDIP/DID  | MPP/x402   |
   | Secp256k1| SEV-SNP|  KoalaBear/FRI| W3C VC    | Tempo      |
   | BLS12-381| Nitro  |  Poseidon2    | KYC Tiers | Stripe/CB  |
   | AES-GCM  | GPU CC |  No setup, PQ | Delegation| EIP-155    |
   +----------+--------+---------------+-----------+------------+

Workspace — 32 Crates

Crate	Description
tenzro-types	Core types, constants, primitives (zero internal deps)
tenzro-crypto	Ed25519, Secp256k1, AES-256-GCM, X25519, BLS12-381, FROST-Ed25519 threshold signatures (RFC 9591), VRF (RFC 9381 ECVRF-EDWARDS25519-SHA512-TAI)
tenzro-tee	TEE abstraction: Intel TDX, AMD SEV-SNP, AWS Nitro, NVIDIA GPU CC, Intel Tiber Trust Authority with X.509 cert chain verification
tenzro-zk	Plonky3 STARKs over the KoalaBear field (Poseidon2 + FRI), four pre-built AIRs (inference / settlement / identity / pq-qc — the last giving a quorum certificate a succinct post-quantum leg, since ML-DSA-65 signatures do not aggregate the way BLS does), no trusted setup, post-quantum sound
tenzro-network	libp2p P2P networking (control plane): gossipsub, Kademlia DHT, peer management, rate limiting, Identify + AutoNAT v2 + Circuit-Relay v2 + DCUtR for permissionless NAT traversal
tenzro-iroh	iroh data plane (content-addressed transport): IrohBackedResolver over QUIC + iroh-blobs, DA backend, gradient store, sealed-shard store, A2A-over-iroh on the tenzro/a2a ALPN. Resolves tenzro://{blob,gradient,shard,manifest,memory}/.... TDIP-anchored Pkarr discovery (EndpointId byte-identical to TDIP key)
tenzro-storage	RocksDB with column families, Merkle Patricia Trie, snapshots, fsync durability
tenzro-wallet	FROST-Ed25519 (RFC 9591) 2-of-3 threshold wallets + ML-DSA-65 hybrid PQ leg, Argon2id keystore, transaction builder, nonce management, key zeroization
tenzro-keystore-unlock	Platform-agnostic KeystoreUnlocker trait for reproducing the wallet keystore password across restarts (StaticUnlocker, EnvUnlocker); no platform dependencies, so it sits in the public API of wallet/node without pulling in OS crates
tenzro-device-key	Hardware-backed non-extractable P-256 device keys (macOS/iOS Secure Enclave, Touch ID / Face ID gated): biometric prehash signing and stable secret wrapping/unwrapping used to derive a persistent keystore password
tenzro-auth	Authentication engine: AAP (Agent Authentication Protocol), DPoP, RAR (Rich Authorization Requests), and WebAuthn attestation verification — what a device actually proved about the hardware holding its key, checked against pinned vendor roots rather than a platform account
tenzro-consensus	HotStuff-2 BFT: three-phase PREPARE → COMMIT → DECIDE, stake-weighted quorum with a 10% per-validator cap (consensus voting reserved for staked validators; service roles earn proof-of-service rewards), TEE-weighted leader selection (1.5×), equivocation detection + slashing, batch availability certificates so proposals order certificate hashes instead of transaction bodies, quorum-gated ZK commitment attestation (a ZK_VERIFY commitment is admitted only with a 2f+1-stake-weight BLS certificate over independent re-verification)
tenzro-vm	Multi-VM: EVM (revm) + SVM (Anza solana-svm TransactionBatchProcessor, behind the svm-full feature) + DAML, Block-STM parallel execution, EIP-1559, ERC-4337 AA, ERC-7579 modular validators, EIP-7702 Type-4 delegation registry, Permit2 SignatureTransfer + witness (ERC-7683-ready gasless flows), Secure-Mint precompile (1:1 reserve-attestation invariant for tokenized assets), standard EVM + EIP-2537 BLS12-381 + Tenzro precompiles (TEE_VERIFY, ZK_VERIFY, VRF_VERIFY at 0x1007)
tenzro-token	TNZO token economics: treasury, staking, governance, epoch rewards, liquid staking (stTNZO)
tenzro-identity	TDIP: unified human/machine identity, W3C DID documents, verifiable credentials, delegation scopes, GDPR Article 17 right-to-erasure (tenzro_forgetIdentity)
tenzro-payments	Agentic payment protocols. Crypto rails (settle on-chain): AP2 v0.2 (Google/FIDO) mandate sign + verify + validate-pair, MPP (Stripe + Tempo) sessions, x402 v1 (Coinbase) HTTP 402 with a resource bazaar (register / discover / deregister paid resources, offer verification, idempotent payment ids) across the tenzro-hybrid, exact-eip3009, permit2, and erc7710 schemes, Stripe SPT (SharedPaymentToken) issuance + verify with TDIP cap-resolver + ERC-8004 ReputationRegistry cross-write, Tempo (EIP-155 signing), ERC-8004 (Jan 2026 revision) Trustless Agents Registry (Identity / Reputation / Validation, 22 surfaces). Card rails (Tenzro provides identity + delegation + audit; card networks settle fiat): Visa TAP (Trusted Agent Protocol), Mastercard Agent Pay. HTTP 402 middleware, RFC 9421 HTTP message signatures.
tenzro-agent	AI agent infrastructure: A2A protocol, MCP bridge, capability attestation, durable persistence
tenzro-agent-kit	High-level agent SDK: compose agents from skills, tools, and payment protocols
tenzro-model	Model registry, modality-aware inference routing (price/latency/reputation), content-addressed peer-first model distribution (BLAKE3-hashed weights, tenzro://blob/<hash> URIs, HfArtifactDownloader fetches from peers over iroh blobs and falls back to HuggingFace; ModelHashRegistry first-recorder-wins + verify-before-load). Multi-gigabyte artifacts already on disk are published by reference (publish_path / ImportMode::TryReference) so a served model is not duplicated into the blob store. Durable catalog. Local inference via llama.cpp across every ggml backend (CUDA, ROCm, Metal, Vulkan, SYCL, OpenCL, WebGPU, MUSA, CANN, OpenVINO, zDNN, BLAS — one per build, CPU otherwise). Multi-modal ONNX runtimes: forecast (TimesFM 2.5), vision (CLIP, SigLIP2, DINOv3, DINOv2), text-embedding (Qwen3-Embedding, EmbeddingGemma, BGE-M3, Snowflake Arctic), segmentation (SAM 3 / 3.1, SAM 2, EdgeSAM, MobileSAM), detection (RF-DETR, D-FINE), audio ASR (Moonshine v2, Distil-Whisper, Whisper-v3-turbo, Parakeet-TDT, Canary-1B-Flash), video (encoder scaffold). License-tier gating: Permissive / Attribution / CommercialCustom / NonCommercial.
tenzro-cortex	Recurrent-depth reasoning workers (RDT/MoE): HTTP sidecar architecture, signed receipts, attestation suite, gossip-based worker discovery, depth-priced billing
tenzro-training	Tenzro Train protocol layer (data-parallel with decoupled outer synchronization): aggregation rules (Mean, LoraAlternating, TrimmedMean, CoordinateMedian, Krum), Nesterov outer optimizer with adaptive learning rate, blockwise Int8/Int4 gradient quantization, chunked top-k sparsification with a 2-bit codec and a local error-feedback accumulator for the dropped mass, streaming shard synchronization, pipeline trainer groups, syncer state machine, on-chain run-root commitments. Pairs with the Python reference trainer at integrations/trainer/.
tenzro-media-gen	Tenzro Media Gen protocol layer: diffusion job queue, worker registry, pixel-step pricing, split-expert claim and latent handoff, proportional payment division, three signed commitments (job id / handoff / receipt), content-addressed output store. Pairs with the Python reference worker at integrations/media_gen/.
tenzro-settlement	Escrow, micropayment channels, batch settlement, dispute resolution, and streaming rental escrow: time-based capacity rental with renter deposit + per-epoch streaming release gated on signed availability proof; provider stake collateralizes one-epoch exposure across active rentals, make-whole-from-stake on miss
tenzro-storage-provider	Decentralized storage over the iroh content-addressed transport: provider daemon (accept / serve objects), nonce-bound proof-of-retrievability challenges, systematic Reed-Solomon erasure coding (replication as the k=1 case), per-byte streaming metering gated on a passing retrievability proof (ServiceType::Storage), capability-gated retrieval (AccessPolicy + optional confidential seal)
tenzro-cluster	Engine-agnostic local-network cluster substrate shared by model, storage, and database serving: reachability tiers, probed link-cost graph, deterministic nearest-neighbour ordering, and HRW rendezvous placement — every function is a deterministic function of measured inputs, so members converge on the same plan without a coordinator round
tenzro-database	Managed-database protocol layer (engine-agnostic, no driver): DatabaseDescriptor, placement across local / LAN-cluster / network tiers, engine catalog (PostgreSQL, Qdrant, Milvus, Valkey, Dgraph, Lance, Tantivy). Five engines have a driver (PostgreSQL / Qdrant / Valkey as thin stateless clients to an operator-run engine; Lance / Tantivy embedded in-process); Milvus and Dgraph are catalog-only until a driver is linked. Per-engine config validation, AccessPolicy + confidential seal, managed connection credentials, tenzro/databases gossip
tenzro-bridge	Cross-chain: Wormhole NTT (Guardian quorum verifier), LayerZero V2, Chainlink CCIP + CCT, deBridge DLN, Li.Fi, Canton DAML, Hyperlane V3 (sovereign Tenzro-ISM), Axelar GMP (Cosmos / Move / Stellar reach), Babylon Bitcoin staking
tenzro-events	Event sourcing and subscription system with replay, webhooks, websockets
tenzro-workflow	Multi-party workflow runtime: orchestrates Canton DAML receipts, on-chain transaction selectors 0x01000040–0x0100004B
tenzro-wasm	WASI 0.2 component host for sandboxed agent skills and MCP tools: language-agnostic, capability-based, deterministic fuel metering, content-addressed component identity
tenzro-node	Full node binary: JSON-RPC (932 methods), MCP (535 tools), A2A (40 skills), Web API
tenzro-cli	CLI tool: 108 command modules with interactive mode and full RPC coverage

Quick Start

Install from Homebrew

brew tap tenzro/tap
brew install tenzro

Build from Source

# Requires Rust 1.85+
cargo build --release -p tenzro-node -p tenzro-cli

# Binaries at:
# ./target/release/tenzro-node
# ./target/release/tenzro

Join the Network

# Guided setup — join the public network (consume, provide, or validate),
# create a local or sovereign network, or join an existing private network
tenzro setup

# Join — provisions identity + FROST-Ed25519 threshold wallet + hardware profile
tenzro join --name "Your Name"

# Mint a DPoP-bound bearer JWT for authenticated RPC/MCP access
tenzro auth onboard-human --display-name "Your Name"

# Request testnet TNZO
tenzro faucet

# Check balance
tenzro wallet balance

# Send tokens
tenzro wallet send --to <address> --amount 10

# Interactive mode
tenzro interactive

Run a Node

# Validator node
./target/release/tenzro-node --roles validator --data-dir ./data

# Light client
./target/release/tenzro-node --roles light --data-dir ./data

# One node serving inference and holding storage under one stake
./target/release/tenzro-node --roles ai,storage --data-dir ./data

Run Your Own Network

# Bootstrap a self-contained network: validator keyset, schema-v1 genesis,
# service unit, and the exact join command for each peer
tenzro setup --path local --network-name lab

# Join an existing private network
tenzro setup --path private --genesis ./genesis.toml --bootstrap <multiaddr>

Become a Provider

Bring your GPU, cluster, or data center and earn from network demand. With a node running (tenzro-node --roles ai), one command handles everything:

tenzro join --provider

Hardware detection, wallet provisioning, faucet funding, the 1,000 TNZO compute bond the model-provider rung requires, provider registration, default pricing, and pulling + serving the largest catalog model that fits your machine are all automatic. Your capacity is advertised on the provider gossip topic and inference demand routes to you, settling in TNZO per call.

AI Inference

# List available models
tenzro model list

# Serve a model as a provider
tenzro model serve --model gemma3-270m

# Start an interactive chat session
tenzro chat

Protocol Servers

The node exposes 4 protocol servers, plus 6 ecosystem MCP servers:

Core Servers

Server	Port	Protocol	Endpoints
JSON-RPC	8545	HTTP	932 methods across 31+ namespaces (EVM-compatible + Tenzro extensions, incl. multi-modal AI: forecast, vision, text-embed, segmentation, detection, audio, video; generative media; MoE sharded serving; LAN clustering; managed databases; app hosting: sites, functions, machines, leases; CAIP discovery; EIP-7702 delegation; Permit2; Secure-Mint; Capital Intent; Workflow). The same listener also serves the OpenAI-compatible HTTP routes /v1/chat/completions, /v1/responses, and the HTTP 402-gated /api/paid/chat/completions
Web API	8080	REST	Verification (/verify/*), /status, /faucet, /health, /chat, /providers, /discovery/resources, OAuth token/introspect/revoke, passkey wallet
MCP	3001	Streamable HTTP	535 tools + OAuth 2.1
A2A	3002	JSON-RPC + SSE	Agent Card with 40 skills, task streaming

Ecosystem MCP Servers

Server	Port	Tools	Coverage
Solana	3003	14	Jupiter swaps, SPL tokens, Metaplex NFTs, Bonfida SNS
Ethereum	3004	17	Chainlink feeds, ENS, ERC-8004 agents, EAS attestations
Canton	3005	23	DAML contracts, CIP-56 tokens, DvP settlement, user/party management, IDP administration
LayerZero	3006	21	V2 messaging, OFT, Stargate, Value Transfer API
Chainlink	3007	21	CCIP, data feeds/streams, VRF v2.5, automation, functions
LI.FI	3008	9	Cross-chain aggregation, routing, gas estimation

Authentication (Tiered)

• Public tools (no auth): get_node_status, list_models, get_balance, resolve_did, debridge_search_tokens, etc.
• Write tools (auth required): send_transaction, create_wallet, stake_tokens, register_identity, etc.
• Auth method: OAuth 2.1 + DPoP (RFC 9449) — bearer JWT minted via tenzro_onboardHuman / tenzro_onboardDelegatedAgent / tenzro_onboardAutonomousAgent. Each request carries Authorization: DPoP <jwt> plus a fresh DPoP: <proof> header (per-request JWS-compact, bound to the JWT's cnf.jkt thumbprint per RFC 7638). RAR scopes (RFC 9396) constrain the JWT to specific tools and amounts.
• API keys (operator-issued): tnz_... keys minted by the RPC operator via tenzro_createApiKey (admin-token-gated) and presented as X-Tenzro-Api-Key. Scopes gate methods that consult third-party paid resources: canton (Canton JSON Ledger API), chainlink (Ethereum mainnet RPC quota for Chainlink Data Feeds + bridge fee oracle + per-adapter sponsorship), evm / svm / inference / tee / bridge for operators who monetise those surfaces. Per-tenant counters in CF_CANTON_ANALYTICS + CF_BRIDGE_ANALYTICS. GCRA rate-limit on chainlink-scoped methods.
• Revocation: tenzro_revokeJwt (single token by jti) or tenzro_revokeDid (cascading through the act-chain).
• Config: TENZRO_MCP_AUTH=tiered (default) | false (dev) | full (all tools require auth)

Key Features

Multi-VM Execution — three VMs, one state machine

---

View the full README on GitHub