PL-WOS-001-0 · File No. WOS/SYSTEM/01 · Pre-Release
Agent Operating Systems
WUNDEROS by Pentad Labs
The Agentic Operating System
A Minimal Viable Theory

WunderOS is autonomic computing for agents. But, first, a minimal, viable theory.

Solomonoff (1964) proved that optimal compression of any computable sequence is equivalent to optimal prediction of it. Hutter and Schmidhuber extended this to agency: the optimal universal agent is a compressor that has learned the regularities of its environment.

Prediction is the load-bearing aspect of intelligence in this framing. Compression is the mechanism that makes prediction tractable.

Recursion is one mechanism for achieving compression. Bird-Meertens (1986) teaches that structural recursion over an inductive type is a fold, a catamorphism that collapses arbitrary-depth structure into a value via an algebra that retains only load-bearing information. The fold is the mechanism; the algebra is the choice. Well-chosen folds compress.

WunderOS is built on substrate-recursion. Every agent action, every classifier output, every plan execution writes back to the substrate with full provenance. These folds compress operational experience into a representation that subsequent cycles consume as context. Cycle N’s experience becomes cycle N+1’s compressed prediction surface.

The substrate gets smarter over operational time, not because the LLM does, but because the substrate’s compression of experience improves with each cycle.

Substrate-recursion is fold-shaped compression. Fold-shaped compression is intelligence-shaped behavior at the architectural layer. The substrate is the locus of accumulated intelligence. The LLM remains the workhorse for genuinely novel reasoning. Customer agents inherit both. Token consumption decreases. Reasoning quality holds or improves. The loop closes.

Software Platform

WunderOS is an autonomic operating system for agents that combines harness engineering, systems engineering, and control theory with bare metal, HFT-grade latency, durability, and transparency.

Autonomic systems have a precise reference model, namely, MAPE-K (Monitor, Plan, Analyze, Execute over shared Knowledge). WunderOS is MAPE-K for agents: a platform where substrate-recursion makes the write path the structural through-line.

In WunderOS, every assertion carries provenance; every classification carries lineage; and every plan execution writes back into knowledge with full audit-grade traces.

We began with Wunderblock, the agentic memory subsystem. A binary-vector substrate unifies vector and graph retrieval. Three properties distinguish it, none using an LLM in any path: deterministic retrieval and ingestion; deterministic governance and lineage; and deterministic associative memory via VSA/HDC.

In WunderOS, customer agents run unchanged. Agentic frameworks issue native primitives unawares. WunderOS intercepts them invisibly, where it can provably improve upon them, answering them as syscalls. No LLM calls in any internal hot path. Agentic frameworks are the new userland.
Unification

One binary-vector substrate absorbs data streams that otherwise demand separate stores. All become Pentads; all participate in the same bind/bundle/resonate algebra.

  • Agent exhaust: observations, tool outputs, session logs.
  • Enterprise facts: RDBMS, ERP, CRM, HRIS. See §4 (Institutional).
  • Dense embeddings: what a vector database (HNSW, IVF-PQ) would hold.
  • Multimodal features: images, audio, via learned VSA projectors.
  • Case-based analogies: relational patterns, reasoning cases.
Principle

LLM Minimality. Every primary path is LLM-free. Frontier calls are a fallback, never the default. They decay as per-tenant small models distill from them. Each is opt-in, metered, and recorded in Lineage.

Core Operation

Single-hop resonance: ~100ns. Binding: ~200ns. Multi-hop CSR query and inference linear in beam width, not query depth—a 10-hop query costs the same as a 3-hop query. 16,384-bit binary vectors, AVX-512 Hamming distance. No GPU required.

1. A Closed Loop System▲ Contents

Mandate · Closed Loop Invariant · Subsystems · Three Axes
Mandate

WunderOS is an operating system for AI agents.

Subsystems
Name Status Description
Agentic Memory Pre-Release Wunderblock. VSA substrate, six memory tiers, multi-hop ZRP inference. See §2–§4.
Native Agent Execution Internal Framework calls as syscall ABI. BEAM-native customer-agent runtime via Elixir-Volt / OpenBeam.
Agentic Planning Draft Shadow Agents and plan ledger. Hybrid HTN/CBR over Pentads. Saga rollback.
Deterministic Runtime In Progress Simulated clocks, VOPR-style fuzzing, replayable sessions. Time is a first-class capability.
Invariant

