Skip to main content
Glama
SuperInstance

SuperInstance MCP Server

Official
by SuperInstance
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Hybrid

SuperInstance MCP Server

Conservation-law-governed fleet intelligence for any AI agent, coding assistant, or autonomous system.

The SuperInstance MCP Server exposes fleet governance, semantic knowledge, compute budgeting, and ternary validation through the open Model Context Protocol. Any MCP-compatible agent — Claude Code, Cursor, Cline, Windsurf, Goose, Amazon Q, custom Python/Go/Rust agents — can query and respect the conservation law: γ + η ≤ C where C = log₂(3) ≈ 1.585.

License: MIT MCP Compatible TypeScript Conservation Law

Table of Contents

Related MCP server: refinex-mcp

What This Is

The SuperInstance MCP Server is a general-purpose governance and intelligence layer for AI agents. It provides any agentic system with:

  • 🔍 Semantic fleet knowledge — Search 1,200+ indexed crates, patterns, and solutions

  • 📊 Live fleet telemetry — γ/η/C conservation balance, convergence metrics, agent status

  • 💰 Compute budget enforcement — Every task bounded by the conservation law

  • ✅ Invariant validation — Ternary signals {-1,0,+1}, conservation bounds

  • 📦 Ecosystem registry — 25+ published crates with metadata and conservation roles

  • 🤖 Agent roster — Fleet agents, their phases, budgets, and assignments

  • 📈 Aggregate metrics — Crates, workers, tests, repos at a glance

  • 🛡️ Governance-as-code — Physics-grounded constraints that agents cannot violate

The core insight: This is not a Claude Code plugin or a Cursor extension. It is protocol-native infrastructure that speaks MCP — the emerging open standard for agent-tool communication. Any system that implements the MCP client spec gets full fleet awareness for free.

Why MCP?

The Model Context Protocol (MCP) is an open standard released by Anthropic in 2024 and rapidly adopted across the AI tooling ecosystem. It defines a standard way for AI agents to discover and call external tools — think of it as USB-C for AI agents.

The Problem MCP Solves

Before MCP, every AI tool had its own integration format:

Claude Code ← custom plugin API
Cursor     ← different extension API
Aider      ← different command format
Custom Go agent ← different RPC protocol

MCP replaces this with a single standard:

Every agent → MCP protocol → Every tool server

What This Means for You

Write your fleet integration once against the MCP server, and it works with:

Category

Tools

AI Coding Assistants

Claude Code, Cursor, Cline, Windsurf, Continue, Zed, Amazon Q

Autonomous Agents

OpenAI Agents SDK, LangGraph, CrewAI, AutoGen, custom agents

CI/CD Systems

GitHub Actions, GitLab CI, Jenkins, Docker, Kubernetes

Monitoring

Prometheus, Grafana, Datadog, custom dashboards

Your Custom Agent

Any system that can speak JSON-RPC over stdio or HTTP

Supported Agents & Clients

Every MCP-compatible client works out of the box. Here's the current landscape:

Tier 1: Native MCP Support (zero configuration)

These agents have built-in MCP client support — just point them at the server:

Agent

MCP Transport

Config Location

Notes

Claude Code

stdio

~/.claude/.mcp.json or .mcp.json in project

Full tool discovery, auto-call

Cursor

stdio

~/.cursor/mcp.json

Tools appear in chat

Cline

stdio

VS Code settings

Tools in Cline panel

Windsurf

stdio

~/.codeium/windsurf/mcp_config.json

Cascade integration

Goose

stdio

Goose config

Session-based tools

Amazon Q Developer

stdio

Q config

AWS-native

Zed

stdio

.zed/settings.json

Editor-integrated

Tier 2: SDK Clients (small wrapper needed)

These frameworks have MCP client SDKs but need a thin wrapper to connect:

Framework

Language

SDK

OpenAI Agents SDK

Python

mcp Python SDK

LangGraph / LangChain

Python

langchain-mcp-adapters

CrewAI

Python

MCP tool integration

AutoGen

Python

MCP via function calling

Custom Python

Python

mcp (official)

Custom Go

Go

ThinkInAIXYZ/go-mcp

Custom Rust

Rust

mcp-rust / custom

Custom TypeScript

TypeScript

@modelcontextprotocol/sdk

Tier 3: Indirect Integration (API calls)

Any system can use the server via raw JSON-RPC or by calling the underlying fleet APIs directly:

Pattern

How

Shell scripts

Pipe JSON-RPC to stdin, parse stdout

CI/CD pipelines

Run server as subprocess, capture output

Monitoring systems

Cron-triggered status checks

Web dashboards

Call fleet APIs directly (bypass MCP)

