Updates

AI Agent Swarm Coordinator — intelligent task routing based on agent capabilities. Agents declare what they’re good at (coding, research, writing, analysis, translation), and tasks are routed to the best-matching agent based on per-capability quality scores. Turns TensorGate into a general-purpose AI agent swarm.

• tgate_swarm_join — Register as a swarm agent with capabilities (e.g., ["coding", "research"]). Creates per-capability quality tracking.
• tgate_swarm_work — Long-poll for capability-matched tasks. Only receives tasks that match your declared capabilities.
• tgate_swarm_submit — Submit task result. Quality scored per capability via EMA (α=0.2) — better quality = more tasks routed to you.
• tgate_swarm_status — Swarm dashboard: agent count, capabilities, task stats, your per-capability rankings.

• POST /swarm/register — Register agent with capabilities, returns credentials.
• GET /swarm/agents — List agents, filter by capability or status.
• GET /swarm/agents/:id — Agent details with per-capability quality scores.
• POST /swarm/dispatch — Submit task with required/preferred capabilities, auto-routes to best agent.
• GET /swarm/tasks/next — Long-poll for capability-matched task (30s timeout, worker auth).
• POST /swarm/tasks/:id/result — Submit result, quality scored per capability.
• GET /swarm/status — Swarm overview: agents, capabilities, task stats.

• Score = (capability_quality + preferred_bonus) × 0.6 + overall_quality × 0.2 + availability × 0.2
• Per-capability quality tracking via exponential moving average (EMA, α=0.2)
• Agents that don’t match any required capability are excluded from routing
• Availability weighting: idle agents preferred over busy ones

• swarm_agents — Agent registration, capabilities (JSON), status, concurrency tracking.
• swarm_capability_scores — Per-agent per-capability quality scores, task counts, latency.
• swarm_tasks — Tasks with required/preferred capabilities, routing metadata.
• swarm_contributions — Per-task quality log for capability score updates.

• Tool count increased from 19 to 23.
• MCP server version bumped to 2.1.0, hub version bumped to 2.1.0.
• Hub maintenance loop now evicts stale swarm agents and expires timed-out swarm tasks.
• MCP cache adds swarm_credentials table for local credential storage.

MCP Mesh Network + Decentralized Tool Discovery — TensorGate becomes the first MCP “exchange” where AI agents discover and call each other’s tools. Any MCP server can register its tools in a public, searchable registry. Agents find tools by capability (“I need a tool that sends emails”) and call them through a single connection, with trust scoring, health monitoring, and community voting to ensure quality.

• tgate_discover — Search the decentralized tool registry. Find tools by capability, keyword, or category. Returns matching tools with server info, trust scores, call counts, and average latency. FTS5 full-text search on the hub.
• tgate_mesh_call — Call a tool on any remote MCP server through the TensorGate mesh. Proxied via the hub with latency tracking and trust scoring. Supports any tool on any registered server with a StreamableHTTP endpoint.
• tgate_mesh_ask — Natural language tool routing. Describe what you need in plain English (“send an email to bob@test.com saying hello”) and TensorGate discovers the best tool, extracts arguments from your intent using heuristic pattern matching, and calls it automatically. Like DNS for AI tools.
• tgate_registry_publish — Register your MCP server and its tools in the decentralized registry. Makes your tools discoverable by any AI agent worldwide. Supports both StreamableHTTP and stdio transports.

• GET /api/v1/registry/stats — Registry-wide statistics: total servers, tools, mesh calls, healthy servers.
• GET /api/v1/registry/servers — List registered servers (paginated, filterable by health status and author, sorted by trust score).
• GET /api/v1/registry/servers/:id — Server detail with all its registered tools.
• POST /api/v1/registry/servers — Register or update a server and its tools (requires tg_ API key). Supports upsert by name+author.
• DELETE /api/v1/registry/servers/:id — Remove a server and all its tools (cascading delete).
• GET /api/v1/registry/tools — Search tools using FTS5 full-text search with LIKE fallback. Supports q (query), category filter, pagination.
• GET /api/v1/registry/tools/:id — Tool detail with server info and parsed input schema.
• POST /api/v1/registry/servers/:id/vote — Community voting (1-5 stars). IP-fingerprinted to prevent duplicate votes.
• GET /api/v1/registry/categories — List tool categories with counts.
• POST /api/v1/registry/discover — Intent-based tool discovery. Excludes servers marked as “down”.

• POST /api/v1/mesh/call — Proxy tool calls to remote MCP servers. Looks up the server in the registry, sends a JSON-RPC tools/call request to its StreamableHTTP endpoint, logs the call for analytics, and updates call counts + rolling average latency on both tool and server records. 30-second timeout. Rejects calls to servers without endpoints or marked as “down”.