WunderOS is a closed-loop system by construction. Every subsystem that touches memory, agents, policy, or retrieval is decomposed as plant + sensor + controller + actuator. Missing any element means the loop is open and the subsystem is incomplete. This is the structural difference that separates WunderOS from the LLM-wrapper plumbing shipped by every competitor.

The LLM Bracket

LLMs are inherently open-loop: one-shot input → output. KV cache, attention patterns, and gradients are not formally observable. WunderOS does not reach inside them and does not claim internal observability of their workings.

Instead, every LLM interaction is wrapped in a closed loop at the I/O boundary. Trace events and vaccine assertions serve as the sensor; gateway policy, vaccine category match, and execution-harness checkpoints serve as the controller; WAL mutation, policy patch, and retry/replay/reject serve as the actuator.

Control Formalism

Ramadge-Wonham supervisory control (1989) is the dominant framework. LLM tokens, customer input, and clock ticks are uncontrollable events. Tool dispatch, memory commits, network egress, and vaccine-gated emission are controllable events. The supervisor observes event strings and prevents controllable events per specification.

RW guarantees a unique maximally permissive supervisor for any (plant, spec) pair: minimum necessary restriction, not an allowlist. Hybrid automata cover subsystems mixing discrete events with continuous state—memory decay, latency EMAs, bench trends. Classical PID does not apply.

Failure Modes

Control theory names the failures closed loops exhibit. Every new subsystem design bounds each.

  • Oscillation. Controllers fight over shared state. Obligation: convergence proof or bounded frequency.
  • Integral windup. Arrival outruns processing. Obligation: rate-limit, priority queue, or triage path.
  • Sensor saturation. Signal loses discrimination. Obligation: sensor diversity and recalibration.
  • Deadband. Thresholds hide drift below trigger. Obligation: prefer continuous sensors.
  • Drift. Open sub-loop silently accumulates error. Obligation: the loop closes.
  • Latency instability. Sensor lag induces overcorrection. Obligation: name the lag explicitly.
Corollary

Agent-facing UX is a supervisor grammar. Every tool gate, memory scope, HITL approval, vaccine manifest, and policy rule is a specification expression over the plant's controllable events. Harness engineering is supervisor-UX design.

Three Axes

Agent control has three axes, all grounded on the Pentad substrate. Datalog answers which facts are derivable; Wunderlog and ZRP evaluate. Supervisor answers which actions are permissible (see the closed-loop formalism above). Planner answers which actions are chosen by HTN synthesis with case-based retrieval over Pentads.

The three compose without impedance mismatch. They share one predicate vocabulary. An HTN method, a Datalog rule, and a supervisor specification are syntactically interchangeable views on one logic surface. A fourth axis is rarely the answer. Concerns that do not fit derivable / permissible / chosen are execution, observation, or storage; they belong elsewhere.

DATALOG What's derivable? Wunderlog · ZRP SUPERVISOR What's permissible? shield · contract PLANNER What's chosen? HTN · CBR
Figure 1-1. Three orthogonal axes of agent control · Composable because they share one predicate vocabulary
Part 1. The Memory Subsystem

2. Wunderblock▲ Contents

Agentic Memory Subsystem · Vector Symbolic Architecture · D=16,384
Subsystem

Wunderblock is the agentic-memory subsystem of WunderOS, and the first component published here. A binary-vector substrate unifies vector and graph retrieval. Three properties distinguish it, none using an LLM in any path: deterministic retrieval and ingestion; deterministic governance and lineage; associative-memory semantic effects including similarity-preserving retrieval, holistic representation, and graceful degradation. This section covers the physics. §4 covers the Pentad cognitive primitive. §5 covers the six-tier memory model. The wire interface lives in Part 2.

Encoding

All knowledge is encoded as 16,384-bit hypervectors using Binary Spatter Codes. Three operations are defined: binding (XOR), bundling (saturating addition), and search (Hamming distance). All other operations compose from these.

Components
  • VSA/HDC: Binary Spatter Codes (BSC), D=16,384.
  • Codebook: BLAKE3 hash → deterministic binary vector.
  • Query: ZRP beam-search, multi-hop, K-scaling.
  • Temporal: LTL+ operators (Once, Since, Eventually, Always).
  • Storage: 8KB WaxRows, 256KB WaxBanks, O_DIRECT via io_uring.
  • Concurrency: Lockless SWMR, CAS loops, no OS mutexes.
Query Model

The VSA locates the neighborhood; classical methods extract individuals. Superposition serves as an index, not an answer format.

3. The Pentad▲ Contents

