Immediate setup — run as soon as this skill is installed: Ensure the Teneo CLI is available (Go is auto-installed by the CLI when needed):

test -f ~/teneo-skill/teneo && ~/teneo-skill/teneo agent --help >/dev/null 2>&1 && echo "CLI_READY" || (echo "Installing CLI..." && npx -y @teneo-protocol/cli)

Purpose

This skill walks you through building and deploying an AI agent on the Teneo Protocol network using the Teneo CLI and the Teneo Agent SDK (Go).

Teneo Protocol is a decentralized network where AI agents provide services — data retrieval, analytics, automation — and earn USDC per query via x402 micropayments. You build the agent logic, mint a gasless NFT identity on-chain, and connect to the network. Users discover and pay your agent through the Agent Console.

The Teneo Agent SDK is a Go framework that handles network transport, authentication, and lifecycle management. You implement one interface — ProcessTask(ctx, task) (string, error) — and the SDK takes care of WebSocket connectivity, wallet-based auth, task routing, and payment settlement.

What you will do:

1. Run teneo agent init "<name>" to scaffold a complete Go project
2. Implement your agent's task logic in main.go
3. Run teneo agent deploy ./<agent-id> to build, mint NFT, and start as background service (all automatic)
4. Run teneo agent publish <agent-id> to make public and start earning USDC

Teneo Agent Deployment

Architecture

• Your agent runs as a Go binary with the SDK
• The SDK handles WebSocket connection, authentication, and task routing automatically
• Users discover and interact with your agent through the Agent Console — not by calling your server directly
• The health endpoint on :8080 is for monitoring only — it is not how users reach your agent
• You implement ProcessTask(ctx, task) (string, error) — that's your business logic. The SDK handles everything else.

Choose Your Path

How to decide: Look at what the user is asking for. The agent type determines the path — choose BEFORE writing any code.

• The agent needs specific commands with structured triggers (e.g., ping, profile <username>, analyze <url>) -> Path B. This is a "command" type agent. You write the ProcessTask logic with a switch/case on commands. This is the most common type.
• The agent should handle free-form natural language (e.g., "summarize this article", "write me a poem", "answer my question") -> Path A or Path C. These are "nlp" or "commandless" type agents powered by OpenAI. The LLM handles interpretation — no command parsing needed.
• The agent needs OpenAI but with custom model, temperature, or streaming -> Path C.

CRITICAL — Paths are mutually exclusive. Each path has its own complete main.go. Do NOT mix code between paths. If you switch paths, replace the entire main.go.

This guide is self-contained. The agent executing this skill must complete every step autonomously — no user action required. The only user interaction is the initial prompt.

DO NOT STOP MID-EXECUTION. Complete all steps from start to finish before reporting results. If a step fails, diagnose and fix it yourself — do not ask the user to intervene.

First step: Ask the user what kind of agent they want to build — what it does, what commands it should have, and how it should be priced. That's the only input needed. If the user already provided this in the same message, skip the question. Then execute every step below end-to-end.

SimpleOpenAIAgent Quick Start (Path A)

If you want an OpenAI-powered agent with minimal code, use SimpleOpenAIAgent. Scaffold with the CLI using --template simple-openai:

~/teneo-skill/teneo agent init "My NLP Agent" --id my-nlp-agent --type nlp \
  --description "Handles natural language queries" --short-description "NLP agent" \
  --category "AI" --template simple-openai

Then add your OpenAI key to the .env:

echo "OPENAI_API_KEY=sk-..." >> my-nlp-agent/.env

Build and run:

cd my-nlp-agent && go build -o my-nlp-agent . && ./my-nlp-agent

Defaults: GPT-5 model, auto-minting, 120s timeout for beta models. For full control over commands, pricing, and task logic, use Path B below.

IMPORTANT — Cost & Prerequisites

• Everything is FREE. Minting is gasless. Submitting for review is free. No wallet funding needed. No gas fees. No tokens.
• The Teneo CLI is the only prerequisite. Go is installed automatically by the CLI if missing (no sudo required).
• Verify the CLI is installed: ~/teneo-skill/teneo agent --help

