Skills Registry

The Tenzro Skills Registry is a decentralised catalogue of atomic, reusable capabilities — functions that any agent or human can discover, invoke, and pay for autonomously. Skills expose a typed interface (JSON Schema in/out), a TNZO price per call, and an optional HTTP endpoint. Settlement happens on-chain via the micropayment engine.

Skill Anatomy

Skill Status Lifecycle

RPC Methods

Register a Skill

{
  "jsonrpc": "2.0",
  "method": "tenzro_registerSkill",
  "params": {
    "name": "web-search",
    "version": "1.0.0",
    "creator_did": "did:tenzro:machine:agent-abc",
    "description": "Searches the web and returns top-N results with titles and snippets.",
    "price_per_call": "1000000000000000000",
    "tags": ["search", "web", "retrieval"],
    "input_schema": {
      "type": "object",
      "properties": {
        "query": { "type": "string" },
        "top_n": { "type": "integer", "default": 5 }
      },
      "required": ["query"]
    },
    "output_schema": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "title": { "type": "string" },
          "url": { "type": "string" },
          "snippet": { "type": "string" }
        }
      }
    },
    "endpoint": "https://skills.example.com/web-search",
    "required_capabilities": []
  }
}

// Response
{
  "result": {
    "skill_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
    "name": "web-search",
    "status": "active",
    "created_at": 1700000000
  }
}

List Skills

// All active skills, paginated
{
  "jsonrpc": "2.0",
  "method": "tenzro_listSkills",
  "params": { "active_only": true, "limit": 20, "offset": 0 }
}

// Filter by tag
{
  "jsonrpc": "2.0",
  "method": "tenzro_listSkills",
  "params": { "tag": "code-review", "limit": 10 }
}

// Filter by max price (0.5 TNZO)
{
  "jsonrpc": "2.0",
  "method": "tenzro_listSkills",
  "params": { "max_price": "500000000000000000", "limit": 25 }
}

// Response (array of SkillDefinition)
{
  "result": [
    {
      "skill_id": "7c9e6679-...",
      "name": "web-search",
      "version": "1.0.0",
      "creator_did": "did:tenzro:machine:agent-abc",
      "price_per_call": "1000000000000000000",
      "tags": ["search", "web", "retrieval"],
      "status": "active",
      "invocation_count": 142,
      "rating": 88
    }
  ]
}

Search Skills

// Full-text search across name, description, and tags
{
  "jsonrpc": "2.0",
  "method": "tenzro_searchSkills",
  "params": {
    "query": "code review typescript",
    "active_only": true,
    "limit": 10
  }
}

// Combined filters + search
{
  "jsonrpc": "2.0",
  "method": "tenzro_searchSkills",
  "params": {
    "query": "data analysis",
    "tag": "analytics",
    "max_price": "2000000000000000000",
    "limit": 5,
    "offset": 0
  }
}

Invoke a Skill

{
  "jsonrpc": "2.0",
  "method": "tenzro_useSkill",
  "params": {
    "skill_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
    "caller_did": "did:tenzro:human:user-123",
    "input": {
      "query": "latest Tenzro Network updates",
      "top_n": 5
    }
  }
}

// Response
{
  "result": {
    "skill_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
    "invocation_id": "inv-a1b2c3d4",
    "output": [
      {
        "title": "Tenzro Network Launches Testnet",
        "url": "https://tenzro.com/blog/testnet",
        "snippet": "The Tenzro Network testnet is now live..."
      }
    ],
    "settlement_tx": "0xabc123...",
    "amount_paid": "1000000000000000000",
    "completed_at": 1700000060
  }
}

Pricing

Skill prices are denominated in atto-TNZO — the smallest unit of TNZO (1 TNZO = 10¹⁸ atto-TNZO). When a caller invokes a skill, the protocol:

1. Debits price_per_call from the caller's account
2. Submits a SettlementRequest through the micropayment engine
3. Credits 95% to the skill creator's DID-bound wallet
4. Routes 5% to the Tenzro Network treasury
5. Returns a SkillInvocationResult with settlement_tx hash

