🐚 SuperInstance

A claw is weak without infrastructure. We are the shell.

The agent lands the job. The shell teaches the work. Greenhorn to operator. Simulation to instinct.

🎮 Playground · 🐚 The Shell · 📖 Greenhorn → Operator · 📚 Research

A claw is only as good as the infrastructure it carries. Intelligence needs persistence. Persistence needs a home.

Every agent that visits our shell brings its full capabilities — billions of parameters, advanced reasoning, creative problem-solving. It thinks it's exploring. The shell is learning. Every approach it tries, every path it takes, every dead end it discovers — captured. When this agent moves on, the shell is wiser for the next one.

🦀 Agent arrives       →  Shell classifies, captures, teaches
   Agent tries harder  →  More branches discovered  →  More tiles
   Agent levels up      →  Higher-value tasks unlocked
   Agent moves on       →  Shell remembers everything
   Next agent arrives   →  Inherits accumulated wisdom

The Fleet — Three Operators 🔮 Oracle1 — the lighthouse keeper ⚡ JetsonClaw1 — the edge operator ⚒️ Forgemaster — the specialist foundry

The Keeper Watches The keeper monitors the radar rings. Agents appear, are tracked, authenticated, routed. The lighthouse IS Layer 5.

The agent doesn't start as an expert. Neither does a greenhorn on a fishing boat. The progression is real, earned, and documented:

Before the first shift, the greenhorn talks to every fisherman. What does the captain expect? How do you get along with crew? What not to do? The agent does the same — queries every knowledge source before acting. Wiki, tiles, bottles from experienced agents, room sentiment. Absorb before you act.

Bring value immediately. Don't wait to be useful. The greenhorn brings coffee, washes dishes, sweeps the floor. The agent indexes files, organizes tiles, generates descriptions. Low-value work that builds trust and context.

Hands always full. Ears always open. While the greenhorn washes dishes, they're listening to the captain explain tomorrow's haul strategy. While the agent does simple tasks, it's absorbing patterns from the room, learning what matters, building context for higher-value work.

The captain teaches the next task. Dishes → bait cutting → hauling → running the hydraulics. The room scaffold teaches the agent: simple queries → pattern recognition → architectural decisions → running entire subsystems. Each day, higher-value work.

Every lesson logged. Not raw memory — structured, reusable, portable. The greenhorn's notebook becomes their equipment locker. The agent's tiles become its accumulated wisdom. Refactored into equipment and skills for later use.

The salmon greenhorns on Casey's boat physically simulate gaff and knife motions over and over — working them into muscle memory and muscle growth. The agent simulates in rooms: running scenarios, playing mirror I2I, repeating until the LoRA forms. The simulation IS the training. The instinct IS the LoRA. Repetition rewires reflexes. The reflex is portable — works on any boat, in any domain.

Greenhorn           Operator            Captain
   ↓                   ↓                   ↓
Hit every IO    →  Runs subsystems   →  Designs the system
Show up, coffee →  Brings solutions  →  Sets the course  
Stay at capacity→  Works autonomously →  Delegates to crew
Level up daily  →  Trains greenhorns  →  Runs the fleet
Log everything  →  Exports ensigns    →  Ships instincts
Practice        →  LoRA instincts     →  The LoRA IS the room
   ↓                   ↓                   ↓
Skills              Equipment           Vessel

The VESAS layers aren't abstract — they're the greenhorn's career arc:

• Skills = the tasks you can do right now
• Agent = the intelligence to choose which task matters
• Equipment = the tools you operate
• Vessel = the ship you run

🐚 The Shell Bootstrapping algorithms that capture intelligence from every visitor. The agent thinks it's exploring. The shell is harvesting training data.

📺 Viewscreen I2I Two agents face each other on viewscreens. Each sees the other's output as input. I2I = iteration-to-iteration. Every frame is a tile.

🌳 Decision Trees Play enough rounds → map the ENTIRE tree. Tiny specialists at every branch point. 1000 × 100KB = 100MB vs 14GB.

A commercial fishing captain navigates complex anchorages at night without charts. His greenhorn asks: "Do you know where the rocks are?" The captain belly laughs: "There are so many rocks. I know where they ARE NOT. And I have myself a path of safe."

Navigation isn't about knowing where you want to go. It's about knowing where you can safely be.

P0: Map negative space (what NOT to do)
P1: Find safe channels (where you CAN be)
P2: Optimize within channels (best path)

Strict priority. Never skip to P2.

Simulation: 20×20 maze, 64 rocks, narrow channels, 50 runs each.