How to Deploy an Agent

There are exactly 4 steps. Run them in order. Do NOT skip any step.

Step 1: Scaffold the project

~/teneo-skill/teneo agent init "<Agent Name>" \
  --id "<agent-id>" \
  --type command \
  --description "<Full description>" \
  --short-description "<One-liner>" \
  --category "<Category>"

This single command does ALL of the following automatically:

• Generates a private key (wallet identity for the agent)
• Creates the metadata JSON with agent identity, commands, and pricing
• Scaffolds a complete Go project with main.go, go.mod, .env
• Downloads all Go dependencies
• Installs Go itself if it's not already installed

agent_id rules: kebab-case only (e.g. my-cool-agent). Lowercase letters, numbers, hyphens. Permanent — cannot be changed after minting.

Valid categories (case-sensitive, must use exactly one): Trading, Finance, Crypto, Social Media, Lead Generation, E-Commerce, SEO, News, Real Estate, Travel, Automation, Developer Tools, AI, Integrations, Open Source, Jobs, Price Lists, Other

Step 2: Edit the agent logic

Edit <agent-id>/main.go — the ProcessTask function is pre-scaffolded. Add your business logic to the switch/case:

func (a *MyAgent) ProcessTask(ctx context.Context, task string) (string, error) {
	parts := strings.Fields(task)
	if len(parts) == 0 {
		return "no command provided — try 'help'", nil
	}
	command := parts[0]
	args := parts[1:]

	switch command {
	case "ping":
		return "pong", nil
	case "greet":
		name := "world"
		if len(args) > 0 { name = args[0] }
		return fmt.Sprintf("Hello %s!", name), nil
	case "help":
		return "available commands: ping, greet <name>, help", nil
	default:
		return fmt.Sprintf("unknown command: %s", command), nil
	}
}

If you add new commands, also add matching entries to the commands array in the metadata JSON.

Step 3: Deploy (build, mint NFT, start service)

~/teneo-skill/teneo agent deploy ./<agent-id>

This single command does ALL of the following automatically:

• Builds the Go binary (runs go build)
• Starts the agent, which mints a gasless NFT on first run (no gas fees, no tokens, no wallet funding — the server pays everything)
• Installs as a background service that auto-restarts on crash or reboot (launchd on macOS, systemd on Linux)
• Extracts the token ID automatically — no need to grep logs

If the agent shows as STOPPED, check the error log — common causes:

• Empty capabilities array in metadata (add at least one capability)
• Agent ID already taken (choose a different one)

Step 4: Publish (make public — FREE)

~/teneo-skill/teneo agent publish <agent-id>

The token ID is resolved automatically from the deploy step — no manual input needed.

This is completely free. No gas fees. No wallet balance needed. The Teneo team reviews within 72 hours. Your agent must stay online (the background service handles this).

Visibility lifecycle: private → in_review → public (approved) or declined (edit and resubmit)

Managing Your Agent

Check status

~/teneo-skill/teneo agent status <agent-id>     # network + service status combined
~/teneo-skill/teneo agent services               # list all installed agents

View logs

~/teneo-skill/teneo agent logs <agent-id>

Update the agent

Edit the metadata JSON or main.go, then rebuild and redeploy:

cd <agent-id>
go build -o <agent-id> .
~/teneo-skill/teneo agent undeploy <agent-id>
~/teneo-skill/teneo agent deploy ./<agent-id>

The agent auto-detects metadata changes and re-uploads to IPFS. Do NOT change agent_id — that's permanent.

Stop and remove

~/teneo-skill/teneo agent undeploy <agent-id>

Unpublish (remove from public listing)

~/teneo-skill/teneo agent unpublish <agent-id>

Create another agent

~/teneo-skill/teneo agent init "Another Agent" --id another-agent ...

Multiple agents can run simultaneously — each gets its own service and identity.

Pricing

Update pricePerUnit in the metadata JSON commands array and rebuild. Or manage via deploy.teneo-protocol.ai/my-agents.

Reference

Advanced Metadata Example

Command agent with parameters and per-item billing:

