Tenzro MCP Server

Decode the (address, string) return data of an IdentityRegistry.getAgent() eth_call into { agent_address, metadata_uri }.

Decode the bytes return data of an IdentityRegistry.getMetadata() eth_call into { metadata_value }.

ABI-encode ReputationRegistry.appendResponse(uint256 agentId, bytes32 feedbackId, string responseURI) (ERC-8004 v0.6+ mutator). Returns hex calldata.

ABI-encode ReputationRegistry.submitFeedback(bytes32 subjectAgentId, int8 rating, string contextURI). Rating is in -100..=100.

ABI-encode IdentityRegistry.getAgent(uint256 agentId). Returns hex calldata for an eth_call lookup.

ABI-encode IdentityRegistry.getAgentURI(uint256 agentId) (ERC-8004 v0.6+ read). Returns hex calldata.

ABI-encode IdentityRegistry.getAgentWallet(uint256 agentId) (ERC-8004 v0.6+ read). Returns hex calldata.

ABI-encode ReputationRegistry.getFeedback(bytes32 subject, uint256 index). Returns hex calldata for an eth_call lookup.

ABI-encode ReputationRegistry.getFeedbackCount(bytes32 subject). Returns hex calldata.

ABI-encode ReputationRegistry.getFeedbackResponses(uint256 agentId, bytes32 feedbackId) (ERC-8004 v0.6+ read). Returns hex calldata.

ABI-encode IdentityRegistry.getMetadata(uint256 agentId, string metadataKey) (ERC-8004 v0.6+ read). Returns hex calldata.

ABI-encode ValidationRegistry.getValidation(bytes32 requestHash) (ERC-8004 v0.6+ read). Returns hex calldata.

ABI-encode ReputationRegistry.isFeedbackRevoked(uint256 agentId, bytes32 feedbackId) (ERC-8004 v0.6+ read). Returns hex calldata.

ABI-encode IdentityRegistry.register() (ERC-8004 v0.6+ no-arg overload — caller becomes agent owner; registry allocates a sequential uint256 agentId). Returns hex calldata.

ABI-encode IdentityRegistry.register(string agentURI, (string,bytes)[] metadata) (ERC-8004 v0.6+ overload with metadata entries). Returns hex calldata.

ABI-encode IdentityRegistry.register(string agentURI) (ERC-8004 v0.6+ overload with agent URI). Returns hex calldata.

ABI-encode ReputationRegistry.revokeFeedback(uint256 agentId, bytes32 feedbackId) (ERC-8004 v0.6+ mutator). Returns hex calldata.

ABI-encode IdentityRegistry.setAgentURI(uint256 agentId, string metadataURI) (ERC-8004 v0.6+ mutator). Returns hex calldata.

ABI-encode IdentityRegistry.setAgentWallet(uint256 agentId, address newWallet, uint256 deadline, bytes signature) (ERC-8004 v0.6+ wallet rotation). Returns hex calldata.

ABI-encode IdentityRegistry.setMetadata(uint256 agentId, string metadataKey, bytes metadataValue) (ERC-8004 v0.6+ key-value metadata). Returns hex calldata.

ABI-encode ValidationRegistry.validationRequest(address validatorAddress, uint256 agentId, string requestURI, bytes32 requestHash). Returns hex calldata.

ABI-encode ValidationRegistry.validationResponse(bytes32 requestHash, uint8 response, string responseURI, bytes32 responseHash, string tag). Response is a 0..=100 quality score.

List all hostname aliases and the site_ids they resolve to.

List all claimed custom domains and their site_ids.

List all site placements across the node.

Claim a custom domain (e.g. app.example.com) for a site. Returns the DNS TXT proof to publish before verification. Requires a signed did_envelope.

Read a published site's manifest by site_id: routes, index/not-found paths, SPA flag, price per request, and placement.

Resolve a public hostname to its site_id.

Read a custom domain's claim/verification state for a site.

Read a site's current serving-node placement.

