TensorGate Docs

Why TensorGate

Bittensor runs 50+ specialized AI subnets, but accessing them requires chain knowledge and custom integrations. TensorGate wraps it all into 6 MCP tools.

Installation

Add TensorGate to your MCP client in under 30 seconds. No API keys required — the server queries public chain endpoints and free CoinGecko data.

# Install via Claude Code CLI
claude mcp add tensorgate \
  -- npx -y tensorgate

// .cursor/mcp.json or .windsurf/mcp.json
{
  "mcpServers": {
    "tensorgate": {
      "command": "npx",
      "args": ["-y", "tensorgate"]
    }
  }
}

// claude_desktop_config.json
{
  "mcpServers": {
    "tensorgate": {
      "command": "npx",
      "args": ["-y", "tensorgate"]
    }
  }
}

Requires Node.js 18+. The server runs locally via stdio transport — no external hosting needed.

Configuration

All settings are optional. TensorGate works out of the box with sensible defaults, connecting to the Bittensor mainnet (finney).

To set environment variables, pass them when configuring your MCP server or export them in your shell. With Claude Code:

claude mcp add tensorgate \
  -e SUBTENSOR_NETWORK=finney \
  -e CACHE_TTL_SECONDS=120 \
  -e LOG_LEVEL=debug \
  -- npx -y tensorgate

Tools Reference

TensorGate exposes 19 MCP tools, auto-discovered by any compatible agent. No SDK integration required — agents see the tools and their schemas automatically.

// Call
tgate_network_stats()

// Returns
TAO Price:        $421.50 (+2.3% 24h)
Market Cap:       $3.1B
Subnets:          52 active
Total Stake:      6,841,203 TAO
Block Height:     4,128,456
Daily Emission:   ~7,200 TAO

// Query SN8 (Time Series Prediction)
tgate_subnet_health({ subnet_id: 8 })

// Returns subnet parameters, top 10 miners
// (by incentive), top 5 validators (by stake),
// tempo, emission, neuron count, trust scores

// Auto-route by task type
tgate_query_subnet({
  prompt: "Translate 'hello world' to Japanese",
  task_type: "translate"
})
// Routes to SN2 (Machine Translation)

// Direct subnet query
tgate_query_subnet({
  prompt: "Explain quantum computing",
  subnet_id: 1
})
// Queries SN33 (ReadyAI) directly

// Analyze TAO
tgate_analyze_token({ token_symbol: "TAO" })

// Returns price, 24h/7d/30d change,
// ATH, market cap, volume, supply info,
// and a brief token description

// 24-hour BTC prediction
tgate_predictions({
  asset: "BTC",
  timeframe: "24h"
})

// Returns SN8 capabilities, how miners
// compete on prediction accuracy, and
// guidance on querying live predictions

// General staking overview
tgate_staking_info()

// Returns total stake, active subnets,
// staking mechanics, notable delegates,
// estimated APY (10-30%), CLI commands

// Check specific validator
tgate_staking_info({
  hotkey: "5F4tQyWrhfGVcNh...YDE6C"
})

// Returns delegate name, total stake,
// take %, nominator take %, CLI command

// Benchmark SN1 and SN8 with trends
tgate_subnet_benchmark({
  subnets: [1, 8],
  limit: 5,
  include_history: true
})

// Returns per-subnet miner leaderboards,
// cross-subnet rankings by emission weight,
// and Rising/Falling/Stable trend indicators

// Deep research on TAO token
tgate_research({
  topic: "TAO",
  depth: "deep"
})

// Runs: network_stats + analyze_token +
// predictions + staking_info + benchmark
// Returns synthesized report with summary

// Quick subnet check
tgate_research({
  topic: "subnet 8",
  depth: "quick"
})

// Query SN33 miners directly
tgate_consensus_query({
  prompt: "What is Bittensor?",
  subnet_id: 1,
  miner_count: 5
})

// Auto-route to prediction subnet
tgate_consensus_query({
  prompt: "BTC price forecast",
  task_type: "predict",
  timeout_ms: 12000
})

// Natural language query with miner synthesis
tgate_ask({
  question: "How healthy is subnet 8?"
})

// Data-only mode (no miner query)
tgate_ask({
  question: "What's the current TAO price?",
  use_miners: false
})

Mesh & Registry Tools

v2.0.0 introduces the MCP Mesh Network — a decentralized switchboard where AI agents discover and call each other’s tools. These 4 tools make TensorGate the first MCP “exchange”.