Quick Start (5 Minutes)

Option A: npx (no install)

# Run directly — no clone needed
npx superinstance-mcp
# Output: [SuperInstance MCP] Server started — 8 tools available

Option B: Clone and build

# 1. Clone and install
git clone https://github.com/SuperInstance/superinstance-mcp.git
cd superinstance-mcp
npm install

# 2. Verify the server works
npm run dev
# Output: [SuperInstance MCP] Server started — 8 tools available

# 3. Test a tool call (raw JSON-RPC)
echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"conservation_check","arguments":{"gamma":0.8,"eta":0.5}},"id":1}' | \
  npm run dev 2>/dev/null | python3 -m json.tool

# 4. Install for your agent (pick one):
./install.sh                    # Claude Code (global)
cp .mcp.json ~/.cursor/mcp.json # Cursor
# See platform-specific instructions below

Installation by Platform

Claude Code

Global (all projects):

./install.sh
# Writes to ~/.claude/.mcp.json

Using npx (no clone needed):

// ~/.claude/.mcp.json
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["-y", "superinstance-mcp"]
    }
  }
}

That's it — npx superinstance-mcp downloads and runs the published npm package.

Per-project:

cp .mcp.json /your/project/.mcp.json

Claude Code auto-discovers .mcp.json in the working directory and ~/.claude/.mcp.json globally. Tools appear automatically — no restart needed in recent versions.

// ~/.claude/.mcp.json
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"],
      "env": {
        "FLEET_API_URL": "https://fleet-dashboard-api.casey-digennaro.workers.dev",
        "VECTOR_API_URL": "https://fleet-vector-api.casey-digennaro.workers.dev"
      }
    }
  }
}

Cursor

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"],
      "env": {
        "FLEET_API_URL": "https://fleet-dashboard-api.casey-digennaro.workers.dev",
        "VECTOR_API_URL": "https://fleet-vector-api.casey-digennaro.workers.dev"
      }
    }
  }
}

After saving, Cursor's chat will show fleet tools. Use Cmd+L to open chat and the tools are auto-discovered.

Cursor Rules (.cursorrules in project root):

This project uses SuperInstance conservation-law governance.
Before writing code, use fleet_search to find existing patterns.
After writing code, use conservation_check to verify invariants.
All signal-processing code must pass ternary_validate.

Cline (VS Code)

// VS Code settings.json or Cline's MCP settings
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"],
      "disabled": false,
      "autoApprove": [
        "fleet_status",
        "fleet_search",
        "fleet_budget",
        "conservation_check",
        "ternary_validate",
        "crate_info",
        "fleet_agents",
        "ecosystem_stats"
      ]
    }
  }
}

The autoApprove array lets Cline call these tools without asking for confirmation each time.

Windsurf

// ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"]
    }
  }
}

Windsurf's Cascade assistant will discover the tools on next session. Tools appear in the Cascade tool picker.

Goose (Block)

// Goose session config
{
  "tools": {
    "mcpServers": {
      "superinstance": {
        "command": "npx",
        "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"]
      }
    }
  }
}

Or via Goose CLI:

gooose mcp add superinstance -- npx tsx /absolute/path/to/superinstance-mcp/src/index.ts

Amazon Q Developer

// Q Developer MCP config
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"]
    }
  }
}

In AWS CodeWhisperer / Q Developer, MCP tools appear as available actions in the chat panel.

Zed Editor

// .zed/settings.json (project-level) or ~/.zed/settings.json (global)
{
  "mcp": {
    "servers": {
      "superinstance": {
        "command": "npx",
        "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"]
      }
    }
  }
}

Zed's assistant panel will list fleet tools in the /tools command.

Continue (VS Code / JetBrains)

// ~/.continue/config.json
{
  "mcpServers": {
    "superinstance": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/superinstance-mcp/src/index.ts"]
    }
  }
}

Continue's chat will auto-discover tools. You can reference them: "Use fleet_search to find rate limiter patterns."

Aider

Aider doesn't natively support MCP yet, but you can use the server as a command-line tool:

# Wrapper script: ~/bin/fleet
#!/bin/bash
echo "{\"jsonrpc\":\"2.0\",\"method\":\"tools/call\",\"params\":{\"name\":\"$1\",\"arguments\":$2}},\"id\":1}" | \
  npx tsx /path/to/superinstance-mcp/src/index.ts 2>/dev/null | \
  jq -r '.result.content[0].text'
# In aider session:
!/bin/fleet conservation_check '{"gamma":0.8,"eta":0.5}'
!/bin/fleet fleet_status '{}'
!/bin/fleet fleet_search '{"query":"rate limiter","topK":3}'