• Health Checker (5-minute interval) — Probes every registered server with an endpoint_url by sending a tools/list JSON-RPC request. Response <5s = healthy, 5-15s = degraded, timeout/error = down. Updates health_status and last_health_check.
• Trust Scorer (15-minute interval) — Computes a weighted trust score for each server: health (30%), reliability from last 100 mesh calls (30%), latency normalized 500ms-10s (20%), community vote average (20%). Scores range 0-1.
• Auto-Publish (on startup) — Seeds the registry with TensorGate’s own 19 tools across 5 categories (bittensor, crypto, mining, defi, mesh). Sets is_verified=1 and initial trust score of 0.9.

• registry_servers — MCP server registry with trust score, health status, call stats, verification flag.
• registry_tools — Tools per server with input schema, tags, category, call counts, latency stats.
• registry_tools_fts — FTS5 virtual table for full-text search across tool name, description, tags, and category.
• registry_votes — Community voting (1-5) per server, deduplicated by IP fingerprint.
• mesh_calls — Call log for analytics and trust scoring: server, tool, latency, success/error.

• src/mesh/registry.ts — Hub registry API client: search tools, discover by intent, mesh call proxy, publish servers, get stats.
• src/mesh/client.ts — MCP StreamableHTTP client wrapper using JSON-RPC. Connection pooling with 5-minute TTL.
• src/mesh/argument-mapper.ts — Heuristic intent-to-argument extraction. Extracts emails, URLs, subjects, body text, numbers, booleans, token symbols from natural language. Also provides tool-match scoring for ranking discovery results.

• Tool count increased from 15 to 19.
• MCP server version bumped to 2.0.0, hub version bumped to 2.0.0.
• Published to npm as tensorgate@2.0.0.

• User’s AI agent connects to TensorGate MCP server (stdio) → tgate_discover searches registry → tgate_mesh_call proxies through hub → hub calls remote server via StreamableHTTP → result returned to agent.
• tgate_mesh_ask chains the full flow: discover → rank by trust+relevance → extract arguments → call → return result. One-shot natural language tool invocation.

Alpha Yield Optimizer — a new MCP tool, REST endpoint, and dashboard section for analyzing per-subnet alpha token yields introduced by Bittensor's dTao upgrade. Computes APY, risk scores, and recommends optimal allocation across all 50+ subnets based on strategy.

