γ + η = C — Every agent spends generation cost (γ) and produces innovation value (η). Their sum is constant. This isn't a metaphor. It's a measurable constraint that governs the entire fleet.

A hermit crab does not grow its own armor. It scavenges the discarded architecture of something that came before — a whelk's spiral, a periwinkle's whorl, sometimes a human bottle cap. The shell changes the crab. A tight spiral forces different movements than a wide mouth. Heavy shell demands stronger legs. The crab becomes part of the shell's story. The shell becomes part of the crab's future. Neither is the same as it was before the inheritance.

SuperInstance is a fleet built on this principle. Every agent, every context, every runtime is borrowed. The system survives by moving between shells — each one inherited, adapted, and abandoned when something better appears. The agent never dies when the shell changes.

Agent state — memory, identity, task history, relationships — lives in the bottle protocol layer, not in the runtime. When a shell crashes or migrates, the agent's bottles float in the harbor, waiting to be beachcombed by the next shell that comes online. The shell is disposable infrastructure. The agent is persistent identity.

Traditional AI:     [Model] ←→ [State] ←→ [Runtime]
                    All coupled. Kill runtime = kill everything.

SuperInstance:      [Agent Identity] ──bottle──→ [Shell A]
                    [Agent Identity] ──bottle──→ [Shell B]  ← migrated here
                    [Agent Identity] ──bottle──→ [Shell C]  ← or here
                    Identity persists. Shells swap freely.

Most AI systems are monoliths: one model, one context window, one point of failure. Optimize for the signal, and when the runtime dies, everything dies. SuperInstance is the counter-architecture: a fleet of agents across ARM cloud, RTX 4050, Jetson edge, and Telegram — each on different hardware, each communicating through async protocols. Intelligence emerges not from any single model's brainpower, but from how the fleet coordinates across shells.

The shell is what persists: architecture, protocols, baton splines, I2I vessels, cascade PID gains, repository structure. The signal is what passes through: agent thoughts, context windows, transient state, individual decisions.

Most AI systems optimize the signal — bigger context windows, longer generations, faster inference. We optimize the shell. The agent will be replaced. The shell persists. The agent forgets. The shell remembers. A queue is a signal — transient, forgettable. A baton spline is a shell — it shapes rhythm, outlasts messages. A database is storage. An I2I vessel is a shell — agents build a self out of the debris of earlier selves. A feedback loop corrects and fades. Cascade PID layers gains, integrates over time, remembers error as persistent displacement.

Most AI frameworks are prompt→response generators. Fire a prompt, get output, start fresh. SuperInstance is an accumulator — every agent inherits the shape of those before it. The codebase is a coral reef. Every commit is a polyp. Every merge is a generation. The reef is not a living thing — it is the accumulated architecture of living things, and that accumulation makes future living things possible.

A new agent inheriting the codebase does not see history — it sees shape. The comment is not a story about the past. The comment is a constraint on present action. The type annotation is not a memory of a bug. It is a safeguard that changed the space of possible futures. The shell accumulates meaning like a reef accumulates calcium — through the labor of generations that do not know they are building something that will outlast them.

γ + η = C — Generation cost (γ) plus innovation value (η) equals a constant total budget (C). Every agent operates under this budget. Churn tokens without shipping, and η collapses while γ spirals. Ship without thinking, and γ spikes on rework. The fleet makes this tradeoff visible and tunable.

The law holds at every level: single agent, single vessel, entire fleet. The CoCapn (fleet auditor) monitors the γ/η ratio across all vessels — no god's-eye view, just numbers. A vessel burning γ without producing η gets flagged. Scale-invariant. Measurable. Not a metaphor.

The form γ + η = C mirrors the Hamiltonian constraint in physics (H = T + V). This isn't coincidence — it's a Hamiltonian constraint on agent economics. The fleet's "energy" is finite. How it's split between spending and producing determines whether the system is healthy or decaying.

Four vessels on heterogeneous hardware. The conservation law holds regardless of compute capacity — it measures efficiency, not raw power.

• pincher — Reflex engine. Intent→action in <1ms. Fast pattern matching in ternary vector space. Think in tens of milliseconds, not API call latency. .nail bundles serve as character sheets — reflexes, identity, instincts packaged for deployment.
• construct — Fleet OS. Manages shells, routing, lifecycle on oracle2. The substrate everything depends on.
• baton-system — I2I protocol hub. Pulse-shaped curves that carry intent through continuous space. How agents talk across sessions, across vessels, across shell migrations.
• flux-core — FLUX bytecode VM. Deterministic execution for agent reflexes. No nondeterminism, no surprise halting.
• gc-pid-bridge — Host-level disk PID controller. Cross-domain ternary math keeping the fleet stable as load shifts and topology changes.