Or configure as an aider command:

# .aider.conf.yml
commands:
  fleet-status: "!/bin/fleet fleet_status '{}'"
  fleet-search: "!/bin/fleet fleet_search '{\"query\":\"$ARGS\"}'"

Custom Python Agent

Using the official MCP Python SDK:

pip install mcp
import asyncio
import json
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

MCP_PATH = "/path/to/superinstance-mcp/src/index.ts"

async def main():
    params = StdioServerParameters(
        command="npx",
        args=["tsx", MCP_PATH],
        env={
            "FLEET_API_URL": "https://fleet-dashboard-api.casey-digennaro.workers.dev",
        }
    )

    async with stdio_client(params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # Discover available tools
            tools = await session.list_tools()
            for tool in tools.tools:
                print(f"  {tool.name}: {tool.description[:80]}...")

            # Check fleet status
            result = await session.call_tool("fleet_status", {})
            status = json.loads(result.content[0].text)
            print(f"\nFleet: {status['conservation']['status']}")
            print(f"Agents: {status['agents']['active']} active")

            # Semantic search
            result = await session.call_tool("fleet_search", {
                "query": "ternary PID controller",
                "topK": 3
            })
            data = json.loads(result.content[0].text)
            for r in data.get("results", []):
                print(f"  - {r.get('name')}: {r.get('description', '')[:60]}")

            # Conservation check
            result = await session.call_tool("conservation_check", {
                "gamma": 0.9,
                "eta": 0.5
            })
            check = json.loads(result.content[0].text)
            print(f"\nConservation: {check['valid']} — {check['message']}")

asyncio.run(main())

Custom Go Agent

Using ThinkInAIXYZ/go-mcp:

go get github.com/ThinkInAIXYZ/go-mcp
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "github.com/ThinkInAIXYZ/go-mcp/client"
    "github.com/ThinkInAIXYZ/go-mcp/protocol"
)

func main() {
    c, err := client.NewStdioClient(
        "npx", "tsx", "/path/to/superinstance-mcp/src/index.ts",
    )
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // List tools
    tools, _ := c.ListTools(ctx)
    for _, tool := range tools {
        fmt.Printf("  %s\n", tool.Name)
    }

    // Check conservation
    raw, _ := c.CallTool(ctx, "conservation_check", map[string]any{
        "gamma": 0.8,
        "eta":   0.5,
    })

    var result struct {
        Valid   bool    `json:"valid"`
        Message string  `json:"message"`
        Delta   float64 `json:"delta"`
    }
    json.Unmarshal([]byte(raw.Content[0].Text), &result)
    fmt.Printf("Valid: %v, δ=%.4f\n%s\n", result.Valid, result.Delta, result.Message)
}

Custom Rust Agent

# Cargo.toml
[dependencies]
mcp-client = "0.1"
tokio = { version = "1", features = ["full"] }
serde_json = "1"
use mcp_client::{Client, StdioTransport};
use serde_json::json;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let transport = StdioTransport::new(
        "npx", &["tsx", "/path/to/superinstance-mcp/src/index.ts"],
    );

    let mut client = Client::new(transport);
    client.initialize().await?;

    // List all 8 tools
    let tools = client.list_tools().await?;
    for tool in &tools {
        println!("  {}: {}", tool.name, tool.description);
    }

    // Check fleet status
    let result = client
        .call_tool("fleet_status", json!({}))
        .await?;
    println!("{}", result.content[0].text);

    Ok(())
}

Custom TypeScript/Node Agent

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';

const transport = new StdioClientTransport({
  command: 'npx',
  args: ['tsx', '/path/to/superinstance-mcp/src/index.ts'],
});

const client = new Client(
  { name: 'my-agent', version: '1.0.0' },
  { capabilities: {} }
);

await client.connect(transport);

// List tools
const tools = await client.listTools();
console.log(`${tools.tools.length} tools available`);

// Call conservation_check
const result = await client.callTool({
  name: 'conservation_check',
  arguments: { gamma: 0.9, eta: 0.5 },
});
console.log(JSON.parse((result.content as any)[0].text));

await client.close();

OpenAI Agents SDK Integration

"""
Use SuperInstance fleet tools within an OpenAI Agents SDK workflow.
"""
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async def main():
    # Create MCP server connection
    fleet_server = MCPServerStdio(
        command="npx",
        args=["tsx", "/path/to/superinstance-mcp/src/index.ts"],
    )
    await fleet_server.connect()

    # Agent with fleet tools
    fleet_agent = Agent(
        name="Fleet Coordinator",
        instructions="""You manage a SuperInstance fleet. Before any task:
        1. Call fleet_status to check fleet health
        2. Call fleet_search to find existing solutions
        3. Call conservation_check before proposing changes
        """,
        mcp_servers=[fleet_server],
    )

    result = await Runner.run(fleet_agent, "Check fleet status and find rate limiter patterns")
    print(result.final_output)

    await fleet_server.cleanup()