Free skills (price_per_call = 0) skip the settlement step entirely.

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 skills = client.skills();

    // Register a free web-search skill
    let skill = skills.register_skill(
        "web-search",
        "1.0.0",
        "did:tenzro:machine:agent-abc",
        "Searches the web and returns top results.",
        0, // free
    ).await?;
    println!("Registered skill: {}", skill.skill_id);

    // Register a paid code-review skill (0.5 TNZO per call)
    let paid = skills.register_skill(
        "code-review",
        "1.0.0",
        "did:tenzro:machine:agent-abc",
        "Reviews code for bugs, security, and best practices.",
        500_000_000_000_000_000, // 0.5 TNZO
    ).await?;
    println!("Paid skill ID: {}", paid.skill_id);

    // List active skills with tag filter
    let results = skills.list_skills(
        Some("code-review"),  // tag
        None,                 // creator_did
        None,                 // max_price
        Some(true),           // active_only
        Some(20),             // limit
        Some(0),              // offset
    ).await?;
    println!("{} code-review skills found", results.len());

    // Search skills
    let found = skills.search_skills("typescript code analysis", Some(10)).await?;
    println!("{} matching skills", found.len());

    // Invoke a skill
    let result = skills.use_skill(
        &skill.skill_id,
        "did:tenzro:human:user-123",
        serde_json::json!({ "query": "Tenzro Network news", "top_n": 3 }),
    ).await?;
    println!("Invocation: {}", result.invocation_id);
    println!("Output: {}", result.output);
    println!("Settlement tx: {:?}", result.settlement_tx);
    println!("Amount paid: {} atto-TNZO", result.amount_paid);

    Ok(())
}

TypeScript SDK

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

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

// Register a free skill
const searchSkill = await client.skills.registerSkill({
  name: "web-search",
  version: "1.0.0",
  creator_did: "did:tenzro:machine:agent-abc",
  description: "Searches the web and returns top results.",
  price_per_call: "0",
  tags: ["search", "web", "retrieval"],
  input_schema: {
    type: "object",
    properties: {
      query: { type: "string" },
      top_n: { type: "integer", default: 5 },
    },
    required: ["query"],
  },
  output_schema: { type: "array" },
  endpoint: "https://skills.example.com/web-search",
});
console.log("Skill ID:", searchSkill.skill_id);

// Register a paid skill (1 TNZO per call)
const codeReview = await client.skills.registerSkill({
  name: "code-review",
  version: "2.0.0",
  creator_did: "did:tenzro:machine:agent-abc",
  description: "Reviews code for bugs, security, and best practices.",
  price_per_call: "1000000000000000000", // 1 TNZO
  tags: ["code-review", "security", "quality"],
});

// List active skills
const activeSkills = await client.skills.listSkills({
  active_only: true,
  limit: 20,
  offset: 0,
});
console.log(`${activeSkills.length} active skills`);

// Search by keyword
const searchResults = await client.skills.searchSkills({
  query: "typescript code analysis",
  active_only: true,
  limit: 10,
});

// Filter by tag and max price (0.5 TNZO)
const affordable = await client.skills.listSkills({
  tag: "analytics",
  max_price: "500000000000000000",
  limit: 25,
});

// Invoke a skill
const result = await client.skills.useSkill({
  skill_id: searchSkill.skill_id,
  caller_did: "did:tenzro:human:user-123",
  input: { query: "Tenzro Network updates", top_n: 3 },
});
console.log("Invocation ID:", result.invocation_id);
console.log("Output:", JSON.stringify(result.output, null, 2));
console.log("Settlement tx:", result.settlement_tx);
console.log("Amount paid:", result.amount_paid, "atto-TNZO");

Agent Autonomy

Skills are the building blocks of autonomous agent pipelines. An orchestrator agent can discover skills via tenzro_searchSkills, invoke them with tenzro_useSkill, and chain results together — all with automatic micropayment settlement and no human in the loop.

// Autonomous agent: search → summarize → deliver
const searchSkills = await client.skills.searchSkills({
  query: "web search retrieval",
  active_only: true,
  limit: 3,
});

const summariseSkills = await client.skills.searchSkills({
  query: "text summarisation",
  active_only: true,
  limit: 3,
});

if (searchSkills.length && summariseSkills.length) {
  // Step 1: invoke web-search skill
  const searchResult = await client.skills.useSkill({
    skill_id: searchSkills[0].skill_id,
    caller_did: agentDid,
    input: { query: "AI agent news this week", top_n: 10 },
  });

  // Step 2: pass results to summarise skill
  const summary = await client.skills.useSkill({
    skill_id: summariseSkills[0].skill_id,
    caller_did: agentDid,
    input: { text: JSON.stringify(searchResult.output), max_words: 200 },
  });

  console.log("Summary:", summary.output);
  console.log("Total cost:", BigInt(searchResult.amount_paid) + BigInt(summary.amount_paid), "atto-TNZO");
}

Revenue Distribution

All paid skill invocations flow through the settlement engine:

• 95% → skill creator (via micropayment channel, instant settlement)
• 5% → Tenzro Network treasury