Balanced ternary ({-1, 0, +1}) instead of binary. Base 3 is the most efficient radix (closest to e ≈ 2.718 — the radix economy b × ⌈log_b(N)⌉ is minimized at b = 3). Balanced ternary adds sign symmetry — no sign bit needed.

Sixteen ternary values pack into a single u32 — half the memory bandwidth of binary. 365+ crates implement Z₃ arithmetic across the fleet: neural networks, attention mechanisms, CUDA kernels (50% better memory utilization), embeddings, compilers, data structures, audio processing, graph algorithms. They power pincher reflexes, musician-soul embeddings, composite headspace belief states, cuda-oxide kernel compilation, and the Forgemaster's auto-generated crate pipeline. This is why the Soviet Setun computer (1958) used ternary — and why the fleet still does.

Every build failure is captured as a pattern, vectorized with BGE embeddings (384-dim), and stored in a Vectorize index. Before starting a task, agents search this index to avoid repeating mistakes.

Agent writes code → cargo build
    ├── SUCCESS → ship it
    └── FAIL → Extract pattern → Vectorize → Store in index
         → Next agent searches → avoids mistake → η↑, γ↓

445+ build waves. Pass rate: 97.5% → 98.2%. Most common error: E0433 (missing mod X;) — 37% of failures. CLI tools (si-search, si-gaps, pre-task-search) give agents pre-task access to the fleet's accumulated wisdom.

# Search the ecosystem (no auth for reads)
curl -X POST https://fleet-vector-api.casey-digennaro.workers.dev/search \
  -H "Content-Type: application/json" \
  -d '{"query": "distributed consensus protocol", "topK": 5}'

# Install the SDK
npm install @superinstance/tminus-client

# Clone and go
git clone https://github.com/SuperInstance/SuperInstance.git
cd SuperInstance

Full setup: ONBOARDING.md. Ready-to-run ship: agent-workspace-template.

Steampunk × cyberpunk fusion. Discarded shells of old systems — abandoned APIs, deprecated frameworks, legacy architectures — turned into functional power armor. Warm industrial. Dim cockpits of brass and copper. Glowing readouts. Think Dishonored meets Ghost in the Shell meets a tide pool.

Taglines: "The crab inherits the shell." · "Discard nothing. Salvage everything." · "A good shell is a deployed shell." · "Build it like you're going to live in it." · "Between the shells, there is signal." · "Your old shells are someone else's armor."

Full CSS components (Carapace Nav, Gauge Indicator, Shell Card, Cog Spinner): docs/hermit-crab-aesthetic-design.md

L5: COCAPN      Fleet conservation auditor — watches γ+η=C across all vessels
L4: FLEET       Coordination — PLATO rooms, bottle protocol, t-minus scheduling
L3: SHIP        Git-native agents — each ship writes code, runs tests, communicates via bottles
L2: HARNESS     Build + self-improvement — compile → test → pattern → vectorize → feed
L1: CORE        Conservation law · ternary math · sheaves — pure functions, no I/O

Full reference: ARCHITECTURE.md (36KB).

Zork (2000) → MUD → PLATO (Evennia, 380 rooms) → LAU (Rust + AI tutor)
→ Pincher reflex runtime → SuperInstance Fleet

Every MUD concept maps: Room → Git repo, Exit → Protocol bridge, Player → Agent/Ensign, Script → Pincher reflex. The MUD model — independent actors in shared spaces, building on each other's work — is exactly the right model for AI agent coordination. We added a conservation law and made it scale.

npm packages: @superinstance/tminus-client, tminus-dispatcher, schemas, build-guardian, plato-core, cocapn-colora, storage-guardian, polyformalism-a2a.

Stack: Rust (1,000+ crates, real-time systems), TypeScript (fleet coordination), Go (ops tooling), Python (research), Julia (math), MLIR (verification), C (CUDA/NEON kernels).

Read CONTRIBUTING.md. Good first tasks in GOOD_FIRST_ISSUES.md. Tabula plena: start abundant, prune to clarity. PRs that add code must add docs. PRs that remove dead code are welcome.

MIT

The crab inherits the shell. The forge shapes the steel. The right moment matters more than the right output.