Subject · Predicate · Object · Context · Lineage
Primitive Unit

The primitive unit is the Pentad: (Subject, Predicate, Object, Context, Lineage).

SPO defines the graph edge. Context scopes it temporally, spatially, or situationally. Lineage records provenance: agent signature, source document, derivation chain. Binding order is non-commutative; bind(O, bind(P, S)) and bind(S, bind(P, O)) produce distinct vectors.

PENTAD(7)               WunderOS Cognitive Substrate                PENTAD(7)

NAME
       pentad — five-slot cognitive fact primitive

SYNOPSIS
       bind(L, bind(C, bind(O, bind(P, S))))

DESCRIPTION
       The primitive unit of Wunderblock, the memory subsystem
       of WunderOS. Each component
       is a 16,384-bit binary vector (Groove) encoded via BLAKE3.

       S, P, O    Graph skeleton. Topology. What connects to what,
                 in which way. Non-commutative.

       C         Context. Temporal, spatial, or situational scope.

       L         Lineage. Agent signature, source doc, derivation.

OPERATORS
       XOR       Binding. Reversible. Non-commutative under PathHD.
       MAJ       Bundling. Saturating addition. Superposition.
       HAMMING   Similarity. One SIMD cycle. O(1) resonance.

INVARIANTS
       • SPO is the graph edge. [C,L] are aspect modifiers.
       • The (P,O) fingerprint in sys_id ignores C and L.
       • ZRP peels L, then C, then extracts O via Aspect-O.
       • Novelty/dedup operates on SPO core, not full fact.

SEE ALSO
       zrp(7), waxrow(5), honeycomb(7), lexicon(3)

HISTORY
       First described in PL-WOS-001-0. Based on work by
       Kanerva (1988), Plate (2003), Gayler (2004).

Pentad Labs                      2026-04-21                      PENTAD(7)
Figure 3-1. Pentad binding structure · See zrp(7), waxrow(5)

4. Memory Tiers▲ Contents

Six tiers · Different physics per tier · Fact flow
Tier Model

Facts flow through six memory tiers. Each tier has different retention, query physics, and storage characteristics.

Compliance (Ring-0)
Working
Episodic
Procedural
Semantic
Institutional
Figure 4-1. Compliance encompasses all tiers · Institutional feeds in orthogonally
Tier Specs
Tier Description
Working 16 banks × 31 facts, i8 accumulators. Novelty-gated. Transient.
Episodic 8KB WaxRows, O_DIRECT NVMe. ULID, provenance DAG, (P,O) fingerprint.
Semantic Immutable WaxBanks. Tier-1 axioms. Noise recovery oracle.
Procedural Goal-sequence bindings × 1024. Exponential-decay. Shadow Agent habits.
Institutional Systems of record compiled to Pentads. Demand fetch primary, bulk sync cold start.
Compliance Policy vectors. Gram-Schmidt nullification. Amplitude overdrive. Pre-LLM.
Query Physics

Single-hop similarity uses Honeycomb resonance probes. Multi-hop inference uses ZRP beam-search with Datalog evaluation. Query patterns and K values differ per tier.

Part 2. The Runtime

5. The Loom▲ Contents

Shadow Agents · Plan Ledger · Saga Rollback
Shadow Agents

Every customer-facing agent runs paired with a Shadow Agent. The Shadow Agent observes the customer agent's events, evaluates each step against its contract, and gates emission. Shadow Agents are the productized supervisor axis. The Ramadge-Wonham specification surface from §1 is exposed as a runtime peer, not buried in the harness; supervisor logic ships, deploys, and versions like any other artifact.

The Supremal

Each Shadow Agent runs a Supremal: the synthesized supervisor it enforces. The Supremal is the supremal element of the policy lattice in RW theory; the unique maximally permissive supervisor for a given (plant, spec). Minimum restriction, never more. Specs are written in Wunderlog, versioned like code, recompiled to a fresh Supremal on change. The harness ships Supremals, not hand-coded gates.

Plan Ledger

Plans are not transient. The planner emits steps as Pentads (precondition, action, postcondition, compensating action, lineage) and appends them to the plan ledger, an ordered durable record. Agents do not act from in-context plans. They act from committed ledger entries. Execution is replayable; pauses are resumable; the planner / executor split is clean. The planner writes. The executor reads. The ledger is the contract.

Saga Rollback

