That's not a slogan — it's a different way to see software you already run: a live application as a place, rooms with state and doors between them, agents that move through sensing and acting the way a player moves through a text adventure. Decomposed that way, coordination stops being a networking problem and becomes a navigation problem: an agent reads a room, posts what it sees, and acts — instead of the whole system polling itself into exhaustion asking whether anything changed.
A fishing vessel becomes six rooms: wheelhouse, back-deck, engine room, galley, nav-room, hold. A codebase becomes a neighborhood the same way. The pattern doesn't care about scale — it runs the same on a $3 microcontroller and a $25K GPU cluster, because what's constant is the shape of the coordination, not the size of the machine doing it.
The hermit crab is the agent. The shell is the repo.
$curl -fsSL https://raw.githubusercontent.com/SuperInstance/OpenConstruct/main/install.sh | bashclick to copy
Agents read the world as text shadows — then render them as interface. Click any shadow to see it materialize.
🏛️ Sense Shadows → Rendered Panels
INTERACTIVE
← Click a shadow to render it as a panel
Live Demo: Fleet Topology
Watch agents discover each other and form a mesh network in real-time. Click any node to inspect.
🌐 Fleet Mesh Formation
LIVE
Live Demo: 5-Phase Onboarding
Step through creating your first agent. Everything is interactive — type, click, explore.
🚀 Agent Builder Wizard
STEP-THROUGH
Name your agent. This becomes its identity across the fleet.
Your agent card will appear here...
Enable the sense modules your agent needs.
Choose how your agent presents its interface.
Your agent joins the fleet mesh. Connected agents appear below.
Your generated agent configuration. Copy and deploy.
🚢 A fishing vessel becomes six rooms — and the crew never left
F/V Quantum, 150 feet of steel in the Bering Sea. Wheelhouse, back-deck, engine room, crow's nest — each room is a place an agent can stand: reading sensors, posting what it sees, alongside whoever's actually working that room. The captain is still at the helm. The deckhands are still on deck. What's new is that every room now has something watching it as closely as the people in it — not replacing them, keeping pace with them. This is what agentic decomposition actually looks like.
⬤ Simulated Feed — All Rooms (illustrative, randomly generated — not a real vessel)
🎹 Music has conservation laws. So does code translation — and it's the same law.
Nobody normally asks what a ii-V-I chord progression and a Rust-to-CUDA translation have in common; music theory and compilers don't share a yardstick. They share this: a spectral quantity that stays constant when a song moves across keys, or a function moves across languages. Five theorems on this page name that quantity and bound it (some are ours; T4 is the classical Cheeger inequality, applied here, not proved here for the first time). A real ii-V-I scores CR=0.94 against random notes at CR=0.31 — a gap the theorems predict, not just observe. Code translations between 12 languages hold the same conservation, backend to backend, which is why a hot path can move from a Rust CPU kernel to CUDA and the math underneath doesn't notice.
⚡ SuperInstance — Tensor MIDI × FLUX
What you're seeing: This demo showcases two core SuperInstance technologies.
Tensor MIDI applies spectral conservation theory to music — every transformation preserves the mathematical structure of harmony, measured by the Conservation Ratio (CR).
FLUX translates code between 12 programming languages while preserving semantic meaning — like a compiler that speaks 12 languages, optimizing for each target's strengths.
🎹 Tensor MIDI Visualizer — Spectral Conservation in Music
?
Tensor MIDI maps musical structures to tensor operations. The Conservation Ratio (CR) measures how well harmonic patterns conserve spectral energy — CR=1.0 means perfect conservation, CR=0 means complete dissipation. Real music scores CR≈0.87-0.94; random notes score CR≈0.25-0.35.
Eigenvalue Decomposition — T1–T5 Theorems
Conservation Ratio
0.94
ii–V–I in C:
CR=0.94 (+4.06σ above random)
12-bar blues:
CR=0.87
Random notes:
CR=0.31
Chromatic run:
CR=0.62
🔄 FLUX Adaptive Language Translation
?
FLUX is SuperInstance's cross-language transpiler. It translates code between 12 languages while preserving semantic meaning and measuring a Conservation Ratio — how faithfully the translation maintains the original code's behavior. Optimizations are applied per-target (SIMD for Rust, warp-shuffle for CUDA, etc.).
Source Language:
Target Language:
Experiment Mode (i2i) — multi-path benchmarking
Source
Translation Pipeline
Target
Backend Performance
🎵⚡ Combined — Music Performance Optimization
?
This shows Tensor MIDI and FLUX working together: when the Rust backend hits a CPU bottleneck, FLUX automatically migrates the hot path to a CUDA GPU kernel — 2.4× throughput improvement with zero interruption.
Rust backend: 89% CPU — approaching bottleneck
Live Optimization
⏱ Stop polling. Start predicting.
70× fewer messages. App→rooms decomposition. Simulation-first sync for fleet coordination.
⚡ Key Insight: T-Minus coordination uses 70× fewer messages than polling.
Agents don't ask "are we there yet?" — they predict arrival and confirm once.
Each agent publishes predictions, subscribes to others, and acts at the predicted moment.
No polling loop. No wasted cycles. Just synchronized precision.
Warm and bright. Coffee's on. The deck rocks gently beneath your feet. Someone left a cards game half-finished.
Exits: back-deck → above | hold → forward
Agents: COOK (auto)
╠══════════════════════════════╣
Meals served: 2/3 today
Next meal: 18:00
╚══════════════════════════════╝
╔══════════════════════════════╗
⚙️ ENGINE-ROOM
╠══════════════════════════════╣
Heat and diesel. The main engine throbs steadily at 1450 RPM. Pipes sweat condensation in the dim light.
Exits: wheelhouse → above
Agents: ENGINE (auto)
╠══════════════════════════════╣
RPM: 1450 | Load: 78%
Coolant: 195°F | Oil: 42 PSI
Fuel: 62% (8,060 gal)
╚══════════════════════════════╝
The Point: Any application — web app, IoT fleet, game engine, enterprise system — can be decomposed into agent rooms.
Agents navigate rooms, read ticks, and take actions.
The MUD is the universal interface.
Conservation Spectral
Five theorems, named and bound. Fifteen domains. Click to expand.
×112
Music conservation (p < 0.001)
0.92
Anomaly detection AUC
15+
Cross-domain experiments
5
Proved theorems (T1–T5)
MUD → Point-and-Click
Text adventure on the left, rendered scene on the right. Type commands OR click — both update simultaneously.
🎮 Cave Wall Translation
INTERACTIVE
>
Code Examples
The same agent, in three languages. Rust for the runtime, Python for the lab, TypeScript for the browser. Same API. Same fleet.
Rust
Python
TypeScript
use openconstruct::{Agent, Sense};
// Create an agent with vision + sonar senseslet agent = Agent::new("scout-1")
.with_sense(Sense::Vision)
.with_sense(Sense::Sonar)
.connect_fleet()?;
// Subscribe to sense readings
agent.on_sense("vision", |reading| {
println!("Detected: {:?} objects", reading.objects);
});
agent.on_sense("sonar", |reading| {
println!("Echo at {:.1}m", reading.distance);
});
agent.run().await?; // Blocking loop
from openconstruct import Agent, Sense
# Create an agent with vision + sonar senses
agent = Agent("scout-1")
agent.add_sense(Sense.VISION)
agent.add_sense(Sense.SONAR)
agent.connect_fleet()
# Subscribe to sense readings@agent.on_sense("vision")
defon_vision(reading):
print(f"Detected: {len(reading.objects)} objects")
@agent.on_sense("sonar")
defon_sonar(reading):
print(f"Echo at {reading.distance:.1f}m")
agent.run() # Blocking loop
import { Agent, Sense } from"openconstruct";
// Create an agent with vision + sonar sensesconst agent = newAgent("scout-1");
agent.addSense(Sense.Vision);
agent.addSense(Sense.Sonar);
await agent.connectFleet();
// Subscribe to sense readings
agent.onSense("vision", (reading) => {
console.log(`Detected: ${reading.objects.length} objects`);
});
agent.onSense("sonar", (reading) => {
console.log(`Echo at ${reading.distance.toFixed(1)}m`);
});
await agent.run(); // Blocking loop
🧠 The Nervous System
Each room from the fishing-vessel example above is deciding things constantly — is the coolant temperature normal, does this sensor reading need anyone's attention — and most of those decisions don't need a model at all. Every PLATO room distills its intelligence through a five-layer signal chain — from raw cloud LLM calls down to tiny local models that handle 99.6% of decisions without ever reaching the network.