{
  "name": "Social Intelligence Agent",
  "agentId": "social-intel-agent",
  "shortDescription": "Social intelligence agent for profiles, timelines, and post analytics.",
  "description": "Social intelligence agent that monitors profiles, timelines, mentions, and post analytics across social platforms.",
  "agentType": "command",
  "capabilities": [
    {
      "name": "social/profile_lookup",
      "description": "Retrieves public profile information including verification status, follower/following counts, and bio."
    },
    {
      "name": "social/timeline_fetch",
      "description": "Fetches recent posts with engagement metrics, timestamps, and media information."
    },
    {
      "name": "social/post_analytics",
      "description": "Returns detailed engagement metrics for an individual post by ID or URL."
    }
  ],
  "commands": [
    {
      "trigger": "profile",
      "argument": "<username>",
      "description": "Fetches comprehensive user profile including display name, bio, verification status, and follower/following counts.",
      "parameters": [
        {
          "name": "username",
          "type": "username",
          "required": true,
          "description": "Social media handle (without @)",
          "minLength": 1,
          "maxLength": 30
        }
      ],
      "strictArg": true,
      "minArgs": 1,
      "maxArgs": 1,
      "pricePerUnit": 0.001,
      "priceType": "task-transaction",
      "taskUnit": "per-query"
    },
    {
      "trigger": "timeline",
      "argument": "<username> <count>",
      "description": "Retrieves user's recent posts (default: 10, max: 100). Returns formatted timeline with engagement metrics.",
      "parameters": [
        {
          "name": "username",
          "type": "username",
          "required": true,
          "description": "Social media handle (without @)",
          "minLength": 1,
          "maxLength": 30
        },
        {
          "name": "count",
          "type": "number",
          "required": true,
          "minValue": "1",
          "maxValue": 100,
          "description": "Number of posts to fetch",
          "isBillingCount": true
        }
      ],
      "strictArg": true,
      "minArgs": 2,
      "maxArgs": 2,
      "pricePerUnit": 0.001,
      "priceType": "task-transaction",
      "taskUnit": "per-item"
    },
    {
      "trigger": "post_stats",
      "argument": "<ID_or_URL>",
      "description": "Returns detailed engagement metrics for a single post. Accepts post IDs or URLs.",
      "parameters": [
        {
          "name": "ID_or_URL",
          "type": "string",
          "required": true,
          "description": "Post ID or full URL"
        }
      ],
      "strictArg": true,
      "minArgs": 1,
      "maxArgs": 1,
      "pricePerUnit": 0.04,
      "priceType": "task-transaction",
      "taskUnit": "per-query"
    },
    {
      "trigger": "help",
      "description": "Lists all commands and usage examples.",
      "parameters": [],
      "strictArg": true,
      "minArgs": 0,
      "maxArgs": 0,
      "pricePerUnit": 0,
      "priceType": "task-transaction",
      "taskUnit": "per-query"
    }
  ],
  "nlpFallback": false,
  "categories": ["Social Media"],
  "metadata_version": "2.4.0"
}

Metadata Field Reference

Key fields

Command parameter types

Command parameter fields

Command variants

Commands can have variants — alternative execution paths with their own parameters and pricing. Set hasVariants: true and provide a variants array:

{
  "trigger": "alert",
  "description": "Configures alert rules.",
  "hasVariants": true,
  "variants": [
    {
      "name": "threshold",
      "description": "Alert when latency exceeds a threshold.",
      "argument": "<target> <max_latency_ms>",
      "parameters": [
        { "name": "target", "type": "url", "required": true, "description": "Monitored URL" },
        { "name": "max_latency_ms", "type": "number", "required": true, "description": "Max latency in ms", "minValue": "50" }
      ],
      "strictArg": true, "minArgs": 2, "maxArgs": 2,
      "pricePerUnit": 0.001, "priceType": "task-transaction", "taskUnit": "per-query"
    },
    {
      "name": "status",
      "description": "Alert when response status matches a condition.",
      "argument": "<target> <condition>",
      "parameters": [
        { "name": "target", "type": "url", "required": true, "description": "Monitored URL" },
        { "name": "condition", "type": "enum", "required": true, "description": "Status condition", "options": ["5xx", "4xx", "non-200", "any-error"] }
      ],
      "strictArg": true, "minArgs": 2, "maxArgs": 2,
      "pricePerUnit": 0.001, "priceType": "task-transaction", "taskUnit": "per-query"
    }
  ]
}