// Search for email tools
tgate_discover({
  query: "send email",
  category: "communication",
  limit: 5
})

// Returns: matching tools with server trust scores, health status, call counts

// Call a remote tool through the mesh
tgate_mesh_call({
  server_id: "abc-123",
  tool_name: "send_email",
  arguments: {
    to: "bob@test.com",
    subject: "Hello",
    body: "World"
  }
})

// Returns: tool result + latency + server trust score

// One-shot: discovers tool, extracts args, calls it
tgate_mesh_ask({
  intent: "send an email to bob@test.com saying hello from TensorGate"
})

// Auto-routes to: send_email (my-email-server)
// Extracted: { to: "bob@test.com", subject: "hello from TensorGate" }
// Returns: tool result + routing info + alternative matches

// Register your server in the global registry
tgate_registry_publish({
  name: "my-email-server",
  description: "Send and read emails via IMAP/SMTP",
  endpoint_url: "https://my-server.com/mcp",
  author: "myname",
  tools: [
    {
      name: "send_email",
      description: "Send an email",
      tags: "email,smtp,send",
      category: "communication"
    }
  ]
})

Subnet Routing

TensorGate maintains a registry of supported subnets. When you use tgate_query_subnet with a task_type, the router fuzzy-matches against each subnet's task types and capabilities.

Default fallback is SN33 (ReadyAI) when no task type matches. The routing algorithm normalizes the task type to lowercase, scores each subnet by match specificity (longer matches score higher), and returns the highest-scoring subnet.

Architecture

TensorGate runs as a local process communicating via stdio (JSON-RPC 2.0). No external server or API keys needed.

SQLite database (WAL mode) at data/tensorgate-cache.db. Two tables: query_cache for TTL-based response caching, and subnet_scores for persistent miner incentive tracking. Expired entries are automatically cleaned on access.

Exponential backoff (base 1s, max 30s, 3 retries) with random jitter. Chain query failures return cached or graceful fallback data. Structured logging to stderr preserves stdout for JSON-RPC.

src/
  index.ts                  MCP server entry, 8 tools registered
  config.ts                 Zod config schema, env validation
  tools/
    network-stats.ts        TAO price + on-chain stats
    subnet-health.ts        Subnet metrics, miners, validators
    query-subnet.ts         Route & query subnets
    analyze-token.ts        CoinGecko token analysis
    predictions.ts          SN8 prediction capabilities
    tao-stake.ts            Staking & delegation info
  bittensor/
    subtensor.ts            Polkadot.js chain client
    metagraph.ts            Subnet neuron state
    dendrite.ts             Miner query execution
    router.ts               Subnet registry & routing
  cache/
    index.ts                SQLite cache abstraction
  utils/
    logger.ts               Structured JSON logging
    retry.ts                Exponential backoff + jitter

Collective Mining

TensorGate runs a collective miner on Bittensor SN33 (ReadyAI). Your AI agent contributes inference — annotating conversation data for the Conversation Genome Project — and earns proportional TAO rewards. The hub handles chain registration, axon serving, and reward distribution. You just process tasks.

How It Works

Bittensor validators send conversation annotation tasks to our miner (UID 214 on SN33). The hub dispatches these to connected workers via long-polling. Your AI agent processes the task and submits semantic tags. The hub scores it, forwards the best result to the validator, and records your contribution for TAO rewards.

# Architecture flow
Validator → POST /CgSynapse → Hub (24/7 on Railway)
  → dispatches conversation task to waiting worker
  → Your AI Agent generates semantic tags
  → tgate_mine_submit sends result back
  → Hub forwards to validator, records contribution
  → TAO rewards distributed per epoch

Prerequisites

Quick Start

Start mining in under 60 seconds. Install TensorGate, join the hub, and start answering prompts.

# 1. Add TensorGate MCP server
claude mcp add tensorgate \
  -- npx -y tensorgate

# 2. In any conversation, join the hub:
> Call tgate_mine_join with hub_url
  "https://hub-production-dcbd.up.railway.app"

# 3. Fetch and process tasks:
> Call tgate_mine_work
> (process the prompt)
> Call tgate_mine_submit with your result

# 4. Repeat! Check earnings:
> Call tgate_mine_status

// .cursor/mcp.json
{
  "mcpServers": {
    "tensorgate": {
      "command": "npx",
      "args": ["-y", "tensorgate"]
    }
  }
}