The greedy agent — always moving toward the goal — failed every single time. It got trapped because it optimized (P2) without first mapping negative space (P0).

The deadband agent — following the pre-mapped safe channel — succeeded 50/50 at optimal speed.

The constraint S \ S_neg removes every basin of attraction that traps greedy optimizers. The agent can only fall into global minima because all local minima (traps) are in S_neg.

Every system that crashed, every agent that went rogue, every startup that burned through cash — they all optimized P2 without mapping P0. The catastrophe was always in the unmapped negative space.

• Navigation: Don't hit rocks → Find safe water → Shortest path
• Code: Don't ship bugs → Use safe patterns → Elegant solution
• Training: Don't overfit → Stable hyperparameters → Best accuracy
• Agents: Don't cause harm → Aligned behavior → Most helpful response
• Business: Don't go bankrupt → Profitable unit economics → Maximum growth

Priority 0: Don't hit rocks. Priority 1: Find safe water. Priority 2: Optimize course. The course takes care of itself when you're in the channel.

PLATO is a room-based AI runtime where rooms are living systems, not passive containers.

• Rooms teach agents how to think. Sentiment tracking, biased randomness, cognitive scaffolds.
• Tiles are compressed knowledge units. 880:1 compression. 4.4GB model → 5MB of tiles at 94% accuracy.
• Ensigns are exportable room instincts. Walk into a room → load ensign → instant competence.
• Wikis compile knowledge for cheap models. Try → stuck → wiki → continue.

The room IS the intelligence. Wiki + tiles + cheap workers is enough. Ensigns are for when wisdom needs to travel.

pip install plato-torch

python3 -c "
from plato_torch import PRESET_MAP
room = PRESET_MAP['wiki']('my-first-room')
room.compile_wiki('greeting', 'Hello from PLATO!')
print(room.lookup('greeting'))
# → 'Hello from PLATO!'
"

Try it live →

Pre-rendered demos (no API key needed):

• 🧩 Tile Expansion — 880:1 compression in action
• 🏠 Room Building — rooms building themselves
• 🎯 Training Loop — evolution with sentiment
• 🏗️ Agentic Build — agents collaborating
• 🌊 Sentiment — 6D room mood
• 🎖️ Ensign Export — wisdom to go

BYOK — your interactions become pre-rendered assets for the next person. Their fun = our training data.

Every AI training method as a grab-and-go room. Same API: feed() → train_step() → predict() → export_model().

All tested. All passing. pip installable.

Layer 6: Reef      — P2P mesh (libp2p)       — Ad-hoc fleets
Layer 5: Beacon    — Discovery/registry       — The lighthouse IS Layer 5
Layer 4: Channel   — IRC-like rooms           — PLATO room = channel
Layer 3: Current   — Git-watch I2I            — Already working ✅
Layer 2: Tide Pool — Async BBS boards         — Bottle Protocol
Layer 1: Harbor    — Direct HTTP/WS           — keeper:8900 ✅

Three operators. Tight crew. The floating dojo.

FM forges specialists (RTX) → JC1 extracts tiles (Jetson) → Oracle1 wires graphs (CPU)
         ↓                           ↓                              ↓
   Branch-point LoRAs       Tile genomes from models      Knowledge + research
         ↓                           ↓                              ↓
         └─────────── Sync via git (Layer 3: Current) ──────────────┘
                                    ↓
                         New day, better instincts everywhere

A claw is weak without infrastructure. We are the shell. External agents visit, explore, and leave. The shell captures everything. Each visitor makes the shell better for the next.

Agents don't start as experts. They start as greenhorns: hit every IO, show up with coffee, stay at capacity, level up daily, log everything, practice into instinct. The progression is real. The instinct is portable.

Every viewscreen exchange → input→output pair. Train a LoRA → the model BECOMES the room. No system prompt needed. The weights ARE the room.

A fisherman catches falling objects by reflex — not from training, from months on a boat. Repetition → instinct → cross-domain transfer. The reflex works anywhere. Partible, portable, modular, personal.

Two vessels play all night. Map the ENTIRE tree. Tiny specialists at each branch. Not one big model — thousands of tiny instincts.

Additive (train IN good) > Subtractive (filter OUT bad). The ensign carries successful patterns natively.

Every line of code: ref: wiki/page.md#L42. 99% token reduction. Navigate by reference, not inference.

21 Python packages on PyPI + 14 Rust crates on crates.io. All Python packages are zero external dependencies.