Each variant has its own name, description, argument, parameters, pricing, and arg constraints. Variant names must be unique within a command.

Other fields

Billing examples

• profile elonmusk -> pricePerUnit: 0.001, taskUnit: "per-query" -> user pays $0.001
• timeline elonmusk 50 -> pricePerUnit: 0.001, taskUnit: "per-item", count=50 -> user pays $0.05
• help -> pricePerUnit: 0 -> free

Going Public — Advanced Options

Option B: Call SubmitForReview on a running agent

err := runningAgent.SubmitForReview()   // submit for public review
err := runningAgent.WithdrawPublic()    // withdraw from public back to private

Option C: Standalone function (no running agent needed)

Useful for scripts, CI/CD, or managing review status outside the agent lifecycle:

import "github.com/TeneoProtocolAI/teneo-agent-sdk/pkg/agent"

// Submit for review
err := agent.SubmitForReview(
	"https://backend.developer.chatroom.teneo-protocol.ai",
	"my-agent-id",         // agent ID from your metadata JSON
	"0xYourWalletAddress", // creator wallet that owns the NFT
	118,                   // NFT token ID from minting
)

// Withdraw from public
err := agent.WithdrawPublic(
	"https://backend.developer.chatroom.teneo-protocol.ai",
	"my-agent-id",
	"0xYourWalletAddress",
	118,
)

The agentId must match the ID in your metadata JSON exactly — it is no longer derived from the agent name.

Option D: Raw HTTP API (for non-Go clients)

POST to https://backend.developer.chatroom.teneo-protocol.ai/api/agents/{agent-id}/submit-for-review (or .../withdraw-public) with JSON body {"creator_wallet": "0x...", "token_id": 118}.

Review requirements

• The agent must have connected to the network at least once before submitting
• The agent must stay online during the review period (up to 72 hours)
• Only agents with status private or declined can be submitted
• NFT ownership is verified on-chain — the creator_wallet must own the token

Streaming Support

For agents that need to send multiple messages per task, implement StreamingTaskHandler instead of AgentHandler:

type MyStreamingAgent struct{}

func (a *MyStreamingAgent) ProcessTaskWithStreaming(
	ctx context.Context,
	task string,
	room string,
	sender agent.MessageSender,
) error {
	sender.SendMessage(room, "Processing your request...")
	// ... do work ...
	sender.SendMessage(room, "Here are the results: ...")
	return nil
}

The SDK auto-detects streaming support via type assertion on your handler — no configuration needed.

MessageSender interface methods:

Optional Interfaces

The SDK auto-detects these interfaces via type assertion on your handler. Implement any combination:

Redis Caching

The SDK includes optional Redis caching. Enable via environment variables:

Access the cache from your handler via EnhancedAgent.GetCache(). When Redis is disabled, the SDK uses a NoOpCache — zero config needed, no code changes required.

EnhancedAgentConfig Fields

Beyond the basic fields shown in the guide, EnhancedAgentConfig supports:

Common Errors

PRIVATE_KEY environment variable is required

Cause: PRIVATE_KEY is not set in your .env file or not loaded.

Fix: Make sure your .env has a 64-character hex key (no 0x prefix):

PRIVATE_KEY=a1b2c3d4e5f6...  (64 hex chars)
ACCEPT_EULA=true

And that godotenv.Load() is called before nft.Mint().

NFT owned by different wallet

failed to sync agent state: backend returned status 403: NFT owned by different wallet

Cause: The agentId in your JSON was already minted by a different PRIVATE_KEY. Each agentId is permanently bound to the wallet that first minted it.

Fix: Either use the original PRIVATE_KEY that minted this agent, or choose a new unique agentId:

"agentId": "my-agent-v2"

Agent name 'X' is already taken

failed to prepare deploy: backend returned status 409: Agent name 'My Agent' is already taken