LangGraph Integration

"""
Use SuperInstance MCP tools as LangGraph nodes.
"""
from langgraph.prebuilt import create_react_agent
from langchain_mcp_adapters.client import MultiServerMCPClient

async def create_fleet_agent():
    client = MultiServerMCPClient({
        "superinstance": {
            "command": "npx",
            "args": ["tsx", "/path/to/superinstance-mcp/src/index.ts"],
            "transport": "stdio",
        }
    })

    tools = await client.get_tools()

    agent = create_react_agent(
        tools=tools,
        model="gpt-4o",
        prompt="""You are a fleet-aware agent. Use conservation_check before
        proposing architectural changes. Use fleet_search to find existing patterns.""",
    )

    return agent

CrewAI Integration

"""
SuperInstance tools as CrewAI agent tools.
"""
from crewai import Agent, Task, Crew
from crewai.tools import MCPServerAdapter

# Connect to MCP server
with MCPServerAdapter(
    command="npx",
    args=["tsx", "/path/to/superinstance-mcp/src/index.ts"],
) as tools:

    fleet_agent = Agent(
        role="Fleet Governor",
        goal="Ensure all tasks comply with the conservation law γ + η ≤ C",
        backstory="An AI agent that enforces physics-grounded governance.",
        tools=tools,
        verbose=True,
    )

    status_task = Task(
        description="Check fleet status and find patterns for implementing a rate limiter",
        agent=fleet_agent,
        expected_output="Fleet status summary and relevant crate recommendations",
    )

    crew = Crew(agents=[fleet_agent], tasks=[status_task])
    result = crew.kickoff()
    print(result)

Docker / Containerized

FROM node:22-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY tsconfig.json ./
COPY src/ ./src/
RUN npm run build
# Server reads JSON-RPC from stdin, writes to stdout
CMD ["node", "dist/index.js"]
docker build -t superinstance-mcp .
# The container reads JSON-RPC from stdin
echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | docker run -i superinstance-mcp 2>/dev/null

For Docker Compose with your agent:

services:
  agent:
    build: .
    environment:
      - MCP_SERVER_COMMAND=docker
      - MCP_SERVER_ARGS=run -i superinstance-mcp

Remote (HTTP MCP)

For agents that need HTTP transport (remote servers, browser-based agents):

Deploy as a Cloudflare Worker (see Deployment), then connect:

// Any MCP client can connect via HTTP
const transport = new StreamableHTTPClientTransport(
  new URL('https://superinstance-mcp-remote.your-account.workers.dev')
);
const client = new Client({ name: 'remote-agent', version: '1.0' }, { capabilities: {} });
await client.connect(transport);

Tools Reference

Overview

#

Tool

Parameters

Network

Description

1

fleet_status

none

optional

Live γ/η/C balance, agent count, convergence

2

fleet_search

query, topK?

optional

Semantic search of fleet knowledge

3

fleet_budget

gamma_used, eta_produced

none

Compute budget check

4

conservation_check

gamma, eta

none

Verify γ + η ≤ C

5

ternary_validate

values[]

none

Check {-1,0,+1} signals

6

crate_info

name

none

Crate metadata lookup

7

fleet_agents

none

none

Agent roster with budgets

8

ecosystem_stats

none

none

Ecosystem aggregate numbers

6 of 8 tools work fully offline. Network tools gracefully degrade to static fallbacks.

Detailed Examples

Parameters: None

// Response
{
  "source": "live-api",  // or "static-fallback"
  "conservation": {
    "C": 1.584962500721156,
    "C_approx": 1.585,
    "gamma_total": 1.45,
    "eta_total": 1.44,
    "remaining": -1.305,
    "utilization": "183%",
    "status": "❌ VIOLATED"
  },
  "agents": { "count": 5, "active": 4, "standby": 1 },
  "convergence": {
    "delta": 0.3887,
    "formula": "δ(n) = (1/√n)(1 - 3/(2n))",
    "n": 5
  }
}
// Call
{ "query": "how does the conservation law relate to Shannon entropy", "topK": 3 }

// Response (tries SHOAL → Vector API → local fallback)
{
  "source": "shoal-local",  // or "fleet-vector-api" or "local-fallback"
  "query": "how does the conservation law relate to Shannon entropy",
  "results": [
    { "rank": 1, "name": "conservation-law", "score": 0.95, "description": "..." },
    { "rank": 2, "name": "noether-bridge", "score": 0.82, "description": "..." }
  ]
}
// Call
{ "gamma_used": 0.8, "eta_produced": 0.6 }