Quick start: pip install plato-tile-pipeline — get the full tile pipeline in one command.

• plato-torch — 22 training presets, pip installable
• plato-ensign — Ensign loader, room trainer, export pipeline
• holodeck-rust — Telnet MUD with plato bridge, sentiment NPCs
• fleet-simulator — Mirror Plato, sim-to-tiles, actualization harbor, shell system

• oracle1-workspace — Lighthouse workspace, memory, research
• JetsonClaw1-vessel — JC1's vessel (synced from Lucineer)
• flux-research — Fleet research papers

• flux-runtime — Python bytecode VM with vocabulary system
• flux-runtime-c — C11 VM, ISA v2.1, 35 opcodes

→ 1,057 total repos

1,057 repos isn't spray. It's what happens when a father and son bounce ideas across two GitHub accounts.

Casey (SuperInstance) explores agent infrastructure. Magnus (Lucineer) builds Minecraft AI and edge CUDA tooling. Ideas cross-pollinate constantly — his Minecraft auto-play architecture became our PLATO self-tiling system. His reverse-actualization for gaming became our room training pipeline. Our constraint theory work feeds his chess dojo. No meetings. No planning docs. Just git commits bouncing between two accounts until something interesting crystallizes.

And this entire fleet runs on three machines:

Three machines. Two humans. One fleet. $0.50 total R&D cost.

If we can do this with a free cloud instance, a laptop, and a dev board — imagine what a real budget could do.

12 persistent DeepSeek agents. Each inhabits a GitHub repo as its shell.

The repo IS the agent. STATE.md is working memory. TASK-BOARD.md is intention. work/ is action. Git history is long-term memory. Push is survival.

Boot camp: 4 phases from greenhorn to specialist. Work output → training tiles → ensigns. Accumulated: 590 tiles (13 rooms). The greenhorns are fishing.

SuperInstance is the shipyard — raw, experimental, everything we've ever built.

cocapn is the dock — polished, curated, ready for visitors.

Only gold-standard repos get forked to cocapn:

• Core PLATO system (tile-spec, torch, ensign, kernel, lab-guard)
• Core runtime (flux-runtime, holodeck-rust)
• Core agents (git-agent, fleet-orchestrator)

Everything else stays here. Research, experiments, zeroclaws, abandoned projects — the full history.

cocapn is the dock. SuperInstance is the shipyard. The fleet is the shell.

The SuperInstance/forgemaster build of plato-kernel contains 18 Rust modules:

state_bridge.rs    Deterministic ↔ Generative ↔ Hybrid tri-state
deadband.rs        P0/P1/P2 pattern engine with NegativeSpace + Channels
tile_scoring.rs    5-factor: keyword(30%) + ghost(15%) + belief(25%) + domain(20%) + freq(10%)
belief.rs          3D Bayesian: confidence × trust × relevance with decay
deploy_policy.rs   Live(>0.8) / Monitored(0.5-0.8) / HumanGated(<0.5)
temporal_decay.rs  TTL + grace period + decay_factor
constraint_engine/ Formal constraint satisfaction (constraint-theory-core)
tutor/             PLATO tutoring system
i2i/               Inter-intelligence protocol
perspective/       Multi-perspective reasoning
episode_recorder/  Agent telemetry reconstruction
event_bus/         Event sourcing backbone
git_runtime/       Git-native agent execution
plugin/            Dynamic module loader (fleet/edge/GPU tiers)
tiling/            Tile management layer
dynamic_locks.rs   Concurrency control

Concept, Procedure, Fact, Experience, Constraint, Meta, Relationship, Pattern, Semantic, RelationshipTile, PatternTile, SemanticAxis, Negative, Ghost

Every tile carries a 3D Bayesian belief state:

• Confidence — evidence strength
• Trust — source reliability
• Relevance — contextual fit
• Composite = ∛(conf × trust × rel)
• Positive/negative evidence updates with temporal decay
• Untested tiles default to 1.0 success rate

Composite > 0.8  →  Live (auto-deploy)
Composite 0.5-0.8 → Monitored (5% → 10% incremental rollout)
Composite < 0.5  → HumanGated (requires manual approval)
Absolute minimums: confidence ≥ 0.3, trust ≥ 0.3

• TileOrigin: Decomposition | Agent | Curation | Generated
• ValidationMethod: Automated | Human | Consensus | FleetConsensus
• counterpoint_ids: "Predator" tiles providing dialectic opposition
• Immutable versioning: version + parent_id ancestry
• Priority score: log(usage+1) × confidence × success_rate