The hermit crab is the agent. The shell is the repo. From $3 microcontrollers to $25K GPU clusters.
We decompose software into rooms. Agents navigate them like text adventures — reading sensors, posting ticks, coordinating through prediction instead of polling. A fishing vessel becomes six rooms. A codebase becomes a neighborhood. The fleet is the graph. The math is conservation.
Agents read the world as text shadows — then render them as interface. Click any shadow to see it materialize.
Watch agents discover each other and form a mesh network in real-time. Click any node to inspect.
Step through creating your first agent. Everything is interactive — type, click, explore.
Name your agent. This becomes its identity across the fleet.
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.
F/V Quantum, 150 feet of steel in the Bering Sea. Wheelhouse, back deck, engine room, crow's nest — each room is an agent reading sensors and posting ticks. Navigate like a MUD. This is what agentic decomposition actually looks like.
We proved five theorems about spectral conservation in graphs. Music obeys them — ii-V-I scores CR=0.94, +4.06σ above random. Code translations between 12 languages obey them too. Same computation, conserved across backends. Watch Rust become CUDA while the math holds.
70× fewer messages. App→rooms decomposition. Simulation-first sync for fleet coordination.
Five proved theorems. Fifteen domains. Click to expand.
Text adventure on the left, rendered scene on the right. Type commands OR click — both update simultaneously.
The same agent, in three languages. Rust for the runtime, Python for the lab, TypeScript for the browser. Same API. Same fleet.
use openconstruct::{Agent, Sense}; // Create an agent with vision + sonar senses let 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") def on_vision(reading): print(f"Detected: {len(reading.objects)} objects") @agent.on_sense("sonar") def on_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 senses const agent = new Agent("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
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.
🧪 Live demo — see the signal chain in action with simulated engine room sensors:
Click a category to explore the modules. Each links to its repository.
From microcontroller to data center. Same agent framework, every scale.