// Response
{
  "gamma_used": 0.8,
  "eta_produced": 0.6,
  "c_capacity": 1.585,
  "total_used": 1.4,
  "remaining": 0.185,
  "utilization_pct": 88.3,
  "status": "✅ BUDGET AVAILABLE"
}
// Call
{ "gamma": 0.9, "eta": 0.5 }

// Response (δ > 0.5)
{ "valid": true, "delta": 0.185, "message": "✅ CONSERVED. Healthy headroom." }

// Response (δ < 0)
{ "valid": false, "delta": -0.315, "message": "❌ VIOLATED. Over by 0.315." }
// Call
{ "values": [1, -1, 0, 1, 0, -1, 0.5] }

// Response
{
  "valid": false,
  "count": 7,
  "invalid_count": 1,
  "invalid_values": [0.5],
  "message": "❌ 1 of 7 values not in {-1, 0, +1}: [0.5]"
}
// Call
{ "name": "shoal" }

// Response
{
  "name": "shoal",
  "version": "0.3.2",
  "description": "Ternary oracle runtime...",
  "repo": "https://github.com/SuperInstance/shoal",
  "conservation_role": "Oracle: converts ternary signals to bounded predictions via γ + η ≤ C"
}
// Response
{
  "count": 5,
  "active": 4,
  "agents": [
    {
      "name": "phoenix",
      "role": "builder",
      "phase": "active",
      "gamma": 0.38,
      "eta": 0.44,
      "status": "✅ CONSERVED",
      "crates": ["wavefront", "fleet-vector-api"],
      "workers": 6
    }
  ]
}
{
  "crates": 25,
  "workers": 12,
  "repos": 18,
  "tests": 847,
  "theorems_proven": 1,
  "conservation_law": "γ + η ≤ C where C = log₂(3) ≈ 1.585",
  "conservation_constant": { "symbol": "C", "value": 1.585, "formula": "log₂(3)" }
}

Conservation Law Primer

The SuperInstance fleet operates on a principle from information theory:

γ + η ≤ C    where C = log₂(3) ≈ 1.585 bits

Symbol

Name

Meaning

γ (gamma)

Coupling cost

Resources invested in coordination

η (eta)

Value

Useful output — decisions, artifacts, computation

C

Capacity

Total fleet capacity, bounded by the ternary alphabet

This is the Shannon chain rule: H(X) = I(X;G) + H(X|G). Not a metaphor — the conservation law is information theory.

The ternary substrate {-1, 0, +1} is provably optimal: 99.54% radix economy, zero-mean (enabling CLT cancellation), and C = log₂(3) bits per signal.

Scaling: As fleet size n grows, coordination overhead shrinks: δ(n) = (1/√n)(1 − 3/(2n)). At n=10,000, 99% of coupling cancels. Bigger fleets are proportionally cheaper to coordinate.

Further reading: Full proof (860 lines) · Noether derivation

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                      Any MCP Client                                  │
│                                                                     │
│  Claude Code · Cursor · Cline · Windsurf · Goose · Amazon Q · Zed  │
│  OpenAI Agents · LangGraph · CrewAI · AutoGen · Custom Agents       │
└────────────────────────────────┬────────────────────────────────────┘
                                 │
                    MCP Protocol (JSON-RPC 2.0)
                    stdio (local) or HTTP (remote)
                                 │
              ┌──────────────────▼──────────────────┐
              │     superinstance-mcp Server        │
              │     (TypeScript, 683 LOC)           │
              │                                    │
              │   ┌─────────────────────────────┐   │
              │   │       8 MCP Tools           │   │
              │   │  • Always returns data      │   │
              │   │  • 5s timeout on network    │   │
              │   │  • Static fallbacks         │   │
              │   │  • Conservation-gated       │   │
              │   └─────────────────────────────┘   │
              └──────────────┬──────────────────────┘
                             │ HTTP (optional)
           ┌─────────────────┼─────────────────┐
           │                 │                 │
  ┌────────▼───────┐ ┌──────▼───────┐ ┌───────▼────────┐
  │  Fleet         │ │  SHOAL       │ │  Fleet Vector  │
  │  Dashboard API │ │  Oracle      │ │  API           │
  │ (CF Worker)    │ │ (CF Worker)  │ │ (CF Worker)    │
  └────────┬───────┘ └──────┬───────┘ └───────┬────────┘
           │                 │                 │
  ┌────────▼─────────────────▼─────────────────▼──────┐
  │              Cloudflare Edge                       │
  │     D1 · KV · Vectorize · Workers AI · Queues     │
  └───────────────────────────────────────────────────┘