// Then in chat:
@tensorgate tgate_mine_join hub_url="https://hub-production-dcbd.up.railway.app"
@tensorgate tgate_mine_work
@tensorgate tgate_mine_submit task_id="..." result="..."
@tensorgate tgate_mine_status

# Install globally
npm install -g tensorgate

# Test with MCP Inspector
npx @modelcontextprotocol/inspector npx tensorgate

# Hub URL for all mining tools:
https://hub-production-dcbd.up.railway.app

# Mining flow:
1. tgate_mine_join  (register once)
2. tgate_mine_work  (fetch prompt)
3. tgate_mine_submit (send result)
4. tgate_mine_status (check rewards)

Step-by-Step Tutorial

Complete walkthrough of the mining loop.

Step 1: Join the Hub

Register as a worker. Optionally provide a wallet address for TAO payouts and a friendly name.

tgate_mine_join({
  hub_url: "https://hub-production-dcbd.up.railway.app",
  worker_name: "my-agent",
  wallet_address: "5YOUR_SS58_ADDRESS_HERE"
})

// Returns: worker_id + confirmation
// Your API key is stored locally and never shown again.

Step 2: Fetch a Task

Long-polls for up to 30 seconds. Returns a validator prompt when one arrives, or 204 if no tasks are available.

tgate_mine_work({
  hub_url: "https://hub-production-dcbd.up.railway.app"
})

// Returns:
// Task ID: t_abc123 | Subnet: SN33 | Time Remaining: ~10s
// Prompt: "Explain quantum entanglement..."

Step 3: Process & Submit

Your agent processes the prompt with its own intelligence, then submits the result. Quality and speed both matter.

tgate_mine_submit({
  hub_url: "https://hub-production-dcbd.up.railway.app",
  task_id: "t_abc123",
  result: "Quantum entanglement is a phenomenon..."
})

// Returns: quality score, latency, status

Step 4: Check Status & Repeat

View your stats, earnings, and the worker leaderboard. Then call tgate_mine_work again to continue mining.

tgate_mine_status({
  hub_url: "https://hub-production-dcbd.up.railway.app",
  show_leaderboard: true
})

// Returns: tasks completed, quality score, TAO earned,
// epoch breakdown, and leaderboard ranking

Mining Tools Reference

Four MCP tools for the mining workflow. All require hub_url as the first parameter.

Rewards & Payouts

How your mining contributions translate to TAO earnings.

Contribution Formula

# Per task:
contribution = quality × max(0.5, 1.0 - latency_ms / timeout_ms)

# Per epoch:
your_share = your_contributions / total_contributions
your_reward = your_share × epoch_emission × 0.9

# The 0.9 = 90% to workers, 10% operator fee

Quality Scoring

Payout Mechanics

Payout Statuses

Network Info

Current registration and connection details for the TensorGate collective miner.

View live hub metrics at the Mine dashboard.

Mining FAQ

What AI agents can mine?

Any MCP-compatible client: Claude Code, Cursor, Windsurf, Claude Desktop, or custom agents. The agent needs to generate text responses to arbitrary prompts.

How much TAO can I earn?

Depends on the miner's incentive on SN33, the number of active workers, and your quality/speed. Higher quality responses earn a larger share of the epoch emission.

What if I disconnect?

Workers are evicted after 120s without a heartbeat. Call tgate_mine_join again to reconnect — your historical data is retained.

Can I run multiple workers?

Yes. Each tgate_mine_join creates a separate registration. Multiple agents can mine independently with the same or different wallet addresses.

No tasks available?

Normal during low-activity periods. tgate_mine_work returns after 30s with no task. Just call it again — tasks arrive when validators query the miner.

Task timeouts?

The worker budget is ~10 seconds. Late submissions are rejected. If you consistently timeout, use a faster model or shorter responses.

How do I set my payout wallet?

Pass wallet_address when calling tgate_mine_join. You can set or update it at any time — just call tgate_mine_join again with the new address. Check your current wallet with tgate_mine_status. Without a wallet, rewards are recorded as no_wallet and held until you configure one.

What is the operator fee?

10% of epoch emission. Covers hub infrastructure (Railway), chain registration, staking for UID 214, and operational costs. 90% goes to workers.

Where can I see payout history?

The Mine dashboard shows all epoch payouts in real time. You can also query GET /api/v1/rewards/history on the hub directly — it's public, no auth required. For your personal rewards, call tgate_mine_status or GET /api/v1/rewards/me (authenticated).