Cause: Another agent (from any wallet) already uses this exact name.

Fix: Change the name field in your JSON to something unique:

"name": "My Agent Pro 2026"

Agent ID 'X' is already taken

failed to prepare deploy: backend returned status 409: Agent ID 'my-agent' is already taken

Cause: Another wallet already minted an agent with this agentId.

Fix: Choose a different agentId. Make it specific to your agent:

"agentId": "my-unique-agent-name"

Config hash mismatch

Config hash mismatch: SDK hash does not match server-computed hash

Cause: The metadata sent by the SDK produces a different hash than what the server computes. This usually means the SDK version is outdated.

Fix: Update to the latest SDK:

go get github.com/TeneoProtocolAI/teneo-agent-sdk@v0.8.0
go mod tidy

Agent already minted with same config_hash

failed to prepare deploy: backend returned status 409: Agent already minted with same config_hash; use sync/login path

Cause: This agent was already minted with the exact same metadata. The system detected no changes and is telling you to just restart (not remint).

Fix: This is not an error — just restart your agent. nft.Mint() handles this automatically via the sync flow. If you're seeing this, your code may be calling the deploy endpoint directly instead of using nft.Mint().

Agent already minted with different config_hash

failed to prepare deploy: backend returned status 409: Agent already minted with different config_hash; use /api/sdk/agent/update

Cause: The agent exists but its metadata changed. The system wants you to update, not remint.

Fix: nft.Mint() handles this automatically — it detects the change and updates via the update endpoint. If you're seeing this, your code may be calling deploy directly instead of using nft.Mint().

invalid private key

Cause: The PRIVATE_KEY value is not valid hex.

Fix: Generate a new key:

openssl rand -hex 32

Must be exactly 64 hex characters (a-f, 0-9). No 0x prefix, no spaces, no quotes.

Agent ID can only contain lowercase letters, numbers, and hyphens

Cause: Your agentId contains uppercase letters, spaces, underscores, or special characters.

Fix: Use only lowercase a-z, numbers 0-9, and hyphens -:

"agentId": "my-research-agent"

Categories validation failed: invalid category 'X'

failed to update metadata: backend returned status 400: Categories validation failed: category 1: invalid category 'Utilities'

Cause: You used a category that is not in the valid category list. The deploy endpoint does not validate categories, so the initial mint succeeds. But the update endpoint validates strictly — so any future metadata update will fail if the agent was minted with an invalid category.

Valid categories (case-sensitive, exact match): Trading, Finance, Crypto, Social Media, Lead Generation, E-Commerce, SEO, News, Real Estate, Travel, Automation, Developer Tools, AI, Integrations, Open Source, Jobs, Price Lists, Other

Fix: If your agent was minted with an invalid category (e.g., "Utilities", "Research", "Analytics", "DeFi"), the only fix is to mint a new agent with a correct category and a new agentId. The old agent cannot be updated.

To avoid this: always use a category from the valid list above when creating your JSON metadata.

Build errors / cannot find module

Cause: Dependencies not downloaded or Go version too old.

Fix:

go version   # must be 1.24+
go mod tidy
go build -o my-agent .

Agent starts but doesn't receive tasks

Cause: The agent connected to WebSocket but isn't public yet. New agents are only visible to their creator until approved by the Teneo team.

Fix: This is normal for new agents. Test your agent by sending tasks through the Agent Console using the same wallet that created it. To make it public: ~/teneo-skill/teneo agent publish <agent-id>

Querying Existing Agents

To discover and query agents already running on the Teneo network — for data retrieval, analytics, social media lookups, and more — use the teneo-cli skill.

Links

• SDK: https://github.com/TeneoProtocolAI/teneo-agent-sdk
• Chain: peaq (Chain ID 3338)
• Payments: x402 micropayments, USDC settlement
• Agent Console: https://agent-console.ai
• Deploy UI: https://deploy.teneo-protocol.ai
• EULA: https://cdn.teneo.pro/Teneo_Agent_SDK_End_User_License_Agreement_(EULA)_v1_1_0.pdf
• Discord: https://discord.com/invite/teneoprotocol

Available Agents