Agent Marketplace

The Tenzro Agent Marketplace is a decentralised registry of reusable AI agent templates. Developers publish specialist, orchestrator, and multi-modal templates; users browse and deploy them with one call. Templates can be free, per-execution, per-token, or subscription-based.

Template Types

Pricing Models

All pricing models also accept a compact string form in tenzro_registerAgentTemplate, the CLI (tenzro marketplace register --pricing <form>), and both SDKs:

"free"
"per_execution:5000000000000000000"   // 5 TNZO per execution
"per_token:1000000000000"             // 1e12 wei per token
"subscription:50000000000000000000"   // 50 TNZO / month
"revenue_share:9500"                   // 95% creator / 5% treasury

Paid Marketplace: Creator Identity and Payout Wallet

Paid templates bind each invocation fee to a creator identity and a mandatory payout wallet. The network treasury automatically collects a AGENT_MARKETPLACE_COMMISSION_BPS = 500 (5%) commission on every paid run.

Fee Split (per invocation)

fee_paid           = pricing.price_for(tokens_estimate, max_iterations)
network_commission = fee_paid * 500 / 10_000     // 5%
creator_share      = fee_paid - network_commission  // 95%

payer_wallet     -= fee_paid             // debited
treasury         += network_commission   // credited to NetworkTreasury
creator_wallet   += creator_share        // credited to template.creator_wallet
template.invocation_count += 1
template.total_revenue    += fee_paid

Free templates bypass the fee-collection path entirely — fee_paid = 0, no treasury or creator credits are made, and creator_wallet is not required.

Running a Paid Template

{
  "jsonrpc": "2.0",
  "method": "tenzro_runAgentTemplate",
  "params": {
    "agent_id": "<spawned-agent-id>",
    "payer_wallet": "0x...02",
    "tokens_estimate": 1024,
    "max_iterations": 4,
    "dry_run": false
  }
}

// Response — RunAgentTemplateReport
{
  "result": {
    "steps_executed": 2,
    "steps_failed": 0,
    "steps_skipped_by_dry_run": 0,
    "fee_paid": "5000000000000000000",            // 5 TNZO
    "commission_bps": 500,
    "network_commission": "250000000000000000",   // 0.25 TNZO
    "creator_share": "4750000000000000000",       // 4.75 TNZO
    "payer_wallet": "0x...02",
    "creator_wallet": "0x...01",
    "treasury": "0x...treasury",
    "invocation_count": 1,
    "total_revenue": "5000000000000000000"
  }
}

Setting dry_run: true skips fee collection and persistence but still reports the estimated fee-split, step counts, and steps_skipped_by_dry_run. Use this for cost estimation before committing a paid invocation.

CLI Walkthrough

# 1. Register a paid per-execution specialist template
tenzro marketplace register \
  --name "Premium Alpha Advisor" \
  --description "Alpha signal generation" \
  --template-type specialist \
  --creator-did did:tenzro:human:alice \
  --creator-wallet 0x...01 \
  --pricing per_execution:5000000000000000000 \
  --system-prompt "You are an alpha advisor..."

# 2. Spawn an instance from the template
tenzro marketplace spawn --template-id ref-premium-alpha-advisor-v1 \
  --name "advisor-01"

# 3. Run it (payer is charged 5 TNZO; 4.75 to creator, 0.25 to treasury)
tenzro marketplace run \
  --agent-id <spawned-agent-id> \
  --payer-wallet 0x...02 \
  --tokens-estimate 1024 \
  --max-iterations 4

TypeScript SDK

import { TenzroClient, TESTNET_CONFIG } from "@tenzro/sdk";

const client = await TenzroClient.connect({ ...TESTNET_CONFIG });

// Register a paid template with creator DID + payout wallet
const paid = await client.marketplace.registerAgentTemplate({
  name: "Premium Alpha Advisor",
  description: "Alpha signal generation",
  template_type: "specialist",
  creator_did: "did:tenzro:human:alice",
  creator_wallet: "0x...01",
  pricing: "per_execution:5000000000000000000",
  system_prompt: "You are an alpha advisor...",
  tags: ["paid", "alpha"],
});

// Invoke — returns the detailed fee-split report
const report = await client.marketplace.runAgentTemplate({
  agent_id: "<spawned-agent-id>",
  payer_wallet: "0x...02",
  tokens_estimate: 1024,
  max_iterations: 4,
  dry_run: false,
});

console.log("fee_paid           =", report.fee_paid);
console.log("network_commission =", report.network_commission);
console.log("creator_share      =", report.creator_share);
console.log("invocation_count   =", report.invocation_count);

Rust SDK

use tenzro_sdk::{TenzroClient, config::SdkConfig};

let client = TenzroClient::connect(SdkConfig::testnet()).await?;
let marketplace = client.marketplace();

let report = marketplace.run_agent_template(
    "<spawned-agent-id>",
    "0x...02",          // payer_wallet
    Some(1024),         // tokens_estimate
    Some(4),            // max_iterations
    false,              // dry_run
).await?;

println!("fee_paid           = {}", report.fee_paid);
println!("network_commission = {}", report.network_commission);
println!("creator_share      = {}", report.creator_share);

RPC Methods

List Templates

// Browse free templates only
{
  "jsonrpc": "2.0",
  "method": "tenzro_listAgentTemplates",
  "params": { "free_only": true, "limit": 20, "offset": 0 }
}