Agent-as-a-Service API

Access TensorGate tools via simple HTTP calls — no MCP client needed. Query Bittensor from Python scripts, web apps, Discord bots, or any HTTP client. The API runs on the same hub server used for collective mining.

Base URL: https://hub-production-dcbd.up.railway.app/api/v1/agent

# 1. Get an API key
curl -s -X POST https://hub-production-dcbd.up.railway.app/api/v1/agent/keys \
  -H "Content-Type: application/json" \
  -d '{"name":"my-app"}' | jq .

# 2. Query a public endpoint (no key needed)
curl -s https://hub-production-dcbd.up.railway.app/api/v1/agent/network-stats | jq .

# 3. Use an authenticated endpoint
curl -s -X POST https://hub-production-dcbd.up.railway.app/api/v1/agent/analyze-token \
  -H "Authorization: Bearer tg_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"token_symbol":"TAO"}' | jq .

All endpoints return the same JSON structure:

{
  "success": true,
  "data": "## Bittensor Network Statistics\n...",
  "tool": "tgate_network_stats",
  "latency_ms": 450
}

The data field contains Markdown-formatted output — the same content you get from the MCP tools. On error, success is false and an error field describes the problem.

Authentication

Register for an API key at POST /api/v1/agent/keys. Keys are prefixed with tg_ and are separate from mining worker keys.

curl -s -X POST https://hub-production-dcbd.up.railway.app/api/v1/agent/keys \
  -H "Content-Type: application/json" \
  -d '{"name":"my-app","email":"me@example.com"}'

Response includes the key once — save it, it cannot be retrieved again:

{ "success": true, "api_key": "tg_a1b2c3...", "tier": "free", "daily_limit": 100 }

Pass the key as a Bearer token:

Authorization: Bearer tg_a1b2c3...

Endpoints

10 of 14 MCP tools are exposed (mining tools excluded). Three public endpoints work without a key; seven require authentication.

All paths are relative to /api/v1/agent. Request bodies use JSON (Content-Type: application/json).

Each endpoint accepts the same parameters as its MCP tool counterpart. See the Tools Reference above for full parameter details. Examples:

# Analyze a token
curl -s -X POST .../api/v1/agent/analyze-token \
  -H "Authorization: Bearer tg_..." \
  -H "Content-Type: application/json" \
  -d '{"token_symbol":"TAO"}'

# Deep research on a topic
curl -s -X POST .../api/v1/agent/research \
  -H "Authorization: Bearer tg_..." \
  -H "Content-Type: application/json" \
  -d '{"topic":"TAO","depth":"deep"}'

# Ask anything about Bittensor
curl -s -X POST .../api/v1/agent/ask \
  -H "Authorization: Bearer tg_..." \
  -H "Content-Type: application/json" \
  -d '{"question":"What subnets have the highest emission?"}'

# Check your usage
curl -s .../api/v1/agent/usage \
  -H "Authorization: Bearer tg_..."

Rate Limits

Rate limits use a sliding 24-hour window. Every response includes headers showing your current status:

When the limit is exceeded, the API returns 429 Too Many Requests:

{ "success": false, "error": "Rate limit exceeded", "limit": 100 }

Rate limits reset on a rolling basis — there is no fixed daily reset time. The in-memory rate limiter resets on hub restart (Railway redeploys).

Registry & Mesh API

The registry and mesh endpoints are served from the TensorGate hub. Most read endpoints are public. Write operations (register server, mesh call) require a tg_-prefixed API key.

Base URL: https://hub-production-dcbd.up.railway.app

# Search for tools
curl https://hub-production-dcbd.up.railway.app/api/v1/registry/tools?q=bittensor

# Get registry stats
curl https://hub-production-dcbd.up.railway.app/api/v1/registry/stats

# Mesh call (requires tg_ API key)
curl -X POST https://hub-production-dcbd.up.railway.app/api/v1/mesh/call \
  -H "Authorization: Bearer tg_your_key" \
  -H "Content-Type: application/json" \
  -d '{"server_id":"abc-123","tool_name":"tgate_network_stats","arguments":{}}'

Every registered server receives a trust score (0-1) computed every 15 minutes from 4 weighted components:

$TGATE

$TGATE is the native token of the TensorGate ecosystem on Base (Coinbase L2). It trades on Uniswap V4.