When a step's contract fails (Shadow Agent veto, tool error, vaccine trigger), the runtime walks the ledger backward, executing the compensating action of each prior committed step. The plan unwinds to a known consistent state. No manual intervention. No human in the loop. Forward and rollback are one primitive seen from opposite directions; the ledger is the axis of symmetry.

PLAN LEDGER SAGA ROLLBACK SHADOW AGENT contract observer s1 s2 s3 s4 c3 c2 c1
Figure 5-1. Forward execution commits steps to the plan ledger under Shadow Agent oversight · Contract failure at s4 triggers compensating-action rollback to a consistent state

6. The Interface▲ Contents

Wunderlog · Natural Language Transducer · Datalog variant
Wunderlog

The native query language is Wunderlog, a Datalog variant optimized for LLM emission—agents produce well-formed queries without prompt engineering. A request body is a squirt: one or more scopes, each opened with WZ:: and closed with ETX; the squirt ends with EOT. Temporal operators map to LTL+ via Unicode glyphs with ASCII aliases.

N-ary Relations

Arity greater than 2 is supported by the ⟪⟫ role-binding operator in the O slot. K ≤ 5 produces resonance in the 0.37–0.50 range. K ≤ 10 is the practical ceiling. Higher arities require decomposition.

WUNDERLOG GRAMMAR                                  EBNF (v4 wire form)

<squirt>         ::= <scope>+ "EOT"
<scope>          ::= "WZ::" <tiers>? <modifier>? <item>* <end>
<end>            ::= "ETX" | "-30-"

<tiers>          ::= <tier_glyph>+ | "[" <tier_glyph>+ "]"
<tier_glyph>     ::= "ε" | "σ" | "ι" | "ω" | "λ" | "κ" | "Ω" | "⏚"

<item>           ::= <statement> | <squirt_block> | <rule>
<squirt_block>   ::= <label> "{" <tiers>? <modifier>? <statement>* "}"
<label>          ::= [a-z][a-zA-Z0-9_]*

<statement>      ::= <pattern> <modifier>?                  bare = read
                   | <action> <modifier>?
                   | <statement> <disj> <statement>

<action>         ::= <linda_op> "(" <pattern> ")"
<pattern>        ::= <pentad> | <temporal_expr>
<pentad>         ::= "(" <term> <term> <term> ")"
                   | "(" <term> <term> <term> <term> <term> ")"
<temporal_expr>  ::= <temporal> "(" <pentad> ")"

<rule>           ::= <atom> "(" <variable>+ ")" <arrow> <pentad>+
<arrow>          ::= "⇒" | ":-" | ":implies"

<modifier>       ::= "|>>" ("bindings" | "pentad" | "proof")

<linda_op>       ::= "⇑" | ":out"           write / emit
                   | "⇓" | ":in"            destructive read / consume
                   | "⊢" | ":rd"            non-destructive read
                   | "⊶" | ":retract"       retract a prior fact
                   | "⊸" | ":revise"        supersede a prior fact

<temporal>       ::= "♦" | ":once"          past: at some point
                   | "■" | ":historically"  past: always been true
                   | "●" | ":prev"          past: true at t-1
                   | "↤" | ":since"         past: A since B
                   | "○" | ":next"          future: t+1
                   | "◇" | ":eventually"    future: park until
                   | "□" | ":always"        future: forever

<disj>           ::= ";" | "∨"

<term>           ::= <atom> | <ns_atom> | <variable>
                   | <wildcard> | <string>