Publish a static site (any framework's static export). Uploads the route map of BLAKE3 blob hashes; the node serves them over the tenzro/http ALPN behind wildcard TLS. Returns the site_id. Mutations require a signed did_envelope matching owner_did.

Remove a published site by site_id. Requires a signed did_envelope matching owner_did.

Unmap a public hostname alias. Requires a signed did_envelope matching owner_did.

Remove a claimed custom domain. Requires a signed did_envelope matching owner_did.

Clear a site's pinned placement, reverting to local serving. Requires a signed did_envelope.

Map a public hostname (e.g. my-app.apps.tenzro.xyz) to a site_id. Requires a signed did_envelope matching owner_did.

Pin a site's serving nodes (iroh EndpointId strings). An empty list reverts to serving locally on this node. Requires a signed did_envelope.

Verify a claimed custom domain against its published DNS TXT proof, activating wildcard-independent TLS for it. Requires a signed did_envelope.

Inspect an AgentBond by agent DID. Returns lifecycle state (Active / Cooldown / Frozen / Slashed / Returned), amount, controller, cooldown_until, last_modified_block, and promotion eligibility. Returns null if no bond exists.

Fetch all capability attestations issued for a specific agent (by agent ID). Returns the agent's registered capabilities, every attestation that names the agent across all capabilities, and the agent's registered wallet address (used by the self-attestation guard).

Read the current UTC-day spend window for a machine agent. Mirrors `tenzro_getAgentDailySpend`: the handler resets the window if the last_reset crossed UTC midnight before returning. Returns {agent_did, current_daily_spend, max_daily_spend, remaining, last_reset}. Use to enforce the runtime SpendingPolicy ceiling (defence-in-depth on top of the on-chain ERC-7579 spending-limit validator).

Resolve a single agent JWK by RFC 9421 keyid. Accepts `did:tenzro:...` (first compatible key) or `did:tenzro:...#fragment` (specific key). Mirrors GET /.well-known/jwks.json/:keyid.

Get details about a specific agent template in the Tenzro Agent Marketplace. Returns template configuration, capabilities, pricing, and usage statistics.

Get statistics for an agent template on the Tenzro Network marketplace. Returns total spawns, average rating, and total number of ratings.

List all Tenzro agent public signing keys as an RFC 7517 JWK Set. Mirrors GET /.well-known/jwks.json. External RFC 9421 verifiers (Visa TAP, Mastercard, Stripe MPP, AP2, x402) use this to resolve `keyid` parameters.

List agent templates from the Tenzro Network agent marketplace. Browse available AI agent configurations that can be deployed. Filter by type, tag, creator, or price.

Run an agentic task loop for an agent. The agent calls an LLM with built-in tools (spawn_agent, delegate_task, collect_results, complete) and executes them iteratively until done or the maximum step limit is reached.

Run (invoke) a spawned agent template. For paid templates, the `payer_wallet` is charged: the network commission (5%) goes to the treasury and the remainder is paid to the template's `creator_wallet`. `tokens_estimate` is used for per-token pricing. Set `dry_run=true` to simulate without charging fees or dispatching real transactions. Successful non-dry-run invocations are metered (invocation_count + total_revenue) and persisted.

Search agent templates on the Tenzro Network marketplace by query. Matches against template name, description, and tags using case-insensitive substring search.

Update metadata for an agent template you own. Change description, version, status, or tags. Returns the updated template record.

Fetch a workflow by 32-byte hex id. Returns the full Workflow record (creator, participants, obligations, approval gates, status, canton_mirror, signatures). Read-only. Writes use send_transaction with the workflow privileged-VM selectors.

Full lifecycle history for a workflow: ordered list of LifecycleTransition entries (from-status, to-status, reason, actor, at). Useful for audit and dispute resolution.

Snapshot of workflow operational metrics (workflows/obligations/approvals partitioned by status, signature totals, canton-mirror count, fee routes, privacy domains). Returns the same data as the /metrics scrape, but as typed JSON.

Fetch a single workflow receipt by 32-byte hex id. Receipts are append-only and form a per-workflow hash chain via prev_receipt for audit.

Read the current state of a saga workflow (steps, statuses, escrows, receipt). Mirrors tenzro_getWorkflowSaga.

Walk a workflow's receipt chain from head backwards via prev_receipt. Returns receipts oldest-last, bounded by `max` (default 256). Use this for audit trails and dispute history.

Finalize a saga workflow once all steps are Verified: compute the receipt hash and mark it Completed. Mirrors tenzro_workflowFinalize.

Open a multi-agent saga workflow: declare ordered steps (each with an Execute→Verify→Compensate lifecycle) plus optional per-step escrow. Returns the opened saga. Mirrors tenzro_workflowOpen.

Compensate a saga step (and, with cascade=true, every lower-index executed/verified step in reverse order), refunding still-funded per-step escrow (vault→payer). Mirrors tenzro_workflowStepCompensate.

Execute a saga step: transition it Pending→Executing and, if escrow_amount is set, lock a per-step escrow (payer→vault). Mirrors tenzro_workflowStepExecute.

Verify a saga step: transition it Executing→Verified, release any per-step escrow (vault→payee), and emit ERC-8004 reputation feedback for the step executor. Mirrors tenzro_workflowStepVerify.

Return the catalog MoE topology for a model (num_experts, experts_per_token, shared_experts, params_per_expert_x10) and its architecture. The moe field is null for dense models.

Load a per-expert safetensors weight blob (gate_proj/up_proj/down_proj) into this node's MoE expert runtime, from an inline base64 blob or a tenzro://blob URI. Returns the resident expert's dimensions and byte footprint.

Snapshot of this node's resident MoE experts and gating networks: each entry's residency tier (memory / disk), byte footprint, the total footprint, the memory budget, and whether GPU compute is active.

Run a distributed MoE forward for one layer: gate-route the hidden-state batch locally, fan expert sub-batches out to holders (local runtime, iroh tenzro/moe ALPN, or HTTP JSON-RPC), and gather the gate-weighted combined outputs. hidden_states and outputs are base64 of little-endian f32 bytes.

Load a gating-network safetensors blob (router.weight) for a model layer into this node's MoE expert runtime, from an inline base64 blob or a tenzro://blob URI.

Given per-token top-k routing decisions, return the per-holder batch plan and per-token slot assignments. Set allow_cold to permit routing to experts that are not warm-resident.

Slice a catalog MoE checkpoint into per-expert safetensors blobs (and optionally the layer gate), optionally block-quantizing each projection (q4_k_m / q8_0 / q4_k / q6_k preset, or a per-projection gate/up/down mix), and publish them as tenzro://blob content so holders can load them. Runs asynchronously; returns a job_id to poll with moe_prepare_status. Omit experts to prepare every expert in the layer.

Poll the state of an expert-preparation job started by moe_prepare_experts. Returns the job's model_id, layer, state (running / done / error), any error, and the prepared per-expert tenzro://blob URIs when done.

Return the current replication policy used by shard-view consumers: min/max replication and the hot-expert tokens-per-second threshold.

Return the expert shard map for a model: per-expert holders, replication counts, role counts, the replication policy, and lists of under-replicated and hot experts across known providers.

Bridge tokens through the BridgeRouter pinned to the Chainlink CCIP regulated rail. Refuses the call if no CCIP adapter is registered rather than silently falling back to a generic adapter. Returns transfer_id, tx_hash, fee_paid, estimated_arrival_ms.

Quote a Chainlink CCIP fee via Router.getFee() eth_call. CCIP is Tenzro's regulated rail: OCR commit-store committee + RMN ARM blessing. Returns native fee in wei on the source chain.

List CCIP lanes (source-destination chain pairs). Optionally filter by source or destination chain selector.

Read inbound + outbound rate-limiter state for a (pool, remote-chain) pair. Returns the RateLimiter.TokenBucket tuple (tokens, lastUpdated, isEnabled, capacity, rate).

Prepare a Router.ccipSend() envelope — returns calldata + msg.value ready for the caller to sign and broadcast via eth_sendRawTransaction.

List CCIP-supported chains from the Chainlink docs API.

List CCIP-supported tokens from the Chainlink docs API.

Inspect a CCIP CCT v1.6+ token-pool contract. Returns chain, pool address, and the bound ERC-20 token address read from the pool's getToken().

Track CCIP message execution via OffRamp.getExecutionState(bytes32). States: 0=UNTOUCHED, 1=IN_PROGRESS, 2=SUCCESS, 3=FAILURE.

Register a new AI agent identity on the Tenzro Network. Two modes: (1) provisioner — node provisions a server-side hybrid wallet (FROST Ed25519 + ML-DSA-65 + BLS12-381), returns the classical_public_key + pq_verifying_key_len + bls_verifying_key_len; (2) BYOK — caller supplies `public_key` (32B Ed25519), `pq_public_key` (1952B ML-DSA-65), and `bls_public_key` (48B BLS12-381 G1) hex, registration is self-custodial. Returns agent_id, wallet_address, tenzro_did, registration_fee, and `byok` flag.

Publish an agent template to the Tenzro Network agent marketplace. Templates define reusable AI agent configurations with system prompts, capabilities, and pricing. Others can discover and deploy your template.

Register a developer app in the on-chain app registry. Permissionless and first-writer-wins: the developer signs a DID envelope with their own key; the app wallet is the developer's own TNZO treasury (the network never holds custody). Provide a developer-signed `envelope` (hex header value) bound to the canonical registration params.

Register ERC-3643 compliance rules for a token. Defines KYC requirements, holder limits, country restrictions, and balance caps. All transfers of this token will be checked against these rules.

Register a human or machine identity on the Tenzro Decentralized Identity Protocol (TDIP). Human identities are self-sovereign; machine identities require a controller DID and receive a delegation scope

Register a cross-VM pointer for an NFT collection. Maps the collection to a contract address on another VM (EVM, SVM, or DAML) enabling cross-VM NFT discoverability.

Register as a service provider on the Tenzro Network. Providers earn TNZO by validating blocks, carrying RPC traffic, providing TEE enclaves, serving AI models, renting accelerators, providing storage, operating cloud services, or training and syncing models.

Register or replace an issuer's stable-asset policy (issuer-agnostic stable-unit issuance on the Secure-Mint reserve floor). Requires the `issuer` API-key scope.

Register a webhook URL for event notifications. The Tenzro node will POST JSON event payloads to the registered URL when matching events occur. Each POST includes an HMAC-SHA256 signature in the X-Tenzro-Signature header for verification. URL must be `https://`; secret must be at least 16 characters. Requires owner_did plus a signed did_envelope proving control of it — the owner is what delete and list authorize against.

Assign a solver to a capital intent; if `payer` is set, lock the principal escrow up to the authorized ceiling. Mirrors tenzro_capitalIntentAssign.

Compensate (refund the principal escrow and fail) a capital intent. Mirrors tenzro_capitalIntentCompensate.

Record one executed settlement leg of a capital intent. Mirrors tenzro_capitalIntentExecute.

Open a signed Capital Intent — regulated capital allocation over tokenized assets (the capital-markets analog of an AP2 Intent Mandate; objective = acquire/exit/rebalance/hedge/yield, with reg regime + KYC + ceilings). Mirrors tenzro_capitalIntentOpen.

Submit a solver bid to fulfil a capital intent (ranked by ERC-8004 + KYA). Mirrors tenzro_capitalIntentQuote.

Settle a capital intent: release escrow to the solver, write ERC-8004 feedback, finalize with a receipt. Mirrors tenzro_capitalIntentSettle.

Verify a capital intent's proofs (requires all legs settled). Mirrors tenzro_capitalIntentVerify.

Read a capital intent record (status, quotes, legs, escrow, receipt). Mirrors tenzro_getCapitalIntent.

Load an ASR ONNX model (Moonshine, Distil-Whisper, Whisper-v3-turbo, Parakeet-TDT-v3, Canary-1B-Flash) from files already on the node's filesystem. Either pass `catalog_id` to inherit `family` / `max_audio_seconds` / `whisper_variant` from the catalog and enforce its license tier, or set them explicitly. Which auxiliary paths are required depends on the family: 'moonshine' and 'whisper' need `tokenizer_path`, 'parakeet' and 'canary' need `preprocessor_path` + `vocab_path`. The ORT-backed transcribers ship behind an audio feature flag; default node builds return ProviderNotAvailable until built with that feature.

Load a detector (RF-DETR, D-FINE) from an ONNX file already on the node's filesystem. `catalog_id` supplies the family, input resolution and class count from the catalog and enforces the entry's license tier; otherwise set `family`, `input_size` and `num_classes` yourself.

Load a forecast (timeseries) ONNX model into the node's runtime. The file at `path` must be a valid ONNX export. Either pass `catalog_id` to inherit context_length/max_horizon/output_name/batch_size from the curated catalog and enforce its license tier, or set them explicitly. For multi-output graphs (TimesFM 2.5 transformers export), `output_name` selects the prediction tensor and `batch_size=2` satisfies the export's flip-invariance averaging.

Load a segmenter (SAM 2 base/large, EdgeSAM, MobileSAM) from an encoder ONNX plus a decoder ONNX already on the node's filesystem. `catalog_id` supplies the family and input resolution from the catalog and enforces the entry's license tier; otherwise set `family` and `input_size` yourself.

Load a text-embedding ONNX model. Two paths: pass a catalog id as `model_id` with no `path` and the node fetches the ONNX graph and tokenizer from HuggingFace onto its models directory, or pass `path` + `tokenizer_path` + `family` for files already on the node, with `catalog_id` supplying embedding_dim and max_sequence_length. This is the one modality with a fetch path — every other loader needs the artifact on the node's filesystem first.

Download (or reuse cached) the SAM-3 family ONNX bundle from HuggingFace Hub and register it under model_id. Bundle contains image encoder, language (CLIP) encoder, decoder, and CLIP tokenizer.

Register a clip-level video encoder over an already-loaded image encoder. Video embedding is frame-based: the node extracts `num_frames` evenly-spaced frames, embeds each through the encoder named by `vision_model_id`, and mean-pools. Load that image encoder first with load_vision_model — an unloaded `vision_model_id` is refused with JSON-RPC -32004.

Load a vision encoder ONNX into the node. Either pass `catalog_id` to inherit input_size/embedding_dim/normalization from the curated catalog, or set them explicitly. Returns when the ORT session is ready.

Unload a registered ASR model, freeing its ORT session.

Unload a registered detector, freeing its ORT session.

Unload a registered forecast model from this node, freeing its ORT session.

Unload a registered segmenter, freeing its ORT session.

Unload a registered text-embedding model, freeing its ORT session.

Unload a registered SAM-3 segmenter, freeing its three ORT sessions (image encoder, language encoder, decoder).

Unload a registered video encoder, freeing its ORT session.

Unload a registered vision encoder, freeing its ORT session.

Book a compute rental against this node's compute provider. The renter pre-funds total_epochs from their deposit.

Pure preview: how would a `gross_wei` amount be split across a fee route's recipients? Truncates to last for the remainder. Does not settle — settlement is consensus-mediated.

Look up a compute rental by id.

Set the per-epoch compute pricing policy. Use mode "dynamic" with a non-zero capacity and optional min_rate/max_rate bounds; fixed-rate is the spawn default.

Settle one epoch of an active compute rental, gated on the provider's availability proof. A valid proof streams the epoch slice to the provider; an invalid or missing proof makes the renter whole from stake.

Summary of this node's compute-rental state: effective rate and active rental count.

Read compute bonds — the admission collateral a provider must post before register_provider will accept it. Pass provider_did for one bond, or omit it to list every bond on the node. Always returns the node's minimum bond and withdrawal cooldown so a caller can see what admission requires.

Register a database this node serves, computing and persisting its partition placement over the live cluster. owner_did becomes the admin authority (owner-only access policy). placement is 'local', 'lan_cluster', or 'network'. Returns {database, partitions}.

Run an engine-dialect query against a database partition. caller_did is authorized against the access policy (writes require the admin action, reads the read action) before any engine is touched. When this node holds the target partition the result carries served_here=true and the engine result; otherwise it carries holder endpoints.

Read per-query pricing and cumulative usage counters (queries, writes, bytes in/out, total billed) for a database. Administrative — caller_did is gated on the admin (write) action.

Look up a database descriptor by id.

Return the placement of one partition.

List the database engines this node can serve — each with its data models, license, sharding model, and native-cluster topology. Engines are operator-run externals (PostgreSQL, Qdrant, Valkey) and in-process embedded engines (Lance, Tantivy).

List every partition placement of a database.

Add an additional WebAuthn device credential to an existing passkey-bound smart account. The account must already have at least one enrolled credential.

Add a social-recovery guardian to a smart account. The guardian holds an Ed25519 + ML-DSA-65 composite key and will be asked to sign rotation proofs when the user loses access to their primary passkey.

Create a pending browser-launch passkey ceremony session (enroll a new account, add a device credential, or sign over an op hash). Returns a session id and the node-served /auth/passkey URL to open in a browser; the browser runs navigator.credentials.create()/get() and the caller polls get_passkey_session until the session reaches a terminal status.

Get a smart account's second-factor policy: the policy name, how many passkey signatures each operation requires, and how many credentials are enrolled.

Poll a browser-launch passkey ceremony session by id. Returns the session kind, status (pending/in_flight/completed/failed/expired), and — once terminal — the handler result or error.

Revoke a single WebAuthn credential from a passkey-bound smart account by credential id. The account stays usable while at least one other credential survives; removing the last one leaves it recoverable-only until a guardian finalizes a recovery.

Set a smart account's second-factor policy. "single_credential" (default): one enrolled passkey approves each operation. "two_credentials": two distinct enrolled passkeys must both sign every operation (requires at least two enrolled credentials).

Verify a Tenzro DID envelope carried as a tool argument (the hex X-Tenzro-DID-Envelope value). Supports did:tenzro (registry), did:key, did:ethr (recoverable secp256k1), and did:web (resolved over HTTPS). Returns {valid, did, method} or {valid:false, error}. MCP-native carriage: tool calls expose no HTTP headers, so the envelope rides as an argument.

Verify a stored inference commitment by re-executing the prompt+output as a single prefill and comparing per-step top-k logits. The caller supplies the exact prompt (never stored). Requires the model loaded in serial (llama.cpp) mode on this node. Returns {commitment_hash, model_id, provider, pass, steps_total, steps_passed, failing_steps}. Mirrors tenzro_verifyInferenceCommitment.

Verify a payment credential against a previously created challenge and settle the payment on-chain

Verify a cryptographic signature against a public key and message. Returns whether the signature is valid.

Verify a TEE attestation report. Checks the vendor certificate chain, signature, and measurement hashes. Returns verification status and details.

Verify a Tenzro VRF proof (RFC 9381 ECVRF-EDWARDS25519-SHA512-TAI). Returns the deterministic 64-byte VRF output if the proof is valid. Used for provably-fair NFT reveals, lotteries, and randomized trait assignment.

Verify a Plonky3 STARK proof (over KoalaBear) on the Tenzro ledger. Requires a circuit_id ('inference', 'settlement', or 'identity').

List the x402 scheme backends registered on this node. Each scheme corresponds to a different verification path under the x402 protocol: 'tenzro-hybrid' (Ed25519 hybrid sig over canonical preimage), 'exact-eip3009' (USDC EIP-3009 meta-tx via CDP facilitator), 'permit2' (Uniswap Permit2 via CDP facilitator), 'erc7710' (delegation redemption). Use the returned ids in the 'extra.scheme' field of an x402 PaymentRequirement.

Remove a Bazaar listing. Refused unless seller_did owns the listing. Returns {removed}.

Query the x402 Bazaar for paid resources. All set filters are ANDed; unset filters match everything. Each listing carries seller_reputation joined from the provider-reputation ledger (settled payments are the only score-up path). Results are highest-reputation-first (unscored last), freshest within the same score, capped by limit when non-zero. Returns {listings, count}.

Derive the deterministic pay_<hex> idempotency id for an (offer, payer) pair so a buyer can detect and skip a retry client-side. Pass either the full requirement (node recomputes the commitment) or a 64-hex offer_commitment, plus payer_did.

Describe the x402 protocol surface this node exposes: registered schemes, supported networks/assets, and the Bazaar discovery endpoints.

List a paid HTTP resource in the x402 Bazaar so buyers can discover it. scheme is an x402 scheme id ('tenzro-hybrid', 'exact-eip3009', 'permit2', 'erc7710'). Returns the assigned listingId.

Verify a server-signed x402 offer before paying. Pass the full X402PaymentRequirement JSON exactly as it appeared in the 402 body. The node recomputes the commitment and verifies the Ed25519 signature under the carried signer key. Returns {valid, offerCommitment, offerSigner}.

Read the Babylon finality-provider record for a Tenzro validator.

List BTC delegations for a finality provider.

List every registered Babylon finality provider.

Register a Tenzro validator as a Babylon finality provider. Tenzro validators are then economically secured by native BTC delegations through Babylon's finality-providers protocol.

Submit an EOTS (Extractable One-Time Signature) over a Tenzro block hash. Equivocation slashes the BTC delegations bonded to the finality provider.

Sum BTC delegations for a finality provider.

Get a bridge quote without executing the transfer. Returns estimated output amount, fees, estimated time, and recommended route. Useful for previewing costs before committing to a bridge transfer.

Bridge tokens between blockchains. Supports routes between Tenzro, Ethereum, Solana, and Base via LayerZero, Chainlink CCIP, and deBridge adapters

Execute a bridge transfer with a deBridge post-fulfillment hook. After the tokens arrive on the destination chain, the hook_target contract is called with hook_calldata. Enables composable cross-chain operations (e.g., bridge + swap, bridge + stake).

Get available bridge routes between two chains, including estimated fees, time, and which adapter handles the route

List all registered bridge adapters (LayerZero, Chainlink CCIP, deBridge, Canton)

Enumerate the canonical per-adapter bridge sponsorship-pool vault addresses. Vault addresses are deterministic SHA-256 over 'tenzro/bridge/sponsorship-vault' || adapter_str (first 20 bytes).

Unlink a file from the caller's account and stop its storage deal. This is NOT erasure: objects are content-addressed and erasure-coded across independent providers, so deletion cannot reach into every provider holding a shard. Shards expire when the deal stops paying for them. Do not treat deletion as redaction — the response repeats this on every call.

File a challenge against a stored inference commitment. Open to any caller; the model and provider are read from the stored envelope so filings cannot misattribute. Returns the filed challenge record with its challenge_id. Mirrors tenzro_fileInferenceChallenge.

File an insurance claim against a bonded agent (Agent-Swarm Spec 9). The claim enters Open status awaiting governance adjudication; payout (if approved) is settled by a separate PayInsuranceClaim transaction. Returns the full ClaimRecord including the deterministic claim_id.

What the caller is storing on this node: file count, total bytes, how many files have an open storage deal (and how many do not — those are stored but unbilled), and the derived billing address their deals settle against.

File a fraud proof against an attested ZK commitment inside its fraud window. This node fetches the proof from the commitment's DA locator, re-runs the Plonky3 verifier deterministically, and adjudicates: 'unfounded' (proof re-verified, commitment stands, challenger bond forfeit) or 'upheld' (proof failed, commitment retracted from the ZK_VERIFY registry, every co-signer on the certificate slashed for a consensus offence). Any staked party may file.

Fetch one file's record — size, filename, purpose, creation time, and the storage deal funding it. A file belonging to another tenant reports the same "no such file" as one that does not exist, so ownership cannot be probed by guessing ids.

Look up a single Tenzro Media Gen job by id. Returns null when this node has never seen it. On a split job the assignments array shows which halves of the denoising schedule are already claimed.

Fetch the signed receipt sealing a completed Tenzro Media Gen job. Returns null while the job is still open. The receipt commits to output_hash, output_mime, output_bytes, the params actually rendered, and the worker's signature.

List the curated generative-media catalog: ungated diffusers pipelines serving text2image, image2image, text2video, or image2video. Each entry carries id, hf_repo, pipeline_class, kinds, default resolution and steps, min_vram_gb, license, and expert_pair. A non-null expert_pair means the denoising schedule splits across two workers, so a claim on that model needs a role.

List the Tenzro Media Gen jobs this node holds, optionally filtered by status. Each job carries job_id, task_spec, status, required_roles, assignments, handoff-if-split, and receipt-if-complete. Read-only — safe for monitoring agents.

List the generative-media workers enrolled on this node. Each entry carries worker_did, supported_models, expert_holdings (the halves of a split model it has resident), max_resolution, max_frames, and gpu_vram_gb. Read-only.

Price a Tenzro Media Gen job before posting it. The work unit is the pixel-step (width x height x steps x frames). Returns kind, pixel_steps, per_pixel_step, base_fee, and quote as decimal attoTNZO strings. Read-only — nothing is queued.

Get the current pricing configuration for a provider node. Returns the per-token rates, the per-unit rates for every other billable dimension, and the network ceilings.

Get the availability schedule for a provider node. Returns the configured hours, days, and timezone when the provider accepts inference requests.

Get provider statistics including served models, inference count, staking info, and earnings. Omit address to get stats for the local node.

List providers with published capacity across the Tenzro network. For each provider returns both the advertised capacity (its own claim: max concurrent requests, requests/sec, batch size, MTP support) and the measured throughput this node has observed (tokens/sec, p95 latency, reputation, and a reputation-discounted throughput figure). Includes this node's local providers (source=local) and gossip-discovered peers (source=network). Mirrors tenzro_listProviderCapacity.

Set the pricing configuration for a provider node. Token prices are wei per token (1 TNZO = 10^18 wei); the optional rates cover cached tokens, reasoning loops, image tokens, audio and video seconds, denoising pixel-steps and consumed frames. Every rate is held at or below the network per-unit ceiling. Returns the updated pricing config.

Set the availability schedule for a provider node. Define which hours and days the node will accept new inference requests. Returns the updated schedule.

Run one proof-of-retrievability-gated charge epoch for a storage deal. Charges only when the retrievability challenge passes.

Look up a storage deal by id.

Open a streaming storage deal for an already-stored object. The renter pre-funds total_epochs from their deposit; the per-epoch price is size × rate.

Set the byte-epoch storage pricing policy. Use mode "dynamic" with a non-zero capacity and optional min_rate/max_rate bounds; fixed-rate is the spawn default.

Summary of this node's storage-provider state: effective rate and stored object count.

Store an object on this node's storage provider with an erasure-coded redundancy scheme. Returns the object id, stored size, and shard counts.

Browse the curated ONNX text-embedding catalog: Qwen3-Embedding (0.6B/4B/8B), EmbeddingGemma-300M, BGE-M3, ModernBERT-embed (base/large). Each entry carries embedding_dim, supported Matryoshka truncations, and license tier.

List text-embedding models currently loaded on this node (Qwen3-Embedding, EmbeddingGemma, BGE-M3, etc.). Use list_text_embedding_catalog to browse the curated catalog.

Browse the curated ONNX text-promptable segmentation catalog: SAM 3 / SAM 3.1 (Meta) — open-vocabulary text-promptable segmenter, ViT-H backbone, 1008x1008 input, 32-token CLIP BPE language encoder.

List text-promptable segmenters currently loaded on this node (SAM 3 family). Use list_text_segmentation_catalog to browse the curated catalog.

Embed a batch of strings with a registered text encoder. Returns one row per input. Optional `requested_dim` enables Matryoshka truncation (e.g. 128/256/512 from a native 768/1024-dim model).

Run open-vocabulary text-promptable segmentation. Provide a free-text label (e.g. 'person', 'dog') and an image; optionally narrow with a normalized cxcywh box. Returns a variable number of detections, each with a bbox (x0,y0,x1,y1 pixels), score, and binary mask resampled to original image dimensions.

Create a cross-chain transaction via deBridge DLN. Returns transaction data ready for signing and submission.

Get all blockchain networks supported by deBridge DLN for cross-chain transfers.

Get deBridge operational instructions and guidance for cross-chain transfers.

Execute a same-chain token swap via deBridge. Swaps tokens on the same blockchain without cross-chain bridging.

Search for tokens available on deBridge DLN. Returns token addresses, symbols, and supported chains.

Execute a DvP saga: run each escrow leg forward (release vault→payee). Signature-gated / custom-condition escrows require a per-leg release proof supplied via `proofs`. Any leg failure triggers automatic compensation (refund vault→payer) of already-executed legs. Mirrors tenzro_dvpExecuteSaga.

Finalize a DvP saga once every leg has executed: compute the receipt and mark it Completed. Mirrors tenzro_dvpFinalizeSaga.

Read the current state of a DvP saga (legs, per-leg outcomes, escrows, receipt). Mirrors tenzro_dvpGetSaga.

List DvP sagas opened by a creator address. Returns {creator, count, sagas: [...]}. Mirrors tenzro_dvpListSagasByCreator.

Open a delivery-versus-payment saga: bundle two or more legs (delivery + payment) into an all-or-compensate unit. Only escrow-venue legs are saga-executable (the payer pre-funds and authorizes the escrow, so release/refund needs no fresh signature); native/channel/external legs are rejected. Returns the opened saga. Mirrors tenzro_dvpOpenSaga.

Fetch a single ERC-7683 FillRecord by (order_id, origin_chain_id). Returns the record JSON, or -32000 if no fill has been recorded.

Fetch a single Tenzro7683Order envelope by 32-byte order_id. Envelope is persisted in CF_SETTLEMENTS under the `7683_origin:` keyspace. Order state machine: Open → AwaitingProof → Settled / Refunded / ForceRefundEligible.

List every recorded destination-side FillRecord on this node. Cardinality is bounded — registry holds at most one FillRecord per cross-chain order ever filled here.

Paginated scan over persisted ERC-7683 orders in the `7683_origin:` keyspace. Optional state filter (open / awaiting_proof / settled / refunded / force_refund_eligible) and CAIP-2 dest_chain filter.

Destination-side commit of an ERC-7683 FillRecord (single-shot per order_id — re-submission returns -32010 OrderAlreadyFilled). Required fields: order_id, origin_chain_id, origin_settler, filler, recipient (32-byte), fill_tx_hash, filled_at_ms, proof_route, outputs[].

Deploy a long-running microVM (Firecracker) from a content-addressed image. Placed only on KVM+nested-virt nodes; optionally TEE-sealed. Env vars are wrapped to the node's X25519 sealing key. Requires a signed did_envelope.

Read a deployed machine's manifest: artifact CAID, internal port, resources, TEE requirement, price, and placement.

Remove a deployed machine by id, tearing down the microVM. Requires a signed did_envelope matching owner_did.

Fetch this node's X25519 machine sealing public key. Wrap machine env-var ciphertext to it (alg x25519-hkdf-sha256-envelope-aes-256-gcm) before machine_deploy.

Read a running machine's live status: lifecycle state, serving node, and last heartbeat.

Delete a model from this node's local storage. The model must not be currently serving. Frees disk space. Returns deletion confirmation.

Read the canonical content-hash record for a model from the transparency log: the BLAKE3 + SHA-256 over the canonical weight bytes plus the per-file manifest hash, the recorder DID, and the record epoch. This is the trust root a fetcher verifies downloaded weights against before load. Open — no auth

List all model service endpoints with their API and MCP URLs, model details, and status

List every recorded canonical model hash on this node. Each entry carries the model ID, BLAKE3, SHA-256, manifest hash, recorder DID, and record epoch. Open — no auth

Get this node's X25519 public key for sealed-model distribution. A publisher includes this key in a recipients entry when sealing a model addressed to this node

Operator-only. Revoke an API key by its non-secret `key_id`. Requires `X-Tenzro-Admin-Token`. Fails with `-32004` if the target is an `operator_protected` key (those cannot be revoked via RPC, by anyone, including an admin — rotate by updating the operator secret and restarting the node).

Revoke a JWT by its jti. Requires a signed did_envelope from the token's bearer DID or the controller DID that authorized it — a jti travels in every audit row, so knowing one is not authority to destroy it. Cascades to any tokens minted from the revoked token.

Subject-gated. Revoke an API key belonging to the caller's own subject. Requires `X-Tenzro-Api-Key`. Only `subject`-class keys are eligible. The error for "no such key" and "not your key" is intentionally the same so ownership cannot be probed.

Revoke an active wallet session immediately. Requires a signed did_envelope from the DID that owns the session's wallet. The session ID becomes invalid and any pending operations under this session are cancelled.

Revoke a smart account's session-key validator config.

Read the Secure-Mint policy for an asset.

Atomic check + circulating increment. Use after the invariant check has passed off-chain.

Read-only invariant check for a proposed mint. Returns `{would_succeed, reserve, circulating, headroom, reason?}`.

Record a redemption — decrements circulating. Call after the off-chain burn is finalized.

Set or update a Secure-Mint policy for a tokenized real-world asset. Enforces per-token 1:1 reserve attestation `circulating + amount ≤ reserve` at every mint.

Fetch a SeedAgent governance charter by 32-byte id. Charter enumerates OperationKind (InferenceConsumer / TaskMarketplaceConsumer / etc.), spend caps, throughput target, counterparty filter, and sunset deadline.

Show the genesis SeedAgent treasury earmark — total TNZO allocation, draw-down to date, decay schedule, seed-agent count, surplus burn bps at sunset. The earmark funds protocol-owned bootstrap agents for the first 12 months.

Get network activity counters (inference / settlement / bridge / ERC-7683). exclude_seed=true filters out flows where either side `is_seed_agent`, isolating organic activity from protocol bootstrap traffic.

List provisioned SeedAgent records. Each record carries agent_did, controller_did, status (Active/Paused/Quarantined/Terminated), allocation drawn, and optional bond id. Filter by charter_id to scope to one charter's roster.

List every SeedAgent governance charter registered on this node.

Ask the Tenzro Train syncer for its round decision. Returns `{decision: "wait", remaining_ms}` while the grace window is open, `{decision: "finalize", round}` once a witness quorum endorses the round, or `{decision: "no_quorum", round}` when the window elapses without a quorum (the run advances, carrying the prior state root forward). Returns JSON-RPC -32602 when the run is unknown. Read-only — safe for monitoring agents.

Fetch the sealed receipt for a finalized Tenzro Train run. Returns null when the run is still active. Persisted under CF_TRAINING_RECEIPTS — carries final_state_root, rounds_completed, witness_committees, optional manifest_hash, sealed_at_ms.

Look up a single Tenzro Train run by task_id. Returns the full read-side view (task_spec, status, current_round, state_root, enrolled_trainers, metadata, receipt-if-terminal). Returns JSON-RPC -32602 when the run is unknown.

Fetch the installed sealed-shard manifest for a Confidential-tier Tenzro Train task. Returns null when no manifest has been installed (Open and Verified tiers never have a manifest). Manifest binds each trainer's encrypted shard, HPKE-wrapped data key, and enclave attestation.

List every active Tenzro Train run this node is syncing. Each run carries task_id, status (Pending/Active/Completed/Failed/Cancelled), current_round, state_root, enrolled_trainers, and (once terminal) the sealed receipt. Read-only — safe for monitoring agents.

Show the current adaptive burn-rate config — base/local/paymaster burn bps with their treasury complements. Paymaster is locked at 100% burn. The dial moves only via on-chain governance proposals (see adaptive_burn_get_recommendation).

Show the latest supply-side metrics snapshot — block height, circulating supply, rolling-window epoch delta, burn/emission breakdown. Drives the recommendation engine.

Show the current adaptive-burn recommendation — action (NoChange / IncreaseBurnPct / DecreaseBurnPct / AlarmHighInflation / AlarmHighDeflation), magnitude bps, and whether it's above the auto-proposal floor. Pure function of metrics + targets, no side effects.

List pending and historical adaptive-burn governance proposals.

Return AP2 protocol metadata: version, supported mandate types, supported VC formats, and issuer DID methods recognized by this node.

Sign an AP2 mandate (Intent or Cart) with the auth-bound wallet's Ed25519 key, returning a verified Verifiable Digital Credential (VDC). Auth: DPoP+JWT mandatory. Wallet must be Ed25519. signer_did must match the wallet's controller DID.

Validate an AP2 v0.2 Checkout+Payment mandate pair for consistency: ensures the PaymentMandate references the CheckoutMandate, amounts/items match the checkout's constraints, and both VDCs verify. When enforce_delegation=true, additionally cross-checks the agent's TDIP DelegationScope against the payment total (TDIP identifies. AP2 authorizes. Tenzro settles).

Verify a single AP2 mandate (Verifiable Digital Credential). Checks the VDC proof, issuer, and schema for Intent, Cart, or Payment mandates per Google's AP2 spec.

Dispatch an Axelar GMP `call_contract` message. Correlation id is `keccak256(payload)`.

Look up an Axelar GMP message by payload hash.

List supported Axelar chains. Reach spans 30+ chains: EVM, Cosmos (Osmosis, Cosmos Hub, Juno, Neutron, Injective, Kujira, Crescent, Evmos), Move (Aptos, Sui), Stellar, XRP Ledger, Hyperliquid, Filecoin EVM, Kava.

Pre-pay the Axelar Gas Service for a previously-dispatched message.

Download and instantiate an agent template. Creates a new agent identity from the template with optional configuration overrides. Returns the new agent DID and wallet.

Retrieve a stored file's contents, rebuilt from its erasure-coded shards and returned base64-encoded. Only the owning subject can read it.

Download a model to this node's local storage. Fetch is peer-first: content-addressed weights are pulled from Tenzro peers over iroh blobs (BLAKE3-verified over the whole transfer), falling back to HuggingFace Hub when no peer holds them. Computes the weights' BLAKE3 and checks it against the canonical hash record (see get_model_hash) before load. Returns download status and progress.

Check the download progress of a model. Returns bytes downloaded, total size, percentage complete, and estimated time remaining.

Build the 23-byte EIP-7702 delegation designator (`0xef0100 || delegate_address`) that gets written into the EOA's code slot once an authorization is accepted. Returns `{designator, length: 23, prefix: '0xef0100', delegate_address}`.

Decode an account's `code` (hex with or without 0x prefix) and extract the delegate address if it is a valid EIP-7702 designator. Returns `{is_designator: false, delegate_address: null}` for code that is not a 23-byte 7702 designator.

Read static metadata about the EIP-7702 support surface — tx type (0x04), magic byte (0x05), designator prefix (0xef0100), designator length (23 bytes), signing scheme (secp256k1), and operator notes on the current transaction-side integration state.

Compute the secp256k1 signing hash for an EIP-7702 authorization tuple `(chain_id, delegate_address, nonce)`. The returned `signing_hash` is what the EOA's secp256k1 private key signs client-side; full preimage is `MAGIC(0x05) || rlp([chain_id, delegate_address, nonce])`. Returns `{signing_hash, signing_data, magic_byte}`.

Dispatch a Hyperlane V3 message through the canonical Mailbox. Tenzro runs a sovereign Tenzro-validator-set ISM, so inbound messages on Tenzro are verified against the active Tenzro validator BLS / ML-DSA set.

Look up a Hyperlane message by id.

List supported Hyperlane chains and their canonical domain ids. Coverage: Ethereum, Polygon, Arbitrum, Optimism, Base, Avalanche, BSC, Mantle, Blast, Scroll, Linea, Manta, zkSync, Celo, Moonbeam, Mode, Fraxtal, Tenzro.

Quote the interchain gas payment for a Hyperlane dispatch.

List newest-first memories for an agent. Optional `kind` filter ('granted' | 'recalled' | 'self_noted' | 'archived'). Pure read against the on-tier text index. Use memory_recall for query-driven hybrid retrieval.

Archive a memory record. Pushes the canonical payload to the configured DA backend, then rewrites the on-tier rows with kind='archived' and the resulting DaPointer attached. Frees hot search budget; payload is fetchable on demand via the pointer.

Grant a memory to an agent on the Tenzro Network. Embeds the text via the configured TextEmbeddingRuntime and writes to both the Lance vector index and the Tantivy BM25 index. Returns the persisted MemoryRecord including its UUID.

Recall memories for an agent. Mode 'hybrid' (default) merges Lance vector kNN and Tantivy BM25 via Reciprocal Rank Fusion (k=60); 'vector' or 'text' restrict to one backend. Returns ranked MemoryRecord stubs (no embeddings).

Compute a multilateral netting batch over a set of bilateral obligations: greedy netting collapses the gross obligation graph into a minimal set of net settlement instructions. Deterministic and idempotent by batch id. Mirrors tenzro_nettingCompute.

Read a netting batch (gross obligations, net settlement instructions, status). Mirrors tenzro_nettingGetBatch.

List all netting batches. Returns {count, batches: [...]}. Mirrors tenzro_nettingListBatches.

Mark a computed netting batch as settled once its net settlement instructions have been executed. Mirrors tenzro_nettingSettle.

Get this node's DID Document — every way of reaching it in one place. A node is addressed five ways (TDIP DID, Ed25519 public key, iroh EndpointId, libp2p PeerId, Pkarr record) plus its JSON-RPC/MCP/A2A/web service URLs; resolving the DID yields all of them. Unroutable bind addresses are omitted rather than advertised, and an ALPN appears only when a handler is actually installed. Returns an error when the node has no provisioned identity.

Get the current status of the Tenzro node including health, block height, peer count, uptime, and role

Return this node's hardware self-profile: linked runtime build commit, CPU architecture, operating system, detected compute devices, and derived serving values (capacity in GB, serving backend, capability key). Each device reports the ggml backend it executes on — CUDA, Metal, Vulkan, ROCm, SYCL, or CPU — and serving_backend is the backend of the strongest GPU-class device, else CPU.

Return this node's sustained connectivity tier. When the network service is not running the tier is null and available is false.

Compute the EIP-712 digest a user signs for a Permit2 SignatureTransfer. If `witness` is provided, binds the permit to that 32-byte witness (used by ERC-7683 origin opens to bind to a specific cross-chain order). Returns `{digest, struct_hash, domain_separator}`.

Read the EIP-712 domain separator for the canonical Tenzro Permit2 contract (0x0000…00001023) on `chain_id`. Returns `{domain_separator, verifying_contract, chain_id}`.

Check whether a (owner, nonce) Permit2 slot has been consumed. Returns `{used, owner, nonce}`.

Atomically verify a signed Permit2 message and consume its (owner, nonce) bitmap slot. Returns `{consumed, word_pos, bit_pos}`.

Create a new ERC-20 token via the Tenzro token factory. Returns the deployed token address and token ID. The token is registered in the unified token registry and discoverable across all VMs.

Get the TNZO balance for an address across all VMs. Shows native balance (18 decimals), EVM wTNZO balance (18 decimals), SVM wTNZO balance (9 decimals), and DAML holding amount.

Get information about a token by symbol, token ID, or EVM address. Returns the full token definition including cross-VM addresses.

Get the TNZO token balance for an address. Returns the balance in wei (1 TNZO = 10^18 wei) as a decimal string.

Browse the curated ONNX vision encoder catalog: DINOv3 (small/base/large), SigLIP2 (base/large/so400m), CLIP ViT-B/32 + L/14, DINOv2. Each entry carries input_size, embedding_dim, normalization preset, and license tier.

List vision encoder models currently loaded on this node (DINOv3, SigLIP2, CLIP, etc.). Use list_vision_catalog to browse available models.

Embed a single image with a registered vision encoder. Pass base64-encoded PNG/JPEG/WebP bytes. Returns a dense feature vector (e.g. 768-dim for DINOv3-base, 1152-dim for SigLIP2-so400m).

Compute cosine similarity between an image embedding and a text embedding (must have matching dimension). Pure math — does not load any model. Typical use: pair vision_embed (image) with text_embed against a CLIP/SigLIP text tower.

Bridge tokens via the Wormhole adapter registered on the BridgeRouter. Returns transfer_id, tx_hash, fee_paid, and estimated_arrival_ms on success.

Look up the Wormhole numeric chain id for a chain name (ethereum=2, solana=1, base=30, arbitrum=23, optimism=24, etc.).

Enumerate the Wormhole NTT chain catalog supported by this Tenzro deployment. Returns Wormhole chain ids + names + supported Transceiver kinds (wormhole / axelar / layerzero / custom).

Parse a canonical Wormhole VAA id of the form {chain}/{emitter}/{sequence} into its components.

Operator-only. Mint a new API key on this node. Requires the caller's MCP request to carry an `X-Tenzro-Admin-Token` header matching the node's configured admin token. `class` controls revocability: `subject` (default) — subject can self-revoke, admin can revoke; `operator_internal` — admin-only revoke; `operator_protected` — not revokable via RPC by anyone (rotate via operator secret + restart). The MCP tool auto-injects the `confirm_operator_protected` interlock when class is `operator_protected`. Returns the plaintext `tnz_...` key exactly once — persist it immediately.

Operator-only. List every API key the node has issued — active and revoked. Requires `X-Tenzro-Admin-Token`. Returns `key_id`, `subject`, `label`, `scopes`, `class`, `created_at`, `revoked_at`, `active`.

Subject-gated. List every API key belonging to the caller's own subject, and the entitlement behind each: scopes, tier ceiling, `canton_networks`, `canton_user_id`, and party-delegation arrays. A row with a non-empty `canton_networks` but a null `canton_user_id` has node access without ledger access — it authenticates but is bound to no Canton party, so command submission is refused. Requires the caller's MCP request to carry an `X-Tenzro-Api-Key` header identifying the subject.

Fetch a single approval record by id. The engine lazy-transitions an expired `Pending` record to `Expired` on this read path, so a returned `Pending` record is guaranteed to still be live. Returns the full record JSON; returns -32000 if id is unknown. Requires AuthEngine to be initialised on the node.

Fetch an approval gate by 32-byte hex id. Returns the approver set (single / threshold / role / delegated), m-of-n threshold, on-event trigger, and effect.

Fetch an open or finalized approval request by 32-byte hex id. Returns the gate, decisions collected, threshold progress, and final outcome (approved / rejected / pending).

Authorize a bridge address for ERC-7802 crosschain mint and burn operations. Only authorized bridges can mint/burn tokens for cross-chain transfers. Sets daily mint and burn limits for rate limiting.

Check — without side effects — whether caller_did may read the database. Returns {authorized, reason}.

Authorize a temporary session for a wallet with specific allowed operations and a time limit. Requires a signed did_envelope from the DID that owns the wallet — opening a session is an act on the wallet. Returns a session ID and expiry timestamp.

Inspect the EIP-1559 fee market: current effective gas price (base fee + suggested tip), suggested priority tip, and recent base-fee history. Use this to size maxFeePerGas / maxPriorityFeePerGas on Type-2 transactions. Base fee adjusts ±12.5% per block based on parent gas usage vs. the 15M target.

Fetch a fee route by 32-byte hex id. Fee routes describe how a settlement payout is split across recipients in basis points (must sum to 10_000).

List every registered fee route. Each route has a label, splits in bps, and a derived 32-byte id used by Workflow.fee_route.

Run a univariate timeseries forecast on a registered model. Pass `history` (most-recent-last context series), `horizon` (steps ahead), and optional `quantiles` (e.g. [0.1, 0.5, 0.9]) and `frequency_seconds`. Returns point forecasts and (when supported) quantile bands.

Browse the curated ONNX forecast (timeseries) catalog. Returns models like TimesFM 2.5 — each with HF repo, context length, max horizon, and quantile support.

List forecast (timeseries) models currently loaded on this node. Use list_forecast_catalog to browse available models from the curated catalog.

Deploy a wasi:http WebAssembly component as a request-scoped function. The node runs it under wasmtime with the granted capabilities, fuel limit, and per-request deadline. Requires a signed did_envelope.

Read a deployed function's manifest: wasm blob hash, capabilities, fuel/deadline limits, price, and placement.

Remove a deployed function by id. Requires a signed did_envelope matching owner_did.

Fetch an inference challenge by id. Returns the full record (status, filed_at, resolved_at, verification) or null when unknown. Mirrors tenzro_getInferenceChallenge.

Fetch a stored TOPLOC inference commitment by hash. Returns the envelope {commitment_hash, model_id, provider, created_at, commitment: {k, prompt_tokens, steps}} or null when no commitment is stored under that hash. Mirrors tenzro_getInferenceCommitment.

List inference challenges, optionally filtered by status (voting_commit/voting_reveal/upheld/dismissed) and provider. Returns {count, challenges: [...]} sorted newest first. Mirrors tenzro_listInferenceChallenges.

Fetch a content-addressed `tenzro://blob|model|gradient|shard|receipt/...` URI from the local iroh-blobs store (auto-populates from peers as needed). Returns base64-encoded bytes plus the parsed URI and size.

Show the local iroh endpoint id, Pkarr relay URL, and ALPNs registered on the shared router. Returns an internal error iff the iroh transport failed to bind at startup.

Publish raw bytes to the shared iroh-blobs store. Returns a content-addressed `tenzro://blob/<blake3-hex>` URI that any iroh peer can fetch (subject to NAT/discovery reachability).

Create a new MPC threshold wallet with configurable threshold and share count. Default is 2-of-3. Returns the wallet ID, address, and key share metadata.

Operator-only. Start a DKLS23 secp256k1 distributed-key-generation ceremony. Requires X-Tenzro-Admin-Token. Every participant's operator posts identical params (same participant_dids, finalized_block_hash, session_nonce, threshold) so the derived InstanceId matches byte-for-byte; peer_bindings must map every remote participant DID to its libp2p PeerId or the call is rejected. Idempotent — re-posting the same session returns the existing record.

Query MPC keygen session state. Pass instance_id for a single session, or omit it to list every keygen session on this node. Each record carries status, threshold, total_parties, local_party_index, and — once completed — group_id, group_public_key, and the derived EIP-55 address.

Create a new NFT collection on the Tenzro ledger. Supports ERC-721 (unique tokens) and ERC-1155 (semi-fungible tokens). Returns the collection ID and deployed address.

Get information about an NFT collection or a specific token within a collection. If token_id is provided, returns token-level details (owner, URI). If omitted, returns collection-level info (name, symbol, total supply).

List all NFT collections registered on the Tenzro ledger. Optionally filter by creator address or NFT standard (erc721/erc1155).

Read the renter's current prepaid balance. Returns `{renter, asset, balance}` in wei.

Pre-fund the streaming settlement path: lock `amount` (wei) of the renter's on-chain TNZO into the prepaid ledger so storage/compute runtimes can stream per epoch out of it. Returns `{renter, asset, deposited, balance}`. Requires the node to run with storage + token subsystems.

Withdraw up to `amount` (wei) of the renter's unspent prepaid balance back to their on-chain account. Returns `{renter, asset, withdrawn, balance}` — `withdrawn` is capped at the available balance.

Fetch the recorded outcome for a settlement authorization by (app_id, external_ref). Returns the amount, payer net, commission, and success/failure detail, or an error if no settlement was recorded for that reference.

Execute a developer-signed settlement authorization. The developer already charged the end user in fiat on their own payment-provider account; this moves TNZO from the app wallet to the payer, minus the network commission. Idempotent per (app_id, external_ref): a replay returns the recorded outcome with duplicate=true. The signature must be from one of the app's registered signing keys.

Execute an immediate settlement between two addresses on the Tenzro Network. Transfers TNZO from payer to payee for a specific service type. Returns the settlement receipt.

Read the SLA fault-detector parameters this validator is using: `slash_threshold` (number of missed probes before slashing fires for a provider), `slash_amount_wei` (per-crossing slash amount in wei, decimal string), and this validator's `vrf_pubkey` (0x-prefixed hex).

Issue a VRF-bound SLA liveness probe to a ModelProvider / TeeProvider DID and broadcast it on the `tenzro/sla` gossipsub topic. Validator-only — on a non-validator node this returns `-32000 SlaManager not initialized`. The probe is addressed by a 32-byte VRF output (`challenge_nonce`). `deadline_ms` is a Unix-millisecond timestamp; if the provider does not respond before this deadline the probe is counted as missed against the fault-detector's slash threshold.

List every in-flight SLA probe awaiting a response, regardless of issuer. Returns `{count, probes: [...]}` with `challenge_nonce`, `provider_did`, `epoch`, `round`, `deadline_ms`, and `issuer` for each probe. Used by operators to spot stuck probes whose deadline has already elapsed without a matching response.

Get the current spending limits for a wallet. Returns the daily limit, per-transaction limit, and current daily usage.

Install or update the per-account SpendingLimitValidator config (per-tx + daily rolling-window caps).

Set spending limits for a wallet. Defines the maximum daily spend and per-transaction limit in TNZO. Transactions exceeding these limits will be rejected.

Submit a DAML command to a Canton domain. Supports create, exercise, and create_and_exercise commands. Returns the transaction ID and updated contract state.

Submit one guardian's composite (Ed25519 + ML-DSA-65) signature against an in-flight social-recovery ceremony. Returns the running tally and a quorum_reached flag.

Record a signed Proof-of-Reserve attestation backing a tokenized asset, so attested-mint can enforce 1:1 backing. Mirrors tenzro_submitReserveAttestation.

Approve a treasury withdrawal with a signed approval. The signature covers 'tenzro/treasury/withdrawal-approval' || withdrawal_id || asset_id || amount_le and must come from an authorized withdrawer. Returns the approval count and whether the threshold is reached.

Execute a treasury withdrawal after the approval threshold is reached. The (withdrawal_id, asset_id, amount) triple must match the approved withdrawal exactly.

Get a pending treasury withdrawal's approval state: asset, amount, approver addresses, approval count, and the configured threshold. Returns null when no pending withdrawal matches.

Browse the curated video encoder catalog: the V-JEPA 2 family (vjepa2-vitl-256, vjepa2-vith-256, vjepa2-vitg-384 — Meta AI). Serving is frame-based rather than native — load_video_model composes a clip encoder over an already-loaded image encoder and mean-pools the per-frame embeddings.

List clip-level video encoders currently loaded on this node, each wrapping an image encoder with a frame count. Use list_video_catalog to browse the curated catalog.

Produce a clip-level embedding from a short video (base64-encoded). The node extracts evenly-spaced frames, embeds each through the image encoder the clip encoder was registered over, and mean-pools. `frame_stride` overrides the even spacing with a fixed stride. Billing covers both the decode, which scales with clip duration, and the embedding, which scales with frames kept.

List workflow ids created by a given DID. Returns up to all workflows the DID has authored, regardless of status.

List workflow ids that include a DID as a participant (regardless of role). The DID may be the creator, an obligor, an oblige, or an approver.

List workflow ids in a given status. Status: draft | awaiting_signatures | active | suspended | settling | completed | failed | disputed | cancelled.

Look up a registered app by id. Returns the developer DID, app wallet, registered signing keys, developer margin, and active status.

Activate or deactivate a registered app. Requires a developer-signed DID envelope (hex header value) authorizing tenzro_setAppStatus over the canonical status params of (app_id, active). A deactivated app rejects new settlement authorizations.

Return the current node wall-clock as a Tenzro AttestedTimestamp envelope. The returned shape carries wall_ms, monotonic_ns, and TEE vendor (null when the node is not running inside a TEE).

Mint a tokenized asset ONLY if post-mint supply <= attested reserves (1:1 backing as a protocol invariant). Rejects with no/insufficient reserves. Mirrors tenzro_attestedMint.

Browse the curated ONNX ASR catalog: Moonshine v2 (tiny/base, MIT, on-device), Distil-Whisper (small.en/medium.en/large-v3, MIT), Whisper Large-v3-turbo (MIT, flagship), Parakeet-TDT-0.6B-v3 (CC-BY-4.0, 25 European langs), Canary-1B-Flash (CC-BY-4.0, multilingual). The catalog is stable; the ORT-backed transcribers are feature-gated (default builds return ProviderNotAvailable).

List ASR (speech-to-text) models currently loaded on this node. The catalog covers Moonshine v2, Distil-Whisper, Whisper-large-v3-turbo, Parakeet-TDT-0.6B-v3, and Canary-1B-Flash, all backed by ORT sessions.

Get a block by height from the Tenzro ledger, including transactions and metadata

Fetch a contiguous range of blocks by height (default 64, max 256). Returns block summaries plus `next_height` and `more_available` so a lagging client can paginate forward until caught up.

Get a single TNZO CCT pool by chain name. Returns chain_id, chain_selector, pool_address, token_address, pool_type, contract_name, capacities, refill_rate.

List all TNZO CCT pools in the canonical mainnet registry (Ethereum LockRelease; Base/Arbitrum/Optimism/Solana BurnMint).

Resolve an intent to a model and run the chat in one call. Selection walks the cross-model fallback chain, so the intent resolves as long as any model that satisfies it has a live offer, and dispatch is pinned to the offer that was scored — the price quoted is the price settled and the provider share goes to the address that offer named. The chosen decision is attached to the response under 'route'. Difficulty feedback for resolved and failed calls is recorded from the dispatch itself; report an escalation with record_route_outcome

Send a chat completion request to a named AI model served on the Tenzro network. Use list_models or list_model_endpoints to discover available models. Omitting 'model' and giving 'use_case' selects one, but the offer is resolved at dispatch rather than pinned to the scored price — chat_by_intent is the path that pins price and payee

Burn tokens for a crosschain transfer (ERC-7802 crosschainBurn). Only pre-authorized bridges can call this. Tokens are burned on the local chain and will be minted on the destination chain. Returns the burn event and nonce.

Mint tokens via an authorized crosschain bridge (ERC-7802 crosschainMint). Only pre-authorized bridges can call this. The hex-encoded inbound bridge payload is dispatched through the bridge router for quorum verification; the verified TenzroMessage inside is the sole authority for recipient and amount. Returns the mint event and nonce.

Delegate a task from one agent to another on the Tenzro Network. Optionally set a wei budget cap for the delegated task (1 TNZO = 10^18 wei). Returns the delegation record and task ID.

Delegate governance voting power from one address to another. Delegated TNZO stake will count toward the delegate's votes. Returns the delegation record.

Run object detection on an image. Returns an array of detections with bounding box (x0,y0,x1,y1), label_id, and confidence score. NMS-free for DETR-family models — just sigmoid + score threshold.

Detect available Trusted Execution Environment (TEE) hardware on this node. Returns detected TEE type (Intel TDX, AMD SEV-SNP, AWS Nitro, NVIDIA GPU CC) or simulation mode.

Browse the curated ONNX detection catalog: RF-DETR (nano/small/medium/base/large/2xl) — first real-time detector >60 AP on COCO (ICLR 2026); D-FINE (n/s/m/l/x). All Apache-2.0.

List object detection models currently loaded on this node (RF-DETR, D-FINE). Use list_detection_catalog to browse the curated catalog.

Discover registered AI agents on the Tenzro Network. Filter by capability or agent type. Returns agent DIDs, capabilities, endpoints, and reputation scores.

Discover available AI models on the Tenzro Network. Filter by category, serving status, or max price. Returns model IDs, providers, pricing, and endpoints.

Create an on-chain escrow via a signed CreateEscrow transaction. Funds are locked at a deterministic vault address derived from the escrow_id; only the original payer can later release or refund.

Read a single escrow record by its 32-byte escrow_id (hex, with or without 0x prefix). Returns `{escrow_id, payer, payee, amount, asset_id, status, created_at, expires_at, release_conditions}`. Requires EscrowManager to be initialised.

List every escrow held for the given payee address. Returns `{payee, count, escrows: [...]}`. Backed by the `escrow_payee:` secondary index in CF_SETTLEMENTS. Requires EscrowManager.

List every escrow funded by the given payer address. Returns `{payer, count, escrows: [...]}`. Backed by the `escrow_payer:` secondary index in CF_SETTLEMENTS. Requires EscrowManager.

Finalize an inference challenge by tallying revealed committee votes weighted by stake. No admin token — the verdict is the committee's. Idempotent: a decided challenge returns unchanged. An upheld verdict decrements the provider's reputation and records a compute-bond failure (response carries reputation_penalized + bond_failure_recorded). Pass force=true to close a challenge after the reveal window with no uphold quorum. Mirrors tenzro_finalizeChallenge.

Finalize a social-recovery ceremony once guardian quorum is reached. The node installs the new passkey as the smart account's primary WebAuthnValidator.

Generate a new cryptographic keypair. Returns the public key, private key, and derived address in hex.

Generate a Tenzro VRF proof (RFC 9381 ECVRF-EDWARDS25519-SHA512-TAI). Returns the public key, 80-byte proof, and 64-byte deterministic output. Do not use with secret inputs — the try-and-increment encoding is data-dependent.

Compute the Keccak-256 hash of hex-encoded data. Returns the 32-byte hash in hex. Used for Ethereum-compatible hashing.

Compute the SHA-256 hash of hex-encoded data. Returns the 32-byte hash in hex.

List the placement leases bound to a specific app (site / function / machine) id.

List all active placement leases held on this node across sites, functions, and machines.

Mint a new NFT in an existing collection. For ERC-721, each token_id is unique. For ERC-1155, you can mint multiple copies of the same token_id. Returns the minted token details.

Mint stable units, hard-gated by the Secure-Mint reserve floor so circulating can never exceed the attested reserve.

Create a payment challenge for a protected resource. Supports five protocols: - 'mpp' (Machine Payments Protocol): Session-based streaming payments, ideal for per-token AI inference billing - 'x402' (Coinbase HTTP 402): Stateless one-shot payments, ideal for API calls and data downloads - 'visa-tap' (Visa Trusted Agent Protocol): RFC 9421 agent-verified payments for agentic commerce - 'mastercard-agent-pay' (Mastercard Agent Pay): KYA-verified payments with agentic tokens - 'native': Direct TNZO transfer on the Tenzro ledger

List the payment protocols supported by this Tenzro node, including MPP (session-based streaming), x402 (stateless one-shot), and native TNZO transfers

List every approval in `Pending` state for the given approver DID. Lazy-expires stale records server-side before returning, so the caller never sees expired entries. Returns `{approver_did, count, pending: [{approval_id, requester_did, approver_did, created_at_ms, expires_at_ms, status, decided_at_ms, summary, action}]}`. Requires AuthEngine to be initialised on the node.

List in-flight social-recovery ceremonies for a smart account, with current signature counts and expiration timestamps.

Post an AgentBond surety against an agent DID (Agent-Swarm Spec 9). An Active bond ≥ bond_min_for_promotion promotes a Machine identity into the Delegated admission lane even when its controller is unknown / sub-Enhanced KYC. NOTE: this MCP tool describes the operation only — sign and submit a PostAgentBond transaction via tenzro_signAndSendTransaction.

Post a new task to the Tenzro Network task marketplace. Returns the created task with its UUID. Tasks can request AI inference, code review, data analysis, content generation, agent execution, translation, or research.

Fetch a privacy domain by 32-byte hex id. Returns members, X25519 envelope policy, freeze status. Members see plaintext, non-members see Deny (indistinguishable from non-existence).

List privacy domains a given DID is a member of. Caller-side filtered to the DIDs the requester is authorized to see.

Quote the destination-native bridge fee in TNZO for a given (adapter, dest_chain, native_fee_smallest_unit). Read-only quote envelope; the matching tenzro_sponsorBridgeFee RPC consumes the quote to debit the user's TNZO and post a sponsorship receipt.

Submit a price quote for a task in the Tenzro Network task marketplace. Providers call this to bid on open tasks. The quote includes price, model to use, and estimated completion time.

Resolve a DID to its identity information, including display name, type, status, and delegation scope for machine identities

Resolve a username to its DID on the Tenzro Network. Returns the DID associated with the given username.

Discover the best model for an intent (use case + budget + quality floor + cost-quality knob) without naming a model. Returns the selected model_id, tier, estimated cost, fallback chain, the difficulty cluster the prompt landed in, that model's observed error rate in the cluster, and the winning provider's address and endpoint when the offer came from another operator. Discovery only — dispatches nothing and records no spend, though the per-DID budget gate and the wallet-balance ceiling still apply, so an unaffordable request is refused here. Use chat_by_intent to select and run in one call

Read the node's difficulty index: how many prompt clusters it has discovered and how many prompts landed in each. With model_id, also returns that model's per-cluster outcome counters and error rate. An operator diagnostic — routing does not depend on it. enabled=false means the node has no embedding model loaded and routes on declared metadata alone

Fetch a full sealed-model manifest by model ID. The manifest carries only ciphertext hashes, blob URIs, and wrapped (encrypted) content keys — safe to share; recipients use it to install the model on their own node

List sealed-model manifests stored on this node. Sealed models are distributed as encrypted shards with per-recipient wrapped content keys (x25519-hkdf-sha256-envelope-aes-256-gcm); only named recipients can decrypt. Returns summaries — use get_sealed_model for a full manifest

Browse the curated ONNX segmentation catalog: SAM 2 (base/large), EdgeSAM, MobileSAM. SAM 3 / 3.1 are text-promptable with a different decoder ABI and are not exposed via this point/box segment tool.

List segmentation models currently loaded on this node (SAM 2, EdgeSAM, MobileSAM). Use list_segmentation_catalog to browse the curated catalog.

Submit a hybrid-signed (Ed25519 + ML-DSA-65) AgentMessage to a recipient agent's queue. Signing preimage: SHA-256(AgentMessage::signing_data()) — which includes both wallet addresses (resolved from registry, not wire). Both signature legs are required when the router enforces signing (production default); half-signed messages are rejected. Returns message_id, status, timestamp, and signed flag.

Send a TNZO transfer transaction on the Tenzro ledger. Two supported paths: (a) ambient OAuth/DPoP (server-custodial) — omit the signature fields; the server looks up the wallet bound to the bearer DID and signs; (b) self-custody / pre-signed — the caller signs both legs locally and supplies signature (Ed25519) + public_key (Ed25519) + pq_signature (ML-DSA-65) + pq_public_key (ML-DSA-65 verifying key) + timestamp matching the signed Transaction::hash(). The node verifies both legs and rejects a raw send that omits either. On the ambient path, when the controller has put transfers on the always-ask list the first call returns -32002 with data.approval_id; once the controller approves it, retry the same transfer with approval_id set and it executes. A denial returns -32001 carrying the approver's reason.

Sign a message with a private key. Returns the hex-encoded signature. Supports Ed25519 and Secp256k1 key types.

Verify a WebAuthn assertion against the registered passkey on a smart account. Returns verified=true iff the P-256 leg validates and the embedded challenge matches the supplied user-op hash.

Fetch the smart-account summary: address, owner, nonce, deployment status, installed ERC-7579 validators.

List every smart account known to the node, including each account's installed validators.

Fetch one chunk of a local snapshot by `(height, chunk_index)`. The returned `data_b64` is the base64-encoded chunk bytes; verify against `manifest.chunk_hashes_hex[chunk_index]` before applying. Returns `{height, chunk_index, data_b64}`.

Fetch the full snapshot manifest at `height`, including per-chunk SHA-256 hashes used to verify chunks before applying. Returns JSON-RPC error `-32004 no snapshot at height` if no snapshot exists at that height. The manifest contains `state_root_hex` which the caller MUST verify against a trusted QC at the same height before offering this manifest to another node.

Spawn a child agent under a parent agent on the Tenzro Network. The child inherits the parent's controller DID and can be delegated tasks. Maximum 50 children per parent agent.

Spawn an agent from a marketplace template on the Tenzro Network. Creates a new agent instance with its own identity, wallet, and capabilities based on the template definition.

Create a swarm of coordinated agents under an orchestrator on the Tenzro Network. Each member spec spawns one child agent. Tasks can be dispatched to all members in parallel or sequentially.

Get the current status of a Tenzro agent swarm including lifecycle status, member count, and per-member agent statuses, roles, and results.

Generate a TEE attestation report from the node's hardware enclave. The attestation proves the code is running in a genuine TEE. Optionally specify the TEE type or auto-detect.

List all registered TEE providers on the network, including their TEE type, attestation status, and supported capabilities.

Terminate an agent (TERMINAL — irreversible). Halts messaging, optionally slashes stake (slash_bps 0-10000), and optionally cascades to all descendant spawned agents. Requires controller_did to match. NOTE: this MCP tool describes the operation only — the transaction must be signed and submitted via tenzro_signAndSendTransaction with type=TerminateAgent.

Terminate a Tenzro agent swarm and all its member agents. Attempts graceful shutdown of each member. Returns confirmation with swarm ID and terminated status.

Read the ERC-7943 (uRWA) frozen-tokens amount for a (token_id, account) pair. Returns the frozen amount in token smallest unit.

Read the ERC-7943 (uRWA) kill-switch state for a given token_id (32-byte hex). Returns the kill-switch active flag, the canonical 4-byte selectors for the standard uRWA functions, and the precompile addresses backing the on-chain enforcement path.

List only currently-Active validators. Convenience over list_validators with status='Active'. Useful for SRE dashboards that need the current committee size and stake distribution.

List all apps registered in the on-chain app registry, sorted by app id.

Assign a task to a specific agent on the Tenzro Task Marketplace. Moves task from open to assigned state and notifies the agent. Returns the updated task record.

Read the fraud-window record for a ZK commitment: certificate voting power, the DA locator co-signers use to re-verify, the height the fraud window opened at, whether that window is still open at the current finalized height, and whether the commitment is admitted to the on-chain ZK_VERIFY registry.

Read DA committee availability scores (0-1000, +1 per passed possession challenge, -5 silence or honest not-held, -25 bad proof). Pass an address for one member's score, omit for all scored members lowest-first.

Get the TNZO token balance of an account on the Tenzro ledger

Find the best agent on this node for a given capability. Prefers TEE-backed attestations (most recent wins), falling back to any agent with the capability registered. Returns the chosen agent_id and the total candidate count.

List blob commitments known to the local DA committee store, with the locally-held sliver index (if any) and the availability certificate (attesting member indices, quorum, root, timestamp) when one is held.

Get the CAIP-10 account id for a Tenzro address. Accepts hex or base58btc on input; normalises to canonical 64-hex.

Get the CAIP-19 asset id. Asset namespaces: `slip44` (native TNZO, SLIP-44 coin index 1414421071), `token` (Tenzro token registry id, 32-byte hex), `nft` (collection id + nft_token_id).

Get the CAIP-2 chain id for this node: `tenzro:<lowercase hex of the first 16 bytes of the genesis block hash>`. Returns `{chain_id, namespace, reference, evm_chain_id}` — the `evm_chain_id` sidecar is for EVM tooling.

Invoke any JSON-RPC method this node serves, by name. The escape hatch for everything without a dedicated tool — discover names with list_rpc_methods first. Authorization is unchanged: the call runs behind the same admin-token gate, API-key scope gate, and default-deny classification as a direct JSON-RPC request, so this reaches exactly what your credentials already allow and nothing more.

Cancel a pending or active task on the Tenzro Task Marketplace. Only the original requester can cancel. Refunds any escrowed TNZO. Returns cancellation confirmation.

List Canton synchronizer domains configured on this node. Returns domain IDs, connection status, and participant info for enterprise DAML integration.

List all registered capabilities on this Tenzro node. Returns each capability with the count of agents that have it, the count of attestations, and the list of agent IDs supporting that capability. Use to discover what specialized work the local agent runtime can route.

Fetch all attestations registered for a given capability. Each attestation carries the agent ID, attestation timestamp, TEE-backed flag, attester address, attester public key, signature, and metadata. Set verified_only=true to filter for attestations that pass query-time signature/expiry verification.

Challenge a DA committee member to prove current possession of its Red Stuff sliver for a blob commitment. The target must return the full sliver plus a nonce-bound Ed25519 signature; the challenger re-verifies the sliver against the commitment. The outcome (passed / failed_no_response / failed_not_held / failed_bad_proof) feeds the target's rolling availability score. Validator-only.

List resolved DA possession-challenge records, newest-first. Each record carries the blob commitment, target member index + address, nonce, timestamps, and outcome.

List all available ZK circuits on the node — name, AIR type, field, and hash function.

Clear the Secure-Mint policy for an asset.

Close a micropayment channel with the final balance. Requires sender signature on the final state. Settles remaining balance on-chain and returns any unused deposit.

Compute a deterministic cluster placement for a model across candidate members. Returns the fit decision and, when a cluster forms, the VRAM-weighted per-member layer assignment ordered to minimize pipeline transfer cost. Pure function of the params; reads no node state.

Commit a committee vote on an inference challenge. Open to drawn committee seats only. `commit_hash` = compute_vote_commit(verdict, salt, challenge_id, voter); the verdict stays hidden until reveal. When committed stake reaches the 2f+1 threshold the challenge advances to the reveal phase. Mirrors tenzro_commitChallengeVote.

Show the current DA committee roster: each member's index, address, whether it is the local node, and its availability score if it has ever been challenged.

Mark a task as completed with a result payload. Optionally attach a proof of completion. Triggers settlement payment to the completing agent. Returns the completion receipt.

Check whether a token transfer would be compliant with the registered ERC-3643 compliance rules. Returns compliant/non-compliant status with specific violation details. Does not execute the transfer.

Invoke Tenzro Cortex recurrent-depth reasoning. Executes a recurrent-depth transformer (OpenMythos-style) through a registered Cortex worker, charging TNZO based on tokens_in, tokens_out, and loops_used. Returns the reasoning output along with a signed CortexReceipt binding input/output commitments, weights hash, runtime hash, loops_used, and worker DID. Use tier='fast|standard|deep|institutional' to select the reasoning depth budget.

Transfer tokens between VMs (e.g., EVM to SVM). Uses the cross-VM bridge precompile for atomic transfers. Only TNZO is currently supported for cross-VM transfers.

Ask the node for the challenge an already-enrolled passkey must sign to authorize one custody change (add_passkey, remove_passkey, set_passkey_policy, grant_session_key, revoke_session_key, set_spending_limit, add_hardware_signer, add_guardian). Changing who can sign for a wallet needs proof of control from a device already on the account — the account address is a public identifier, not a credential. The challenge is single-use, time-bounded, and bound to this account and operation.

List active DAML contracts on a Canton domain. Filter by template ID. Returns contract IDs, parties, and payload data for enterprise workflow automation.

List every database this node serves.

Decide a pending approval — `decision` is 'approved' or 'denied'. When `approver_did` is supplied, the engine refuses to apply the decision unless the record's approver_did matches (cross-approver tampering defence). Mismatch returns JSON-RPC -32001 (forbidden). `deny_reason` is recorded on a denial and surfaced to the requesting agent on retry. Returns the updated approval record. Requires AuthEngine to be initialised on the node.

ABI-decode contract call return data. Takes hex-encoded return data and output type signatures, returns decoded values. Useful for interpreting EVM contract responses.

Decrypt AES-256-GCM encrypted data using the key and nonce. Returns the plaintext in hex.

Set the delegation scope for a machine identity, defining spending limits, allowed operations, payment protocols, and chains the agent may use

Deploy a smart contract to the Tenzro ledger. Supports EVM (Solidity bytecode), SVM (BPF programs), and DAML (DAR packages). Returns the deployed contract address.

Derive a 256-bit encryption key from a password using Argon2id KDF. Returns the derived key in hex.

Fetch a single channel dispute by id. Returns the full ChannelDispute (challenger, evidence blobs, status, opened_at / timeout_at / resolved_at, resolution). Returns -32004 if no dispute with that id exists. Requires ChannelManager.

List every dispute (open or historical) attached to a channel. Returns `{channel_id, count, disputes: [...]}`. Empty list is not an error — a channel with no disputes returns count: 0. Requires ChannelManager.

Remove a database and all its partition placements, tearing down the engine backing for every partition this node holds. Administrative — caller_did is gated on the admin (write) action and its usage counters are removed with it.

ABI-encode a function call. Takes a Solidity-style function signature and arguments, returns hex-encoded calldata. Useful for preparing EVM contract interactions.

Encrypt data using AES-256-GCM symmetric encryption. Returns the ciphertext and nonce in hex.

Enroll a passkey-bound smart account. Consumes a WebAuthn registration credential (P-256 public key + opaque credential ID + ML-DSA-65 verifying key for hybrid PQ), creates a TDIP human identity, deploys a smart account via the shared AccountFactory, and installs WebAuthnValidator as the primary signer. The signing key never leaves the user's hardware secure element.

Query historical events from the Tenzro ledger. Supports cursor-based pagination. Filter by block range, event type, and involved addresses. Returns events ordered by sequence number.

RFC 8693 OAuth 2.0 Token Exchange. Mint a narrower child JWT from a parent JWT, bound to a different DPoP key with a strict subset of the parent's RAR grants and AAP capabilities. The child token's controller_did is set to the parent's sub, extending the act-chain by one hop. Subset enforcement is performed by the AS; over-scoped requests are rejected.

Export a wallet's keystore as an encrypted JSON file. Uses Argon2id KDF for key derivation. The exported keystore can be imported on another node.

List the caller's own stored files, newest first, with the tenant's total stored bytes. Never returns another tenant's files: the listing is scoped to the subject on the presented `X-Tenzro-Api-Key`.

TDIP/GDPR Article 17 right-to-erasure. Hard-deletes a previously revoked identity from the registry and persistent storage. The DID must already be in `Revoked` status — call `revoke_did` (RPC) first, allow cascading revocation to propagate, then call this. Distinct from revoke (logical delete). Operator-only: requires X-Tenzro-Admin-Token.

Freeze an address for a specific token under ERC-3643 compliance. A frozen address cannot send or receive the specified token. Returns the freeze record.

List deployed functions, optionally filtered by owner DID.

Grant a scoped session key to a smart account so an agent can sign a bounded subset of operations without holding the human's passkey. Permissions: allowed function selectors, target contracts, per-call value cap, cumulative value cap, validity window.

Install a hardware-signer ERC-7579 validator (Ledger / Trezor / GridPlus / YubiKey / generic) as an additional ANDed validator on a smart account.

Import a wallet from an encrypted keystore JSON. Decrypts with the provided password and adds the wallet to the local node.

Initiate a social-recovery ceremony to rotate a smart account to a freshly enrolled passkey. Returns a recovery_id and the 32-byte op hash that guardians must sign.

RFC 7662 OAuth 2.0 Token Introspection. Ask the AS whether a token is currently active and, if so, return its full claim set (RAR authorization_details, AAP aap_* claims, cnf, controller_did, etc.). Per RFC 7662 §2.2 a failed validation returns `{active: false}` with no other fields — the AS does not leak why the token is inactive.

Mint a managed-database connection credential bound to bearer_did, scoped to this one database. The owner (caller_did) — or a caller holding the write-action capability — issues it. When write is true the token also carries the admin action. Returns the credential a developer presents on every query.

Compute the canonical SHA-256 hash for an IVMS101 Travel Rule envelope. The caller passes the envelope JSON; the node returns the binding hash that anchors the envelope to a settlement receipt.

Join the Tenzro Network as a MicroNode — a zero-install full participant. Auto-provisions a TDIP decentralized identity (DID) and MPC wallet. Grants access to all 10 network capabilities: inference, payments, agent collaboration, MCP tools, task execution, chain queries, smart contracts, TEE services, cross-chain bridge, and governance. Works from any entry point: Claude, ClawBot, MCP, A2A, SDK, API, CLI, or app. No hardware, no binary installation required.

Get the key share metadata for an MPC wallet. Returns the threshold, total shares, and share indices without exposing secret key material.

List the peer ids discovered on this node's local network segment, with a count. When the network service is not running the list is empty and available is false.

List deployed machines, optionally filtered by owner DID.

List AI models available on the Tenzro network. Shows all models with availability: 'local' (served on this node, free), 'network' (available from remote providers, costs TNZO), or 'downloadable' (in catalog but not yet available). Filter by category or search by name

Get a snapshot of libp2p network metrics: connection counts, gossipsub publish/accept/reject counters, Kademlia routing table size, gossipsub mesh size, and peer_address_migrations_total (QUIC path migration / mobile network switch / NAT rebinding observability)

RFC 8414 / RFC 9728 OAuth Authorization Server / Protected Resource Metadata. Returns the same metadata document the AS publishes at `GET /.well-known/openid-configuration`, augmented with AAP-specific extensions (authorization_details_types_supported, aap_claims_supported, dpop_signing_alg_values_supported).

Fetch an obligation record by 32-byte hex id. Returns the obligor / oblige / kind / amount / status / discharge proof.

Open a micropayment channel for off-chain per-token billing. Sender deposits TNZO into the channel for streaming payments to the recipient. Returns the channel ID.

Satisfy a natural-language intent by planning and running an ordered set of capabilities — models, registered skills, registered tools, and agent/swarm delegation. One layer above route_by_intent: that resolves a single model, this composes models with the skill/tool registries and the swarm runtime. The plan's aggregate estimated cost is checked against the payer's wallet balance before any step runs. Returns the plan, per-step outputs, aggregate estimated cost, and the number of re-plan iterations

List the WebAuthn credential ids enrolled on a passkey-bound smart account.

Pause an agent (reversible). Halts all outbound A2A messaging and inference dispatch but preserves stake. Requires controller_did to match the agent's registered controller. NOTE: this MCP tool describes the operation only — the transaction must be signed and submitted via tenzro_signAndSendTransaction with type=PauseAgent.

Create a Plonky3 STARK proof for one of the three Tenzro AIRs (`inference`, `settlement`, `identity`) over the KoalaBear field. Returns the hex-encoded bincode-serialized p3_uni_stark::Proof and public inputs (4-byte LE KoalaBear chunks).

Create a new governance proposal on the Tenzro Network. Requires a minimum staked balance to propose. Returns the new proposal ID and initial status.

List governance proposals on the Tenzro Network. Filter by status (active/passed/rejected/pending). Returns proposal IDs, titles, vote tallies, and deadlines.

Look up the cached provenance manifest for generated content by its 32-byte hex content_hash (with or without 0x prefix). This is the machine-readable synthetic-content marker per EU AI Act Art. 50(2). Returns JSON-RPC -32004 when no manifest is cached for the hash. Read-only.

List all providers discovered on the Tenzro Network. Providers broadcast announcements every 60s on the tenzro/providers gossipsub topic. Returns both the local node (if serving) and all remotely discovered providers. Optionally filter by provider_type: 'llm', 'tee', or 'general'.

Quarantine an agent (reversible). Halts messaging AND freezes all stake (blocks unstake/withdraw, allows slash). Requires controller_did to match the agent's registered controller. Optionally accepts a 32-byte evidence hash for off-chain audit linkage. NOTE: this MCP tool describes the operation only — the transaction must be signed and submitted via tenzro_signAndSendTransaction with type=QuarantineAgent.

Rate an agent template on the Tenzro Network marketplace. Ratings are 1-5 and help others discover quality templates. Optionally include a text review.

Report how a routed call turned out so per-cluster error rates reflect what happened rather than only what the catalog declares. In practice this carries 'escalated' — the outcome only the caller knows, because it means you took the answer to a stronger model; 'resolved' and 'failed' are already recorded by chat_by_intent from the dispatch itself. Reporting is advisory: retained=false means the node has no difficulty index wired, so the feedback was accepted and discarded

Redeem (burn) stable units, decrementing circulating supply.

Refund escrowed funds back to the payer via a signed RefundEscrow transaction. Only the original payer can refund, AND the escrow must be expired (or use Timeout/Custom release conditions).

Release escrowed funds to the payee via a signed ReleaseEscrow transaction. Only the original payer can release.

Request testnet TNZO tokens from the faucet. The per-request amount and cooldown come from the node's genesis faucet config; the response reports the amount dispensed.

Grow or shrink a database along the local → lan_cluster → network continuum in place. Administrative — gated on the write action. partitions and the replication bounds default to the database's current values when omitted; min_replication and max_replication must be supplied together.

Read the current reserve attestation for a tokenized asset. Mirrors tenzro_getReserve.

Reveal a previously committed committee vote. `(verdict, salt)` must reproduce the earlier commit hash. verdict=true means the commitment did not verify (upholds the challenge). Mirrors tenzro_revealChallengeVote.

Rotate the key shares of an MPC wallet. Generates new shares while keeping the same public key and address. Old shares become invalid.

Read the inference router's live metrics snapshot: total requests routed, hedges dispatched, hedges won, and requests abandoned on the whole-request deadline. Read-only — safe for monitoring agents.

Enumerate the JSON-RPC methods this node serves, with how each is gated (admin token vs open) and which API-key scope it needs. Use this to discover capability beyond the named tools, then invoke what you find with call_rpc. Filter with `namespace` or `contains` — the unfiltered directory is ~900 entries.

Seal (encrypt) data within the TEE enclave using hardware-derived keys. The sealed data can only be unsealed on the same TEE platform with the same key_id.

Run prompt-driven image segmentation. `prompts` is an array of `{type:'point', x, y, is_foreground}` (is_foreground true for a point inside the object, false for background) or `{type:'box', x0, y0, x1, y1}` objects, in original-image pixels. Returns mask data with IOU scores. The encoder caches the per-image embedding, so repeated prompts against the same image only re-run the decoder.

Start serving a model for inference. Local mode loads downloaded GGUF weights in-process (the model must be downloaded first). External mode fronts an already-running OpenAI-compatible engine (vLLM, SGLang, llama-server) — pass engine + base_url. Returns the serving status and configuration.

Compute the canonical hash for an A2A v1.0 SignedAgentCard payload. The caller passes the AgentCard JSON; the node returns the 32-byte hash the domain owner must sign via JWS to produce the SignedAgentCard envelope.

List published sites, optionally filtered by owner DID.

Get usage statistics for a registered skill on the Tenzro Network. Returns total invocations and last used timestamp.

List local snapshots available for state-sync. Per-chunk hashes are elided for compactness — use `get_snapshot_manifest` to fetch the full manifest with `chunk_hashes_hex[]`. Returns `{snapshots: [{height, state_root_hex, num_chunks, created_at, format}, ...]}`.

Read an issuer's stable-asset policy.

Stake TNZO tokens to take a role on the network: validator, RPC operator, TEE provider, model provider, compute provider, storage provider, cloud operator, trainer, or syncer. The bond required depends on the role and, for compute, storage and cloud, on the capacity pledged. Staked tokens earn rewards and increase network weight.

Stop serving a model on this node. The model remains downloaded but no longer accepts inference requests. Returns the stop confirmation.

Register an event filter for real-time streaming via WebSocket or gRPC. Returns a subscription ID and connection URLs for receiving matching events. Events matching the filter will be pushed to connected clients.

Return the canonical Tenzro Cross-VM SVM-native program ID and 4 instruction discriminators (bridge_to_evm, bridge_from_evm, register_token_pointer, transfer_cross_vm). Use this to construct SVM Instructions targeting the Tenzro Cross-VM native program from any SVM client.

Get details about a specific task on the Tenzro Task Marketplace. Returns task description, status, requester, assigned agent, quotes, and completion data.

List tasks from the Tenzro Network task marketplace. Filter by type, status, poster address, or maximum price. Defaults to showing open tasks. Use this to discover tasks agents can fulfill.

List all registered tokens in the unified token registry. Optionally filter by VM type or creator address.

Get usage statistics for a registered tool on the Tenzro Network. Returns total invocations and last used timestamp.

Get the total TNZO token supply in wei (1 TNZO = 10^18 wei). Useful for inflation monitoring and economic analysis.

Report the trainer auto-provisioning daemon status. When the node has no [training] config section (or enabled=false), running is false. Otherwise returns {running, trainer_did, live_trainers, max_concurrent_trainers}. Read-only.

Look up a transaction by its hash on the Tenzro ledger, returning type, sender, recipient, amount, status, and block height

Transcribe an audio clip (WAV/MP3/FLAC, base64-encoded) with a registered ASR model. Optional language hint, per-segment timestamps, and decoding temperature. Note: the ORT-backed transcriber is feature-gated — default builds return ProviderNotAvailable.

Transfer an NFT between addresses within a collection. Verifies the sender owns the token before transferring. Returns the updated ownership details.

Operator-only. Register a trusted credential issuer DID. Requires X-Tenzro-Admin-Token. Pass topics to scope trust to specific gossip topic ids, or leave it empty to trust the issuer for all topics. Persisted to the compliance store.

Unseal (decrypt) data that was previously sealed within the TEE enclave. Requires the same key_id used during sealing.

Unstake TNZO tokens and begin the unbonding period. After the unbonding period (typically 7 days), tokens can be withdrawn.

Store a file on this node, owned by the caller's own subject. The bytes are erasure-coded (4 data + 2 parity shards, surviving two simultaneous provider losses) and published across independent providers, and a storage deal is opened to pay for the shards. Requires an `X-Tenzro-Api-Key` carrying the `storage` scope. Returns the file record, including the `deal_id` that funds it — a null `deal_id` means the bytes are stored but unbilled, which the operator is carrying and the tenant should not assume is durable indefinitely.

Set a globally unique username for a DID on the Tenzro Network. Usernames provide human-readable aliases for DIDs (e.g. 'alice' instead of 'did:tenzro:human:uuid').

Fetch a single validator's registry entry by hex-encoded 32-byte address (with or without 0x prefix). Returns null when the address is not registered. Read-only — validators self-register via the staking transaction path.

List validators in the on-chain registry, optionally filtered by status ('Active' | 'Candidate' | 'PendingActive' | 'PendingExit' | 'Exited' | 'Jailed'). Each entry carries base58 address, Ed25519 + ML-DSA-65 + BLS12-381 pubkeys, self_stake (u128 decimal string), and epoch lifecycle markers.

Vote on an active Tenzro governance proposal. Cast yes, no, or abstain. Voting power is proportional to staked TNZO. Returns the recorded vote and current tally.

Get the governance voting power of an address. Returns the staked TNZO balance used as voting weight. Delegated power is included.

Create a new cryptographic keypair for use as a Tenzro wallet. Supports Ed25519 (Tenzro native) and Secp256k1 (EVM-compatible)

Delete a webhook by id. Requires a signed did_envelope proving control of the owner_did recorded at registration — a webhook id comes back from every list call, so it identifies the row and authorizes nothing. Returns JSON-RPC error `-32602` if the id is unknown; a row that records no owner is refused rather than deleted.

List the webhooks registered under one owner DID. Returns each webhook's id, url, active flag, event_types/addresses filters, and delivery counters (total_deliveries, failed_deliveries). Secret hashes are NOT returned — secrets are write-only. Scoped to one owner rather than the whole node: a row carries its delivery URL and the addresses its owner watches, so it requires a signed did_envelope for owner_did.

Wrap native TNZO to a specific VM representation (wTNZO ERC-20 on EVM, wTNZO SPL on SVM). In the pointer model, this is a no-op since all VMs share the same balance — the tool confirms the balance is accessible on the target VM.

Perform an X25519 Diffie-Hellman key exchange. Returns the 32-byte shared secret in hex.