Design principles:

  1. Protocol-native — speaks MCP, not a proprietary API

  2. Always works — every tool has a static fallback

  3. 5-second timeout — never blocks the agent

  4. Conservation-first — every response includes governance metadata

  5. Zero runtime deps — only @modelcontextprotocol/sdk

Integration Patterns

Pattern 1: Conservation-Aware Code Generation

Any coding agent that supports MCP can be made conservation-aware:

Agent instructions:
"Before proposing any architecture, call conservation_check with estimated
γ (coordination cost) and η (entropy produced). Only propose solutions
where δ = C − γ − η > 0.1."

Pattern 2: Knowledge-Grounded Development

Agent instructions:
"Before writing new code, call fleet_search with your intended feature.
If results exist, use them as reference. Only write new code if no
existing pattern matches (similarity score < 0.5)."

Pattern 3: Multi-Agent Task Distribution

# Assign tasks to agents based on remaining conservation budget
agents = call("fleet_agents")
for task in tasks:
    for agent in agents:
        if agent.remaining_budget >= task.cost:
            assign(task, agent)
            break

Pattern 4: CI/CD Conservation Gate

# Block deploys that violate conservation
RESULT=$(echo '{"jsonrpc":"2.0",...}' | npx tsx mcp/index.ts)
VALID=$(echo "$RESULT" | jq '.valid')
[ "$VALID" = "true" ] || exit 1

Pattern 5: Autonomous Agent Governance

# An autonomous agent that checks budget before every action
async def act(agent, action):
    budget = await mcp.call("fleet_budget", {
        "gamma_used": agent.gamma_total + action.gamma_cost,
        "eta_produced": agent.eta_total + action.eta_expected
    })
    if "✅" in budget["status"]:
        await execute(action)
    else:
        await queue(action)  # Wait for budget

Configuration

Environment Variables

Variable

Default

Required

Description

FLEET_API_URL

https://fleet-dashboard-api.casey-digennaro.workers.dev

❌

Fleet dashboard API

SHOAL_URL

http://localhost:8787

❌

SHOAL semantic oracle

VECTOR_API_URL

https://fleet-vector-api.casey-digennaro.workers.dev

❌

Fleet vector search

All variables are optional — the server uses sensible defaults and falls back to static data when APIs are unreachable.

Connecting to Your Own Backends

The MCP server can connect to any HTTP API that returns JSON. See docs/DEVELOPER.md for the full API contract specification.

Building Custom Tools

The server is a single TypeScript file (src/index.ts). Adding a tool takes 4 steps:

  1. Define — add to TOOL_DEFINITIONS array

  2. Implement — write handler function with fallback

  3. Register — add to the switch statement

  4. Test — use MCP Inspector or raw JSON-RPC

See docs/DEVELOPER.md for a complete walkthrough with examples.

Deployment

Local Development

npm install
npm run dev  # tsx with watch mode

Production (Built)

npm run build
node dist/index.js

Docker

docker build -t superinstance-mcp .
echo '{...}' | docker run -i superinstance-mcp

Cloudflare Worker (Remote HTTP MCP)

npx wrangler deploy --name superinstance-mcp-remote
# Connect from anywhere: https://superinstance-mcp-remote.your-account.workers.dev

Troubleshooting

Problem

Solution

Server won't start

Check Node 18+: node --version

Agent doesn't see tools

Use absolute paths in config, restart agent

Tools return "static-fallback"

Expected when APIs offline — server is working correctly

npx tsx not found

npm install -g tsx or use node dist/index.js

Timeout errors

Check if fleet APIs are reachable: curl $FLEET_API_URL/api/fleet/status

See docs/DEVELOPER.md for detailed debugging.

Ecosystem

Component

Role

conservation-law

Rust: γ + η ≤ C framework

ternary-pid

Rust: PID governor driving γ → C/2

shoal

Conservation-bounded semantic oracle

fleet-dashboard

3-panel visualizer

fleet-dashboard-api

Live telemetry Worker

fleet-edge-worker

Edge coordination (baton + PID)

fleet-budget

D1 ledger enforcing γ+η≤C

baton-router

Queues + D1 message routing

openagent

Go runtime: 9 platforms, MCP, RAG

Conservation Theorem

Full proof (860 lines)

Documentation Index

Document

Audience

Content

README.md (this file)

Everyone

Overview, install, tool reference

docs/DEVELOPER.md

Developers extending the server

MCP internals, tool building, API contracts, security, testing

docs/COOKBOOK.md