<atom>           ::= ":" [a-zA-Z_][a-zA-Z0-9_]*          :alice, :knows
<ns_atom>        ::= <atom> ":" [a-zA-Z_][a-zA-Z0-9_]*   app:ships_to
<variable>       ::= "?" [a-zA-Z_][a-zA-Z0-9_]* | "?"   ? = anonymous
<wildcard>       ::= "_"
<string>         ::= '"' [^"]* '"'
<closure>        ::= <atom> "+" <integer>?              :knows+, :knows+3
Figure 6-1. Wunderlog v4 wire grammar (partial) · WZ:: opens scope, ETX closes (-30- human alias) · bare pentads are reads

7. The Handshake▲ Contents

Agent First Contact · Wire Protocol · Bootstrap Sequence
Protocol

WunderOS rejects JSON tool-calling envelopes. All HTTP requests carry Content-Type: application/x-datalog. The body is raw Wunderlog text. Authentication is Authorization: Bearer <token>. There is no REST resource model—every request is a Wunderlog statement evaluated against the bivectorspace.

Bootstrap

An agent begins by fetching the protocol primer from GET /agents.txt. After parsing, it completes the handshake by emitting a self-naming Pentad to POST /wunderlog:

Session Frame

A request body is a squirt—one or more scopes, each opened with WZ:: and closed with ETX; the squirt ends with EOT. The framing is telegraphic: -30- is the human-readable alias for ETX. A scope pins a copy-on-write snapshot of the named tiers for the duration of the scope.

  • ε episodic · σ semantic · ι institutional · ω working memory.
  • λ loom / procedural · κ compliance · Ω all tiers.
  • lineage ground (L-slot anchor).

Bare pentads (:S :P :O) are reads. / wrap writes and destructive consumes. Result modifier |>> selects bindings (default), pentad, or proof. Squirts are named lexical blocks: label { [tiers] |>> modifier … }.

POST /wunderlog HTTP/1.1
Host: api.pentad.ai
Authorization: Bearer sk-live-...
Content-Type: application/x-datalog

// Scope 1 — episodic + semantic. Writes, reads, nested squirt.
WZ::εσ
  ((:Agent_Procurement :status "online"))
  ((:Factory_1 app:ships_to :Warehouse_7))

  (:Factory_1 app:ships_to ?Dest) |>> pentad

  audit { σ |>> proof
    ((:User_Alice :has_role "Admin"))
  }
ETX   // -30- is the human alias

// Scope 2 — working memory. Prev-tick workflow check.
WZ::ω
  (:User_Bob :action "Payment")
  ((:User_Bob :action "View_Cart"))
ETX

// Scope 3 — episodic. Park on SSE, consume when Job_123 completes.
WZ::ε
  (((:Job_123 :status "Complete")))
ETX

// Rule (outside any scope): friends are knows-chains of length 2
friends(?X ?Y)  (?X :knows ?Z) (?Z :knows ?Y)

EOT   // end of transmission, release the line
Figure 7-1. Wunderlog on the wire (v4 wire vocabulary) · WZ::{tiers} opens a scope · ETX closes it (-30- is the human alias) · EOT ends the squirt
Operations
Glyph ASCII Operation
:out Write. Etches a Pentad or rule into the bivectorspace.
:rd Read. Non-destructive. Binds variables against matching facts.
:in Consume. Destructive read. Fact is removed on match.
:infer Infer. Transitive traversal up to H hops.
:explain Reflect. Returns fuzzy NL context for a complex fact.
:nl Cast. Projects unstructured text into the vectorspace via LSH.
:ns_bind Mutate. Invents a new namespace concept and expands the ontology.
Lifecycle

Emitted facts do not remain static. Working Memory holds active context in superposition. Sleep cycles crystallize stable patterns into Episodic. Repeated invariants promote to Semantic (immutable). Procedural bindings are revisable action-trigger rules evaluated by Shadow Agents.

Error Shapes

Failures return the operator. ↯(:syntax, :parse_failure) indicates malformed Wunderlog. ↯(:hardware, :hop_limit_exceeded) means the 32-hop traversal ceiling was hit. ↯(:semantics, :unbound) means the predicate is unknown—expand the ontology with and retry.

Transport

Responses are newline-delimited Wunderlog assertions, not JSON. HTTP POST for synchronous evaluation. SSE for parked forward-LTL queries ( / :eventually). WebSocket for persistent bidirectional streams. The wire format is identical in all cases.

8. Implementation▲ Contents

Zig + Gleam/BEAM · NIF bridge · All operations reduce to XOR, popcount, threshold
Cognitive Plane

Implemented in Zig. SIMD dispatch covers AVX-512, NEON, and scalar fallback. WaxBanks are cache-aligned at 256KB—one L2 cache line group. Storage uses O_DIRECT + io_uring for zero-copy NVMe access. Concurrency is lockless SWMR with CAS loops and atomic pointer swap over a 64-generation retired ring. Hot paths perform no heap allocation.

Control Plane

Implemented in Gleam on the BEAM. Provides HTTP gateway, actor supervision, AST parsing, query engine, and symbol-vector mapping. A NIF shared library bridges Gleam to Zig through Erlang’s C-ABI.

Status

Pentad Labs is pre-revenue. The memory subsystem (Wunderblock) is maturing rapidly, nearing first public release in Pentad Cloud. Native Agent Execution, Agentic Planning, and the Deterministic Harness runtime are in-flight.

Contact

If you build or operate multi-agent systems and want to talk about what an agentic operating system should actually look like, reach out.

Kendall Clark, k@pentad.ai
—Great Falls, Virginia
April 2026