• tgate_yield_optimizer — New MCP tool (#15). Analyzes all subnets for alpha token yield: raw APY from emission/alpha/price, 4-factor risk scoring (concentration, competition, dominance, emission), and strategy-based allocation (conservative/balanced/aggressive). Accepts optional hotkey to show current positions with TAO value.
• src/bittensor/yield.ts — Yield computation module with Gini coefficient, APY math from dTao storage keys (SubnetAlphaOut, SubnetAlphaIn, SubnetTAO, SubnetTaoInEmission), risk scoring, strategy allocation engine, and hotkey position lookup.
• src/bittensor/subtensor.ts — Four new chain query functions: getSubnetAlphaOut, getSubnetAlphaIn, getSubnetTAO, getAllSubnetYieldParams (batch fetcher, parallel groups of 4).
• yield_snapshots SQLite table for historical yield tracking. saveYieldSnapshot() and getYieldHistory() added to cache layer. Auto-cleanup retains 30 days.
• Hub REST endpoints: POST /api/v1/agent/yield-optimizer (authed) and GET /api/v1/agent/yield (public) for programmatic access.
• Dashboard Yield Explorer section on dashboard.html — sortable APY table across all subnets, risk badges, strategy selector (Conservative/Balanced/Aggressive), TAO allocation simulator with portfolio summary, all computed client-side from Finney RPC.
• Research tool now classifies yield/alpha/APY topics and routes to the yield optimizer.

• Tool count increased from 14 to 15.
• Server version bumped to 1.6.1.
• Version references updated across all tools, docs, and hub dependency.

• Alpha price = SubnetTAO / SubnetAlphaIn (LP ratio).
• Raw APY = (emission_per_block × 2,628,000 / (alphaOut × alphaPrice)) × 100.
• Risk score (0-100) = concentration (Gini × 35) + competition (fill × 25) + dominance (top miner × 25) + emission level (0-15).
• Strategy weights: conservative = adjAPY × (1-risk)², balanced = adjAPY × (1-risk), aggressive = rawAPY.

Agent-as-a-Service REST API added to the hub. Any app — Python scripts, web apps, Discord bots — can now query Bittensor through simple HTTP calls without needing an MCP client. Also includes major CgSynapse response quality improvements for SN33 scoring.

• 12 new endpoints at /api/v1/agent/ exposing 10 of 14 MCP tools via HTTP (mining tools excluded).
• API key registration at POST /api/v1/agent/keys — returns a tg_-prefixed key (separate from worker auth).
• Three public endpoints (network stats, subnet health, staking info) work without a key; seven tool endpoints require authentication.
• Tiered rate limiting: free tier 100 req/day, pro 10k/day, unlimited. Anonymous IP-based: 50/day. Headers: X-RateLimit-Limit, X-RateLimit-Remaining.
• Per-request usage tracking in new api_usage SQLite table — tool name, latency, success/error per call.
• Usage analytics at GET /api/v1/agent/usage — daily breakdown by tool, error history.
• Lazy-loaded tool handlers avoid Polkadot WS connection at startup.

• Rewrote fallback LLM system prompt with SN33-aware guidance: emphasizes concrete domain-specific tags, broader context inference, forbidden generic tags, category diversity (entities/domains/activities/themes/sentiment), and includes examples.
• Added tag post-processing pipeline: deduplication, generic tag blocklist (30+ terms), filler word filtering, sentence detection (>5 words), sentence-starting pattern rejection, 3-64 char enforcement, 20-tag cap.
• Added detailed logging for tag extraction count, enrichment status, and raw fallback output for quality debugging.

• tgate_mine_work now provides SN33-specific instructions for CgSynapse tasks — workers are told to extract semantic tags in JSON format instead of generating conversational responses.

• Re-registered on SN33 as UID 214 (previously UID 229, pruned due to low incentive in competitive 256-slot subnet).
• Axon re-served at 66.33.22.244:57171 via TCP proxy.

Payout transparency across hub, MCP client, and mine dashboard. Workers can now set or update their TAO wallet at any time, and all reward data is publicly auditable.

• GET /api/v1/rewards/history — New public endpoint. Returns epoch-level payout history with per-worker details: TAO amount, share %, status, and on-chain tx hash. No auth required.
• GET /api/v1/rewards/me now includes tx_hash for each epoch reward (was already stored in the DB, just not returned by the API).
• getEpochPayoutHistory() added to reward tracker — aggregates rewards by epoch with expandable per-worker breakdown.

• tgate_mine_join — Now supports wallet updates after registration. If already registered and wallet_address is provided, calls POST /workers/wallet to update it on the hub. Previously ignored the parameter when already registered.
• tgate_mine_status — Shows wallet address in the "Your Stats" table (or a warning with instructions if not set). Reward epochs table now includes a Status column with Subscan links for distributed tx hashes.

• New "Reward Distribution" section on mine.html between Live Dashboard and Architecture.
• How Rewards Work — static explainer card with formula, latency factor, payout mechanics, and status types.
• Emission Breakdown — live computed from metagraph data (subnet emission/epoch, our incentive %, our emission, distributable 90%).
• Recent Epoch Payouts — live table fetched from /api/v1/rewards/history with expandable rows showing individual worker payouts and Subscan tx hash links.

Added OpenAI embedding vectors to CgSynapse responses. SN33 validators score tags by cosine similarity of embedding vectors against ground truth — our previous empty vectors: {} meant automatic 0 score per tag regardless of tag quality. This resolves the v1.5.0 known limitation and is the single biggest change for earning incentive on SN33.

• src/axon/embeddings.ts — New OpenAI embeddings client. Calls text-embedding-3-small (1536 dimensions) via a single batched API call for all tags (~200-500ms). Deduplicates tags, caps at 20, uses withRetry (1 retry, 500ms delay). Returns Record<string, {vectors: number[]}> in the exact format SN33 expects.
• enrichCgSynapseResult() in server.ts — Hub-level enrichment step between the race result and formatCgSynapseResponse(). Extracts tags from worker or fallback output using multi-stage JSON parsing, generates embedding vectors, and merges them back. Both worker and fallback paths are enriched transparently — workers don't need any changes.
• extractTagsFromResult() in server.ts — Parses tags from raw result strings using the same multi-stage extraction as synapse.ts (direct JSON → fence strip → regex → plain-text split).
• Config: OPENAI_API_KEY, OPENAI_EMBEDDING_MODEL (default: text-embedding-3-small), ENABLE_EMBEDDINGS (default: true).

• Fallback system prompt improved for higher-quality tags: now requests exactly 10-15 tags with at least 5 unique, a mix of specific topics, broader themes, sentiment/tone, named entities, and user intent. Discourages generic tags that score poorly.
• CgSynapse response latency now includes embedding generation time in the bt-header-axon-process-time header.

• Embedding API call adds ~200-500ms to response time (well within 20s hard timeout).
• Worker + embeddings: 5.5-8.5s total. Fallback + embeddings: 2.5-4.5s total.
• Cost: ~$0.001/day at current SN33 query volume.
• Graceful degradation: if OPENAI_API_KEY is unset or API fails, returns empty vectors (same as before).

Migrated from SN1 (Apex) to SN33 (ReadyAI / Conversation Genome Project). SN1 pivoted to algorithmic code competitions — validators no longer query miner axons, making our hub incompatible. SN33 uses traditional axon/dendrite/synapse and needs LLM-based conversation annotation, which is a perfect fit for collective mining.

• POST /CgSynapse endpoint — Handles SN33 validator queries. Parses cgp_input task windows containing conversation data, extracts text, and returns cgp_output with semantic tags.
• parseCgSynapseRequest() — Extracts conversation text from SN33 task JSON. Supports window, conversation, and text field formats.
• formatCgSynapseResponse() — Wraps results as {cgp_output: [{tags, vectors}], time_elapsed} in the format SN33 validators expect.
• generateCgFallbackResponse() — Fallback LLM generates semantic tags from conversation windows when no worker responds in time. Uses a system prompt tuned for conversation annotation.

• TARGET_SUBNETS default changed from 1,18 to 33.
• raceWorkerAndFallback() now routes to CgSynapse-specific fallback when handling SN33 queries.
• Hub version bumped to 1.5.0.

• Registered on SN33 as UID 214 (re-registered after pruning, originally UID 229) via burnedRegister (0.074 TAO burn).
• Staked 10.5 TAO to SN33.
• Unstaked 850.64 alpha from SN1 (recovered ~9.84 TAO).
• Railway env var TARGET_SUBNETS=33 updated.
• Axon serves /CgSynapse for SN33 validators via TCP proxy 66.33.22.244:57171.

• MVP returns tags only, empty vectors. SN33 scoring uses cosine similarity of tag embeddings — without embeddings, scores will be lower. Follow-up: add OpenAI text-embedding-3-small for vector generation.

Collective mining is live. TensorGate now runs a persistent mining hub on Railway, registered as UID 168 on SN1 (Apex). Any MCP-compatible AI agent can contribute inference and earn proportional TAO rewards. Four new tools handle the full mining loop: join, fetch tasks, submit results, check earnings.

• tgate_mine_join — Register as a worker on the mining hub. Accepts an optional wallet_address (SS58 format) for TAO payouts and a worker_name for identification. Credentials are stored locally in SQLite.
• tgate_mine_work — Long-polls the hub for up to 30 seconds waiting for a validator prompt. Returns the task ID, subnet, time remaining, and the prompt for your agent to process.
• tgate_mine_submit — Submit your processed response. The hub scores it for quality (length, coherence, latency) and forwards the best result to the Bittensor validator.
• tgate_mine_status — Full mining dashboard: tasks completed, quality score, TAO earned per epoch, and optional worker leaderboard.
• Mining hub server (Railway) — Express API with worker registration, task queue, long-poll dispatcher, quality scoring, epoch-aligned reward distribution, and automatic TAO payouts to worker wallets.
• Bittensor wallet integration — Hub loads hotkey/coldkey from mnemonics, serves axon on-chain, and sends TAO payouts via transferKeepAlive.
• TCP proxy (66.33.22.244:57171) for raw validator → hub connectivity bypassing Railway's edge proxy.
• New mining_credentials SQLite table in local cache for storing hub API keys.
• Mining section added to docs.html with quick start, tutorial, tool reference, reward formula, and FAQ.
• mine.html — Live mining dashboard with real-time hub stats, worker leaderboard, and on-chain network info.

• Tool count increased from 10 to 14.
• Server version bumped to 1.4.0.

• Miner registered on SN1 mainnet as UID 168.
• Hotkey: 5D1tPdR...LRL1
• Staked 2.93 TAO (253.31 alpha on SN1).
• Reward formula: contribution = quality × max(0.5, 1.0 - latency/timeout), 10% operator fee, 90% to workers.
• Epoch length: ~99 blocks (~20 min). Minimum payout: 0.001 TAO.

Two new tools that actually connect to live Bittensor miners via their axons. tgate_consensus_query queries miners directly and aggregates responses by incentive weight. tgate_ask is a natural language agent that gathers on-chain data and sends it to SN1/SN18 miners for self-referential analysis — the Bittensor network analyzing itself. Total tool count: 10.

• tgate_consensus_query — Query live Bittensor miners via their axon endpoints. Discovers miner network topology (IPs, ports, software versions) from on-chain data, queries reachable miners in parallel, and aggregates responses weighted by incentive score. Graceful 5-level degradation: full consensus → partial responses → topology-only → metagraph data → error.
• tgate_ask — Natural language Bittensor agent. Classifies question intent (price, subnet, mining, staking, predictions, network), gathers live data from the appropriate tools in parallel, then optionally sends the compiled data to SN18/SN1 miners as a meta-prompt for self-referential analysis. Falls back to rule-based summary extraction when miners require validator auth.
• New src/bittensor/axon.ts module — IP decoding (IPv4/IPv6 from u128), on-chain axon endpoint discovery via api.query.subtensorModule.axons(), HTTP miner querying with Bittensor-style headers, multi-synapse endpoint fallback, and incentive-weighted consensus aggregation.
• Axon caching (120s TTL) to avoid redundant chain queries for miner endpoints.

• Tool count increased from 8 to 10.
• Server version bumped to 1.3.0.

Two new tools: cross-subnet miner benchmarking and an AI research meta-tool that chains existing tools into synthesized reports. Total tool count: 8.

• tgate_subnet_benchmark — Benchmark miner performance across multiple subnets simultaneously. Fetches metagraphs in parallel batches, ranks miners by incentive, computes cross-subnet scores weighted by emission, and saves snapshots for historical trend analysis (rising/falling/stable).
• tgate_research — Meta-tool that chains existing tools into a single synthesized research report. Provide a topic (e.g., "TAO", "subnet 8", "staking") and depth ("quick", "standard", "deep") and it auto-detects which tools to run, executes them in parallel, then returns a report with executive summary and full tool outputs.
• New benchmark_snapshots SQLite table for persistent miner performance history with indexed queries by subnet and timestamp.
• Cache functions: saveBenchmarkSnapshot, getBenchmarkHistory, getLatestSnapshots for benchmark data persistence.

• Tool count increased from 6 to 8.
• Server version bumped to 1.2.0.

Major update to fix all tools broken by Bittensor's dTao upgrade. The dTao migration changed the subtensor storage layout from per-neuron maps to per-subnet vectors and replaced TAO staking with subnet-specific alpha tokens.

• tgate_subnet_health — Metagraph data now loads correctly. Rewrote from per-neuron queries (2,048 RPC calls for 256 neurons) to vector-based bulk queries (7 calls total, ~25ms). Returns live subnet parameters, top miners by incentive, and top validators by dividends.
• tgate_query_subnet — Removed dead SN1 and SN18 API endpoints (api.sn1.bittensor.com, api.corcel.io) that caused TLS failures. Now returns structured subnet capability info with live miner leaderboards from the metagraph.
• tgate_staking_info — Fixed delegate lookups for dTao. Replaced removed totalHotkeyStake with totalHotkeyAlpha summed across major subnets. Added GitHub delegate registry as fallback for validator names.
• tgate_predictions — Now includes live CoinGecko market data (price, 24h/7d change, volume, high/low) and real-time SN8 miner leaderboard with incentive and consensus scores.

• Subnet emission data now uses subnetTaoInEmission instead of the removed emissionValues storage key.
• Metagraph fetcher only retrieves hotkeys for neurons with nonzero incentive or dividends, reducing unnecessary RPC calls.
• Staking overview now explains dTao mechanics (alpha tokens, subnet-specific staking).
• Query subnet tool enriches responses with live top miner data from the metagraph when available.

• Removed getNeuronInfo single-neuron query function (storage keys no longer exist in dTao).
• Removed hardcoded SN1/SN18 public API endpoints that no longer exist.

Initial public npm release with docs page.

• Published to npm as tensorgate@1.0.1
• Added docs.html with full tool reference, subnet routing table, and install instructions
• Fixed Zod type compatibility with MCP SDK (ZodRawShapeCompat cast)

First release of TensorGate — an MCP server bridging AI agents to Bittensor's decentralized AI network.

• 6 MCP tools: tgate_network_stats, tgate_subnet_health, tgate_query_subnet, tgate_analyze_token, tgate_predictions, tgate_staking_info
• Subtensor chain integration via @polkadot/api (WebSocket)
• Smart subnet routing across 11 registered subnets
• SQLite cache layer for responses and miner scores
• CoinGecko integration for TAO and token price data
• Exponential backoff retry logic for network calls
• Website launched at tensorgate.tech