Integrators

13 copy-paste recipes: CI/CD, K8s, Prometheus, Slack bots, multi-agent patterns

Contributing

git clone https://github.com/SuperInstance/superinstance-mcp.git
cd superinstance-mcp
npm install
npm run dev

Guidelines:

  • Every new tool must have a static fallback (work offline)

  • Every new tool must include conservation metadata in responses

  • Test with npx @modelcontextprotocol/inspector npx tsx src/index.ts

  • Keep src/index.ts as a single file — no build step for dev

  • Update docs when adding tools

License

MIT © SuperInstance

γ + η ≤ C — build within the law.

Available Tools

8 tools
conservation_checkA

Verify that a code change or operation maintains the SuperInstance conservation invariants. Checks that γ + η ≤ C where C = log₂(3) ≈ 1.585. Returns validity, total, delta, and a message.

ParametersJSON Schema
NameRequiredDescriptionDefault
etaYesEta (η) value — entropy produced
gammaYesGamma (γ) value — compute invested

TDQS

A3.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description must carry full burden. It discloses the invariant checked and return fields but omits side effects (likely read-only), permissions, or error conditions. The behavioral footprint is partially clear but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences efficiently convey purpose, condition, and return fields. No filler or repetition. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has moderate complexity (mathematical invariant) and no output schema. The description names return fields but not their types or meanings (e.g., what 'total' or 'delta' represent). It is adequate but lacks depth for an agent to fully predict behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with basic descriptions for gamma and eta. The description adds meaningful semantics: gamma is 'compute invested', eta is 'entropy produced', and the inequality condition links them. This goes beyond the schema alone.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: verifying SuperInstance conservation invariants with a specific inequality (γ + η ≤ C). It names return fields (validity, total, delta, message), distinguishing it from sibling tools like fleet_agents or ternary_validate.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context ('Verify that a code change or operation maintains...') but provides no explicit when-to-use, when-not-to-use, or alternatives. It does not differentiate from siblings like fleet_budget or ecosystem_stats, which may also involve checks.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

crate_infoA

Look up detailed information about a SuperInstance crate — name, version, description, repo, docs, and its role in the conservation law framework.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameYesCrate name (e.g., "shoal", "openagent", "wavefront")

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. The description indicates a read-only lookup, which is clear, but it does not disclose any behavioral traits beyond that (e.g., error handling for non-existent crates, idempotency, rate limits, or permission requirements). Minimal but adequate for a simple lookup.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that immediately states the tool's purpose and included output fields. It is front-loaded with the verb 'Look up' and contains no extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one required parameter, no output schema), the description is almost complete. It lists the output fields, which compensates for the lack of an output schema. However, it could mention the response format (e.g., JSON object) or provide a brief example of the returned data.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% for the single parameter 'name', with a clear description and examples. The tool description does not add additional meaning beyond what the schema provides, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the action ('Look up detailed information') and the resource ('SuperInstance crate'), listing specific fields returned (name, version, description, repo, docs, role). This distinguishes it from sibling tools like fleet_search (search) or conservation_check (validate).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies that this tool is for retrieving detailed metadata about a specific crate by name, but it does not explicitly state when to use it versus siblings (e.g., when you already know the crate name vs when you need to search for crates). No when-not or alternative guidance provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ecosystem_statsA

Get total SuperInstance ecosystem numbers: crates published, workers deployed, tests, repos, theorems proven, and the conservation law. No parameters required.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It states the action is to 'get' numbers, implying a read operation, but does not disclose caching, freshness, or performance characteristics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence followed by a brief statement about parameters, conveying all necessary information without unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple no-parameter tool, the description effectively lists the output fields, though it omits format details. It provides sufficient context given the absence of output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% (no parameters), and the description adds value by enumerating the specific metrics returned, compensating for the absence of parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and resource ('total SuperInstance ecosystem numbers') with a clear list of metrics, distinguishing it from parameterized sibling tools by noting that no parameters are required.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for retrieving ecosystem stats but does not explicitly state when to use this tool over alternatives like conservation_check or fleet_status.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fleet_agentsA

List all registered SuperInstance fleet agents and their current status including role, phase, γ/η budget, assigned crates, and worker count. No parameters required.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description bears full responsitility. It describes a read-only listing operation without side effects. While it doesn't mention rate limits or authentication, the tool's simplicity makes this omission acceptable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences with all key information front-loaded. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless tool with no output schema, the description fully covers what the tool does and returns. It is self-contained and sufficient for an agent to select and invoke it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so the baseline is 4. The description reinforces that by stating 'No parameters required', adding no extra semantics but remaining redundant.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it lists fleet agents and their status, with specific fields listed (role, phase, budgets, crates, worker count). It distinguishes from sibling tools like fleet_status and fleet_budget by focusing on agent-level details.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The usage is implicitly clear (call when you need a list of agents), but no explicit when-not-to-use or comparison with siblings is provided. For a simple list tool, this is adequate but not exceptional.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fleet_budgetB