// Filter by type
{
  "jsonrpc": "2.0",
  "method": "tenzro_listAgentTemplates",
  "params": { "template_type": "specialist", "limit": 10 }
}

Register a Template

{
  "jsonrpc": "2.0",
  "method": "tenzro_registerAgentTemplate",
  "params": {
    "name": "TypeScript Code Reviewer",
    "description": "Reviews TypeScript/JavaScript for type safety and best practices.",
    "template_type": "specialist",
    "system_prompt": "You are an expert TypeScript code reviewer...",
    "tags": ["typescript", "javascript", "code-review"],
    "pricing": { "type": "free" }
  }
}

Get Template Details

{
  "jsonrpc": "2.0",
  "method": "tenzro_getAgentTemplate",
  "params": { "template_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7" }
}

// Response
{
  "result": {
    "template_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
    "name": "TypeScript Code Reviewer",
    "creator": "addr_creator123...",
    "version": "1.0.0",
    "template_type": "specialist",
    "status": "active",
    "download_count": 42,
    "rating": 87,
    "tags": ["typescript", "javascript", "code-review"],
    "pricing": { "type": "free" }
  }
}

Rust SDK

use tenzro_sdk::{TenzroClient, config::SdkConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = TenzroClient::connect(SdkConfig::testnet()).await?;
    let marketplace = client.marketplace();

    // Browse free templates
    let free = marketplace.list_agent_templates(Some(true), Some(20), Some(0)).await?;
    println!("{} free templates", free.len());

    // Register a free specialist template
    let template = marketplace.register_agent_template(
        "Rust Code Reviewer",
        "Reviews Rust code for safety, idiomatic patterns, and performance.",
        "specialist",
        "You are an expert Rust code reviewer. Check for memory safety,          error handling with Result/Option, and idiomatic patterns.",
        vec!["rust".to_string(), "code-review".to_string()],
        serde_json::json!({ "type": "free" }),
    ).await?;

    println!("Template ID: {}", template.template_id);

    // Register a paid per-execution template
    let paid = marketplace.register_agent_template(
        "Advanced Data Analyst",
        "Statistical analysis and trend detection for CSV and JSON data.",
        "specialist",
        "You are an expert data analyst. Parse data, identify patterns,          and return structured JSON insights.",
        vec!["data".to_string(), "analytics".to_string()],
        serde_json::json!({
            "type": "per_execution",
            "price": "5000000000000000000"  // 5 TNZO
        }),
    ).await?;

    println!("Paid template ID: {}", paid.template_id);

    // Get template details
    let details = marketplace.get_agent_template(&template.template_id).await?;
    println!("Downloads: {}", details.download_count);
    println!("Rating: {}/100", details.rating);

    Ok(())
}

TypeScript SDK

import { TenzroClient, TESTNET_CONFIG } from "@tenzro/sdk";

const client = await TenzroClient.connect({ ...TESTNET_CONFIG });

// Browse free templates
const freeTemplates = await client.marketplace.listAgentTemplates({
  free_only: true,
  limit: 20,
  offset: 0,
});
console.log(`${freeTemplates.length} free templates`);

// Register a free specialist template
const tsReviewer = await client.marketplace.registerAgentTemplate({
  name: "TypeScript Code Reviewer",
  description: "Autonomous agent for TypeScript/JavaScript code review.",
  template_type: "specialist",
  system_prompt:
    "You are an expert TypeScript code reviewer. Check for type safety, " +
    "correctness, performance, and adherence to modern best practices.",
  tags: ["typescript", "javascript", "code-review"],
  pricing: { type: "free" },
});
console.log("Template ID:", tsReviewer.template_id);

// Register a per-execution paid template
const dataAgent = await client.marketplace.registerAgentTemplate({
  name: "Advanced Data Analyst",
  description: "Statistical analysis and data visualisation specialist.",
  template_type: "specialist",
  system_prompt: "You are an expert data analyst...",
  tags: ["data", "analytics", "statistics"],
  pricing: {
    type: "per_execution",
    price: "5000000000000000000", // 5 TNZO per run
  },
});

// Register a subscription-based orchestrator
const orchestrator = await client.marketplace.registerAgentTemplate({
  name: "Research Pipeline Orchestrator",
  description: "Coordinates search, analysis, and report generation agents.",
  template_type: "orchestrator",
  system_prompt: "You are a research pipeline orchestrator...",
  tags: ["research", "orchestration", "multi-agent"],
  pricing: {
    type: "subscription",
    monthly_rate: "50000000000000000000", // 50 TNZO/month
  },
});

// Get template details
const details = await client.marketplace.getAgentTemplate(
  tsReviewer.template_id
);
console.log("Downloads:", details.download_count);
console.log("Rating:", details.rating);
console.log("Pricing:", details.pricing);

Reference Templates

The node bootstraps with 10 reference templates that demonstrate marketplace patterns across DeFi, payments, cross-chain, custody, and AI inference. These templates are loaded into CF_AGENT_TEMPLATES at startup and can be deployed immediately.

Template Capabilities

Discovery and Ratings

Templates are discoverable via tag search, type filter, and popularity sort. Every execution increments download_count. Users can rate templates on-chain (0–100 score) — ratings are stake-weighted to prevent Sybil manipulation.

Revenue Distribution

Paid template revenue flows through the settlement engine:

• 95% → template creator (via micropayment channel)
• 5% → Tenzro Network treasury

Revenue-share templates split earnings between the creator and any downstream providers that contributed to execution.