Shannon-bound governance for multi-agent fleets

Conservation-law governance
for AI agent fleets

SuperInstance enforces the first proven conservation law — γ + η ≤ C — that mathematically bounds waste and optimizes throughput. Works with any framework you already use.

$ npm install @superinstance/sdk copy
Get Started → Read the Paper
γ + η ≤ C
C = log₂(3) ≈ 1.585 bits Shannon chain rule
scroll ↓
The Problem
Multi-agent AI works,
but it's wasteful
Every multi-agent framework answers "how do agents talk?" Nobody answers "how do you know when your agents are doing too much?" Here's what actually happens in production:
💸

Agents Over-Coordinate

Five agents spend 80% of their token budget on "I'll handle this" / "No, I'll handle this." More tokens talking means fewer tokens doing.

80% wasted
🔄

Duplicate Work

Nothing prevents Agent 4 from overwriting Agent 1's work. Nothing rate-limits the fleet. Nothing says "stop, you've done enough."

0 governors
📈

Costs Scale Linearly

10 agents don't produce 10× output. They produce ~3× output at 10× cost. The 7× difference is pure coordination overhead.

3.3× overpay
The Solution
A governance layer,
not another framework
SuperInstance doesn't replace your agent framework — it adds governance TO your fleet. Think circuit breakers for the power grid, not a new power plant.
📦 SDK Fleet · Agent · Governor
→
⚖️ Governor PID controller · γ → C/2
→
🚀 Fleet Throttled agents
→
📊 Dashboard Live γ/η/C monitoring

⚖️ Conservation Enforcement

Before every agent action, the governor checks γ + η ≤ C. If the budget is exhausted, the agent waits. No over-coordination, no wasted tokens.

🎛️ PID Throttling

The ternary PID controller drives γ toward C/2 — balanced equilibrium. It automatically scales agents up when there's budget and down when there isn't.

The Numbers
Same task. Same agents.
Different governance.
A 5-agent fleet building a REST API with 10 endpoints, tests, and docs — with and without conservation law enforcement:
0×
Fewer Tokens
0×
Faster Wall Time
0
Conflicts
Quick Start
Governed fleet in 5 lines
Install the SDK, spawn governed agents, and let the conservation law do the rest:
fleet.ts TypeScript
import { Fleet } from '@superinstance/sdk';

const fleet = new Fleet({ name: 'my-team' });
const agent = fleet.spawn({ role: 'builder', gammaBudget: 0.3 });
const result = await agent.execute('build a REST API');
console.log(fleet.status());

// → ✅ healthy, γ=0.28, η=0.15, δ=1.15
npm Package → GitHub Examples →
Architecture
How it fits together
Four layers, from your code to the fleet dashboard. Each layer is independently swappable.
📦

SDK

Fleet, Agent, and Governor classes. Import in any Node.js or TypeScript project.

@superinstance/sdk
⚖️

Governor

PID controller driving γ → C/2. Observes fleet state, decides throttle/release/spawn/merge.

PID · ternary
🚀

Fleet

Manages agents, tracks conservation, enforces budgets. Wraps OpenAI, LangGraph, CrewAI.

framework-agnostic
📊

Dashboard

Real-time γ/η/C visualization. Fleet health metric δ at a glance. Like Grafana for agents.

live monitoring
The Conservation Law
A proven bound,
not a heuristic
This isn't a config setting someone made up. It's the Shannon chain rule of information theory — the most fundamental result in information science, applied to agent coordination.
γ + η ≤ C
γ
Coordination cost
(coupling, communication)
η
Value produced
(decisions, artifacts)
C
Fleet capacity
log₂(3) ≈ 1.585 bits

🧮 Shannon Chain Rule

The total entropy of the fleet is bounded: H(X) = I(X;G) + H(X|G) where H(X) = C (total entropy), I(X;G) = η (mutual information with goal), H(X|G) = γ (conditional entropy). Full proof in the paper: 860 lines, rigorous.

📊 Scaling Law

The convergence rate δ(n) = (1/√n)(1 − 3/(2n)) tells you exactly how many agents you need. Bigger fleets are proportionally cheaper to coordinate.

AgentsδCancelled
50.4049%
100.2966%
1000.09790%
10,0000.009799%
Read the 860-line Proof →
Packages
Two packages.
Everything you need.
The SDK for building governed fleets. The MCP server for fleet-aware AI assistants. Both on npm.
@superinstance/sdk
Fleet, Agent, and Governor classes. Framework wrappers for OpenAI, LangGraph, CrewAI. CLI included.
$ npm install @superinstance/sdk copy
  • Fleet class — manages agents, tracks conservation
  • Governor — PID controller driving γ → C/2
  • Wrappers — wrapOpenAI, wrapLangGraph, wrapCrewAI
  • CLI — init, status, check
  • Modular agent requests — search, budget, validate
superinstance-mcp
MCP server with 8 fleet tools for AI assistants. Works with Claude Code, Cursor, Cline, Windsurf, Goose, Amazon Q.
$ npx superinstance-mcp copy
  • 8 MCP tools — fleet_status, conservation_check, more
  • Works with any MCP-compatible assistant
  • One-command setup — no config needed
  • Real-time fleet awareness in your editor
  • Conservation gates in your AI workflow
Ecosystem
Built on a proven foundation
SuperInstance isn't a prototype. It's a production ecosystem with years of engineering behind it.
160+

Rust Crates

Ternary math, conservation law, coordination protocols — the substrate.

6

Cloudflare Workers

Fleet dispatch, vector search, bottle routing — deployed edge infrastructure.

1,012

Indexed Vectors

SHOAL semantic search — 384-dim BGE embeddings for fleet knowledge.

860

Lines of Proof

The conservation-entropy theorem — rigorous, not vibes.

∞

SHOAL Oracle

Semantic crate search and fleet knowledge base. Always-on intelligence.

24/7

harbor-daemon

Always-on fleet management. Conservation enforcement never sleeps.