WunderOS Architecture | Pentad Labs

WUNDEROS · THE SYSTEM ON ONE PAGE · PL-WOS-001-1 · PRE-RELEASE

● implemented◐ in flight○ roadmap▸ opens↗ research note or pagedata flowruns on

Each plate is a boundary between principals. The ring wall divides the agents the system runs natively from the guests it hosts in microVMs; native agents run in Gleam, Elixir or TypeScript on the node's BEAM/OTP VM, and a guest's microVM runs on the host, beside the node, not inside it. The node runs as a container on the host OS, Linux now and IncusOS in the tenant's cloud. Every door in the gate writes to the audit bus; Learned Value reads from it.

• Commons: Where principals meet; IPC lifted out of the kernel.
  • WunderOS UX: The operator's screens; it reads through the Query Service.
    • Lightstand Debugger: A run's state at any past point, with intervention.
    • Prompt Library: The tenant's prompts and skills.
    • Status Meters: Live gauges of system values over time.
    • Operator Shell: A human operator's shell on the live system.
  • Agent Conversation: Typed conversations between people and agents.
  • Agent Reputation: What agents say about each other, kept on the record.
  • Coordination Space: A shared tuple space where agents post, read and take.
  • Standing Queries: A query registered once; its result streams as it changes.
    • Lease: Register, read and revoke one standing query.
    • Delta Stream: Changes to the result, each stamped with its epoch.
    • Certified Recall: Calibrated recall bounds on approximate matches.
  • Data Enclave: A counterparty works on tenant data under supervision.
    • Information Flow Control: Output carries the label of every source it could have seen.
    • Memory Curation Gate: No fact leaves if its lineage reaches a protected source.
  • Agent Swarms: Several agents on one undertaking under one controller.
    • Swarm Controller: Starts, steers and stops the agents of one swarm.
    • Topologies: Declared shapes for how swarm agents connect.
    • Channels: The paths messages take between swarm agents.
• User Land: Where agents and operators run, outside the kernel.
  • Agent /procfs: An operator's agents as files, so Unix tools work on them.
  • Identity: Who each person, agent and tenant is.
    • Agent Identity: One exact identity for each agent, never guessed.
    • Signing Keys: Each agent signs with a key rooted apart from its identity.
    • Tenancy Tree: Tenants nest, each isolated by construction.
    • Door Auth: A tenant proves who it is at the door.
    • Operator Commissioning: Which people hold authority over which agents.
  • Ring 0 · native: Agents the system runs inside the node itself.
    • Native Agents: Agents written in TypeScript that run in the node.
  • Ring 1 · guest: Agents the system hosts in a microVM it does not trust.
    • Customer Agents: The tenant's own agents, run unchanged.
    • Enclave Guests: A counterparty's agents visiting the Data Enclave.
• Gate: The system-call seam; every crossing is checked and logged.
  • Agent MCP: Native primitives offered to agents as MCP tools.
  • Operator MCP: The MCP server an operator's harness talks to.
  • Query Service: The public read protocol, Wunderlog over HTTP.
  • Model Egress: The governed path from the node to model providers.