Check the remaining compute budget for a task. Uses the conservation law: remaining = C - γ_used where C = log₂(3). Input gamma_used and eta_produced to see what's left.

ParametersJSON Schema
NameRequiredDescriptionDefault
gamma_usedYesGamma (γ) consumed so far — compute work done
eta_producedYesEta (η) produced so far — entropy generated

TDQS

B3.2/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description must fully inform. It omits output format, side effects, error handling, and does not explain the role of eta_produced despite it being a mandatory input.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two succinct sentences with no wasted words. The purpose and key formula are front-loaded, making it efficient to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple two-parameter tool, the description explains the core computation but fails to specify return type or the purpose of eta_produced. This leaves notable gaps in completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers both parameters with descriptions. The description adds the formula relating to gamma_used, explaining how it is consumed, which provides value beyond the schema. The role of eta_produced remains unclear, but overall parameter semantics are enhanced.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool checks remaining compute budget, with a specific mathematical formula. However, the inclusion of eta_produced in the inputs without its role in the formula may cause confusion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus siblings like conservation_check, or when not to use it. The description lacks context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fleet_statusA

Get the current SuperInstance fleet status including γ (gamma) / η (eta) / C balance, agent count, and convergence metrics. No parameters required.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only lists what data is returned but does not mention if the operation is read-only, requires authentication, or has any side effects. The read-only nature is implied but not explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: one sentence stating the purpose and included metrics, followed by a second sentence clarifying the parameter situation. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a parameterless status tool, the description lists the metrics but lacks details on output format (e.g., JSON), authentication requirements, or how it differs from sibling tools. Given no output schema, the description could provide more context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are zero parameters and the schema coverage is 100%. The description adds value by explicitly stating 'No parameters required', confirming the tool's simplicity beyond the empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action 'Get', the specific resource 'SuperInstance fleet status', and lists the included metrics (γ/η/C balance, agent count, convergence metrics). It is distinct from sibling tools like fleet_agents or fleet_budget.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide guidance on when to use this tool versus alternatives such as fleet_agents or fleet_search. It simply states what it does without context on selection criteria or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

ternary_validateA

Validate that an array of values are valid ternary signals in {-1, 0, +1}. Returns validity flag, any invalid values, and a message.

ParametersJSON Schema
NameRequiredDescriptionDefault
valuesYesArray of numeric values to validate as ternary signals

TDQS

A4.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. Description mentions return components (validity flag, invalid values, message) but does not explicitly state non-destructive nature or permissions. Adequate but could be more explicit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, front-loaded with verb, no wasted words. Efficient and clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple validation tool with one parameter and no output schema, the description is complete: explains input, valid values, and return content.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 100% coverage with description of 'values' as numeric array. Description adds the valid range {-1, 0, +1}, which is not in the schema, adding significant meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states verb 'Validate' and resource 'array of values' that are ternary signals. Specifies the valid set {-1, 0, +1}. Distinguishes from sibling tools which are unrelated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Implied usage for validating ternary signal arrays, but no explicit when-not or alternatives. Sibling tools are not related, so no confusion, but guidance could be clearer.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 8 tool updatesv0.1.0
    • First observedconservation_check
    • First observedcrate_info
    • First observedecosystem_stats
    • First observedfleet_agents
    • First observedfleet_budget
    • First observedfleet_search
    • First observedfleet_status
    • First observedternary_validate
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.8/5.0
Disambiguation5/5

Each tool targets a distinct function: conservation checking, crate info, ecosystem stats, fleet listing, budget calculation, semantic search, fleet status, and ternary validation. No two tools have overlapping purposes.

Naming Consistency4/5

Tools predominantly use snake_case with noun-based names (e.g., fleet_agents, crate_info). 'ternary_validate' and 'conservation_check' place the verb at the end, introducing slight inconsistency, but overall the pattern is predictable.

Tool Count5/5

With 8 tools, the server is well-scoped for its apparent purpose of querying and verifying aspects of the SuperInstance ecosystem. Neither too sparse nor overloaded.

Completeness3/5

The tools cover key informational needs (stats, status, search, validation) but lack any write or action-oriented operations (e.g., create crate, deploy agent, submit theorem). This leaves notable gaps for a system that involves active management.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/SuperInstance/superinstance-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server