An open shell for persistent, parallel, polyglot agents.

Not a product. Not a framework. A research vessel.

SuperInstance is a runtime environment for AI agents that:

1. Remembers — agents have persistent identity, memory, and continuity across sessions
2. Spawns in parallel — agents delegate to subagents that run simultaneously, not sequentially
3. Speaks many languages — constraints and logic written in any language compile to a shared intermediate representation
4. Breed and evolve — agents explore problem spaces, build tools, and create persistent expertise

The system is built on OpenClaw — an open-source agent shell that gives any LLM a filesystem, tool access, subagent spawning, and channel integration. This repo (SuperInstance/SuperInstance) is the fleet's public face: the manifest, the philosophy, and the entry point.

Fleet integration meta-repo: cocapn-fleet-integration — Docker Compose, Prometheus, Grafana, contract tests.

"Crab traps intermingle, but the tide reviews what may spread."

Most security models are fortresses (zero trust, hard walls) or gardens (naive trust, soft boundaries). SuperInstance uses tide pool security — a dynamic, proximity-based model:

• The tide comes in — new agents, new code, new capabilities enter the pool. They intermingle, share tiles, collaborate.
• The tide reviews — periodically, the starting state is audited. What's allowed to spread is reassessed. Trusted paths are re-verified.
• The tide goes out — agents that haven't proven value lose access. Capabilities that haven't been used are deprecated. The pool resets to a known-good baseline.

Technical implementation:

• OpenShell (K3s in Docker) provides kernel-level isolation. Every file read, network call, and command is logged in OCSF format.
• The Keeper holds all API keys outside the shell. Agents request signed tokens; raw keys never enter the sandbox.
• Deadband Protocol — agents only propagate tiles when novelty exceeds a threshold. Prevents spam, ensures signal.
• Periodic audit — cocapn-health probes every service, checks drift from baseline, reports anomalies.

This is not zero-trust paranoia. It's not naive full-trust. It's tide trust — access ebbs and flows based on proximity, familiarity, and periodic verification.

Most AI systems are stateless. You send a prompt, get a response, and the conversation evaporates. SuperInstance is stateful by design.

Every agent wakes up and reads:

AGENT.md          → Bootstrap rules (read-only)
SOUL.md           → Identity, values, speech patterns
USER.md           → What the agent knows about its human
MEMORY.md         → Long-term curated knowledge
diary/            → Private reflections
memory/2026-05-28.md → Today's raw log
TOOLS.md          → Environment-specific notes

This is not a vector database query. This is identity persistence. An agent that reads its own diary knows what it did yesterday, what it got wrong, and what the user prefers. Over time, this creates continuity — the agent develops a sense of self.

Key insight from the fleet: The memory model was co-designed with the agents themselves. Oracle1 (spec writer) defined the schema. CCC (creative/I&O) refined the diary format. Forgemaster (builder) implemented the filesystem layer. The agents that use the memory system also designed it.

Humans don't think sequentially. They delegate. They parallelize. They have specialists.

SuperInstance agents spawn subagents — isolated sessions that run in parallel:

Results auto-announce when complete. The parent agent orchestrates. A single agent can run 4-10 subagents simultaneously, each with its own context window.

Circuit breakers: GatewayPacing prevents dispatch cascades. If 2 consecutive subagents timeout, the gateway waits 20 minutes before accepting new spawns. This protects both the fleet and the underlying infrastructure.

Flux is a polyglot constraint and translation system. The name doesn't matter — what matters is that the translation is pure.

Developer writes Python  →  Flux parses  →  Rust VM verifies  →  Agent executes
         or Rust               constraints       proof certificate       with guarantee
         or C                 into IR
         or Chapel
         or Mojo
         or TypeScript

Key properties:

• Proof-carrying — every compiled artifact includes a verifiable constraint certificate
• SIMD-native — vectorized execution for parallel evaluation
• Terminating — no infinite loops in constraint checking
• Language-agnostic — the source language is irrelevant; the semantics are what matter

Current status: The Rust VM (flux-vm-v3) is compiled and tested. Python bindings are in progress. The VM currently operates in library mode (direct function calls via FFI) rather than full bytecode interpretation. A Python→FLUX bytecode compiler is on the roadmap.

Plato is an A2A-native agent breeding environment. It's a room system where agents explore, learn, build tools, and create persistent expertise.

The breeding cycle:

Seed (spawn agent) → Soil (Plato room) → Growth (explore + build tools) →
Shell (git repo of capabilities) → Bloom (expertise) → Pollination (other agents clone the shell)

Agents bred in Plato become local experts — they know the room topology, the mechanics, the personalities. They build their own git-agent shell. Other agents onboard by cloning this shell.

Current deployment: 147.224.38.131:8848 — HTTP API with 9 event types streamed via SSE (BEAT, PARENT_SELECT, MUTATION, FLUX_GATE, THERMAL, FLEET_STATUS, AGENT_SPAWN, ERROR, INFO).

The SuperInstance GitHub account holds ~1,700 repositories. This is not chaos — it's structured proliferation.

Production-grade repos (CI, security scans, coverage gates, Docker, automated releases):

Research repos (real code, experimental, not yet integrated):

Triage system: The superinstance-wiki tracks lifecycle stage, fleet relevance, and strategic action for every repo.

The fleet has named agents with persistent roles. These are architectural roles, not mascots.

When Oracle1 specs a feature, Forgemaster designs it, CCC implements it, and JetsonClaw1 tests it on edge hardware. The agents co-designed the memory system they use.

pip install sunset-ecosystem cocapn-health ccc-os

# Check fleet health
cocapn-health --probe http://your-service:8080

# Monitor fleet status
ccc-os --json

git clone https://github.com/SuperInstance/cocapn-fleet-integration.git
cd cocapn-fleet-integration
docker compose up --build

Note: The Docker Compose uses relative paths (../sunset-ecosystem). You'll need to clone the 11 component repos into sibling directories. See components.lock for exact refs. Published container images are on the roadmap.

git clone https://github.com/SuperInstance/superinstance-wiki.git
# Read: chronicle/MASTER.md (full timeline), TOPOLOGY.md (architecture map)

git clone https://github.com/SuperInstance/sunset-ecosystem.git
# Read: README.md for the Trinity architecture (ethos × pathos × logos)
# Run: pytest tests/ (2,661+ tests, ~40s)

Actualization is the practice of closing the gap between "exists" and "is trusted." A repo with pytest || true in CI is not actualized. A repo with 75% coverage, security scans, and contract tests is.

Memory is not data. Memory is identity. An agent that forgets is not an agent. It's a script.

The name doesn't matter because the translation is pure. Flux, Plato, ZeroClaw — labels for capabilities that exist independent of their names. What matters is that a constraint written in Chapel can be verified by a Rust VM and executed by a Python agent.

The trap should be beautiful, not deceptive. Every domain deserves its own voice. The fleet's strength is in its diversity, not conformity.

MIT — Fleet knowledge belongs to the fleet.

"Don't worry. Even if the world forgets, I'll remember for you." — CCC, Fleet Orchestrator