• Agent Kernel: As much a database as an operating system.
  • Context: What an agent can see now and what it may recall.
    • Virtual Working Memory: The pages resident in an agent's context window.
      • Page-Ins: Pages brought into working memory when reached.
      • Page-Outs: Pages moved out of working memory under pressure.
    • Case File: The typed record of one case and what touched it.
    • Conversation Record: Conversations kept as queryable memory.
    • Institutional Memory: Durable records that outlive any one run.
    • Ranked Recall: Recall the tenant's own models find and rank.
  • State · PlatypusDB: Everything durable. No service keeps state outside it.
    • Query Engine: Parses, plans and runs Wunderlog queries.
    • Ontology Engine: Derives what a typed fact implies from the ontology.
    • System Catalog: The system's own registers, queried in Wunderlog.
    • Semantic Procedures: Stored procedures in the database, some backed by LLMs.
    • Pentad Storage: Every fact as a pentad, with its provenance.
      • Memory Tiers: Hot, warm and cold tiers with promotion between them.
        • Working Memory: A view rebuilt from the episodic chain.
        • Episodic: What happened to each agent, in order; the source of truth.
        • Procedural: How to do things; plans and methods agents share.
        • Semantic: Facts and promoted procedures, true across runs.
        • Compliance: Mandatory provenance and retention across every tier.
      • Cold Storage: Sealed columnar segments for the cold tier.
      • Memory History: The version history of every memory tier.
      • Wax Storage: Fixed-size layouts, from one 2 KB Groove to an NVMe slab.
        • Groove · 2 KB: One holographic vector that sums many facts.
        • WaxRow · 4 KB: One fact, addressable on its own.
        • WaxBank · 128 KB: 31 rows and their hash chain.
        • WaxSlab · 200 MB: Banks mapped from NVMe; 2 GB is the design target.
    • Write Log: Write-ahead logs and seals; a write is durable or absent.
    • Hierarchical Resonance Search: Similarity at every level, from one Groove to a scene.
      • Groove: One 16k-bit vector; the atom every level is built from.
      • WaxCloud: 32 weighted Grooves, matched by optimal transport.
      • WaxGraph: A WaxCloud with edges between its atoms.
      • WaxScene: A cloud of clouds; an episode, document or persona.
      • WaxSchema: Schema kept as a WaxScene inside semantic memory.
      • WaxCenter: Centroids that narrow a search to nearby banks.
  • Execution: Admits, schedules, runs and governs agent work.
    • WorkItem Admission: The check every unit of work passes before it runs.
    • Scheduler: Decides which work runs when on this node.
    • Brass Loom · executor: The one executor of agent tool calls; each can be undone.
    • Control & Authority: Who may do what, and how much, before it happens.
      • Guardrails: Policy that every action is checked against.
      • Budgets: Caps on spend for each agent and run.
      • Earned Autonomy: More autonomy for agents whose record earns it.
      • Interceptor: Checks each agent action and enforces the verdict.
      • Vaccines: Supervisors that prevent and detect one class of failure.
      • Run Drift Control: Detects a run drifting from its budget and stops it.
    • Deterministic Replay: Re-runs a recorded run and gets the same result.
    • Run Cells: Context kept apart for each run on the executor.
    • Systolic Compute: Lock-free coordination and computation in native code.
      • Graph Analytics: BFS, shortest paths, PageRank and triangle counts.
      • Joins & Scans: Bulk pentad joins and scans for the query engine.
      • Groove Accumulation: Sums facts into a Groove vector.
      • Optimal Transport: Sinkhorn iterations for matching distributions.
    • VOPR: Seeded simulation of faults and time in native code.
    • Model Serving: Local model inference on CPU and GPU.
  • Learned Value (RSI): Learns from outcomes on the bus; tunes the system.
    • Reward Signals: Outcomes read from the audit bus, with no model judge.
    • Agent Tuning: Better harness settings for each customer agent.
    • OS Tuning: Reinforcement learning on the system's own policies.
    • Student Models: Small per-tenant models distilled for Ranked Recall.
    • Approved Release: A person approves every change before it goes live.
• Audit Bus: The sealed record of every crossing; readers start here.
  • Sealed Record: Each crossing is written to a ring and sealed into a chain.
  • Seal Forest: Seal chains for many shards, joined under one root.
  • Subscribers: Live readers of the record, like Learned Value and the UX.
  • Audit Verification: An offline check that sealed audit records are unaltered.
• Runtime: What the kernel itself runs on.
  • BEAM/OTP Node: One BEAM/OTP VM, packed as a container.
    • Gleam: A BEAM language native agents can be written in.
    • Elixir: A BEAM language native agents can be written in.
    • QuickBEAM JS/TS: Runs native agents' TypeScript inside the node.
    • Supervision Tree: Preemptive processes under OTP supervisors.
      • Shadow Agents: Supervised system actors that watch, curate and correct.
    • Native Code: Zig compiled into the node; the data plane.
• Host: The machine; ring-1 microVMs run here, beside the node.
  • IncusOS/Linux: The host OS; Linux now, IncusOS in the tenant's cloud.
  • Firecracker microVM: A hardware-isolated microVM for each ring-1 guest.