RS / HEG / RPU TOY LAB // AMBER TERMINAL

// 01 — HOME

Reasoning Substrate Lab

The Reasoning Substrate is a deterministic reasoning layer — a model-agnostic, language-agnostic state machine that structures how systems take reasoning steps. It integrates cleanly with existing architectures, guiding or supporting them to produce more stable, predictable, and reliable reasoning.

This lab hosts conceptual toys — self-contained, browser-runnable simulations demonstrating the RS, HEG, and RPU architectures in isolation. Each toy is a proof-of-concept harness that makes one architectural idea visible and interactive. Nothing here is production code. Everything here is deterministic.

What is a toy? A minimal, fully self-contained HTML/JS simulation demonstrating one specific behavior of the substrate — auditable, replayable, no external dependencies, no network calls.

What is the HEG? The Human Expression Gateway converts raw human expression — text, audio, gesture, prosody — into typed Cognitive Action Packets (CAPs) via a deterministic operator pipeline: SEGMENT → ACT → TARGET → EMOTION → PATTERN → CAP_BUILD.

What is the RPU? Reasoning Processing Units are a proposed class of hardware accelerators, conceptually designed to execute the Reasoning Substrate (RS) update cycle directly in silicon. RPU Classic is defined around contraction-based deterministic convergence, while RPU Quantum is defined around energy-guided perturbation to escape shallow traps. Our current work focuses on the mathematical architecture and patent foundation for these units, with hardware implementations treated as future targets rather than existing products.

RS v1RS v2HEGRPULITE — BY REQUEST

// 02 — TESTING CENTER

Testing Center

All modules below are TOY-grade — browser-runnable, fully sandboxed, no network calls. Click [ EXPAND ] on any toy to load and run it inline.

⏐ HERO TOY // UNIFIED SUBSTRATE DEMONSTRATION

100× Deterministic Replay

This LITE artifact showcases the core physics of the RS substrate: deterministic state evolution, invariant-bounded collapse, fixed-point stability, fault-tolerant safe-return, and replayable audit traces. It is designed as a minimal, inspectable runtime that can be crashed, resumed, replayed, diffed, and exported — allowing engineers to verify substrate behavior directly, without models, heuristics, or optimization. Every step depends only on (state, tick), enabling bit-for-bit identical trajectories across runs and full recovery from interruption. This is the public slice of the substrate: a reliability and safety demonstration built for hyperscalers evaluating deterministic reasoning systems.

── FEATURED TOYS ──────────────────────────────────────

Four featured tests — agent failsafe, full HEG→CAP→RS pipeline, RPU vs Transformer, and the RSv2 intent orchestration layer.

TOY·01 RS v1 — Agent Framework Toy

Wraps a multi-agent orchestration layer (PlannerAgent, DataAgent, ActionAgent) inside an RS v1 cycle. Visualizes state → forward model → plan scoring → collapse. Includes live tool-failure injection to demonstrate RS failsafe and recovery.

TOY·02 HEG — CAP — RS Pipeline

Full HEG→CAP→RS pipeline. Choose text, audio, or video presets and watch each expression processed through SEGMENT, ACT, TARGET, EMOTION, PATTERN, and CAP_BUILD into a typed Cognitive Action Packet. Includes audit envelopes and replay/diff.

TOY·03 RPU vs Transformer — Stability Harness

Side-by-side: Transformer thrashes on complex input, RPU-Classic converges to a fixed point, RPU-Quantum descends an energy landscape. Canvas animations show live energy, state variance, and convergence metrics across all three engines.

TOY·04 RSv2 — Intent / Planner / Executor

Intent Agent → Planner Agent → Executor Agent pipeline on a shared RSv2 memory substrate. Features token budgeting, safety filters, and audit replay. Amber terminal aesthetic throughout.

── MORE TOYS ───────────────────────────────────────────

RS·01 RS v1 — Six-Test Suite

Six long-horizon stability tests across up to 1M turns: constraint grammar enforcement, drift prevention, isothermal load balancing, multi-agent stability, and full audit & replay.

RS·02 RS v1 — Universal Compiler

Translates semantic DSL instructions into typed RS operator graphs then into backend-specific output across compiler, telecom, banking, and networking scenarios.

RS·03 RS v1 — POP-LITE Processor Optimizer

Simulates CPU/GPU/memory/thermal/battery with four plan modes. RS substrate governs hardware state toward low-entropy configurations.

HEG·01 HEG — Segmentation Edge Cases

Stresses the SEGMENT operator with nested intents, abrupt topic shifts, and contradictory instructions.

HEG·02 HEG — Act Classification Ambiguity

Targets the ACT operator boundary between COMMAND, ASK, and ASSERT. Exposes scoring heuristics used to disambiguate intent type.

HEG·03 HEG — Emotion × Target Interaction

Demonstrates the EMOTION operator at the CAP→RS boundary. High-arousal negative inputs trigger different constraint weighting than neutral equivalents.

HEG·04 HEG — Multimodal Fusion

Sends the same text through different synthetic audio and video contexts. The FUSION operator produces different CAPs depending on the combined modality signal.
*Illustrative: audio/video inputs are text-described stand-ins for a browser demo, not real signal processing. Shows methodology, not measured multimodal performance.

RPU·01 RPU — Packet Storm Harness

Flood of hostile packets. Transformer state leaks; RPU-Classic isolates; RPU-Quantum sheds excess via energy-guided shedding.

RPU·02 RPU — Constraint Solver Harness

A 4×4 grid constraint puzzle solved across three engines. Classic applies contraction; Quantum uses perturbation; Transformer iterates without convergence guarantees.

RPU·03 RPU — Constraint-to-Energy Compiler

User-defined constraints compiled into E(x) energy function. Both RPU variants minimize from random starting states.

RPU·04 RPU — Energy Landscape Explorer

A single reasoning state traverses a visualized energy surface. Classic follows gradient descent; Quantum adds noise to escape local minima.

RPU·05 RPU — Lattice Convergence Harness

8×8 multi-cell grid descends energy simultaneously. Color shows cells from high-energy (red) to stable (green).

RPU·06 RPU — Multi-Agent Coordination Harness

Six agents navigate a shared space. Quantum agents receive a mid-run perturbation that Classic agents do not.

RPU·07 RPU — Power & Thermal Budget Harness

GPU-style power and thermal spikes versus RPU flat-and-cool energy descent. Bar charts show real-time power draw and heat generation.
*Illustrative: power/thermal curves are stylized for demonstration, not measured from real workloads. Shows methodology, not benchmarked performance.

RSv2·01 RSv2 — Multi-Agent Self-Learning Toy

Episode-based learning loop with fitness scoring and bounded parameter updates. Agents improve across episodes without gradient descent.

// 03 — LITE DEMO ENGINES

Lite Demo Engines

LITE demos are architectural miniatures — small, precise, and intentionally incomplete. They show how the system thinks, stabilizes, collapses, and converges, without exposing the underlying substrate or proprietary operator calculus. Each LITE is a functional slice: enough to demonstrate capability and behavior; not enough to reveal the crown jewels.

Available for short-term exclusivity evaluation — contact matt@icpub.org.

Each LITE keeps the real structural elements: the state model, the update rules, the evolution loop, the trace format, and the measurable outputs. This makes them ideal for modeling, scaling tests, integration work, and technical evaluation, without exposing sensitive substrate-level mechanisms. They are small, deterministic, and fully inspectable.

Transformer + RSLite Runtime

A self-contained small-scale transformer running entirely in the browser, wired through an RSLite runtime. Shows how a software substrate can normalize input, encode to tokens, run genuine multi-head attention, apply identity projection and stability smoothing, and decode back to text — without any external dependencies or trained weights.

CODE SUMMARY: 2-layer, 4-head causal decoder-only transformer (hidden_size=64, ff_size=256) with seeded Xavier initialization, Float32Array matmul, layer norm, GELU, and causal attention. RSLite adds identity projection, stability smoothing, conversation memory, and a byte-level tokenizer in a dark-themed chat GUI.

Minimal RSLite + Universal API + Language Layer

A compact RSLite orchestration layer that decomposes inputs, plans steps, verifies outputs, and exposes a universal API boundary. Demonstrates how RS can sit behind a language layer and domain-specific helpers (math, code) while remaining implementation-agnostic.

CODE SUMMARY: Defines RSLite with decompose → plan → executePlan → verify → identityCheck, a universal RSAPI that routes tasks to a model, and a LanguageLayer that detects language, builds context, and handles user messages. All logic is stubbed and generic — control-flow rather than substrate math.

RPUClassicLite & RPUQuantumLite

Two LITE RPUs illustrating deterministic Θ-loop reasoning: a contractive classical core and a quantum-flavored core with an explicit energy function. Shows how RS-style dynamics can be expressed as stable, bounded updates over ensembles of cores.

CODE SUMMARY: RPUClassicLite applies the core update rule directly, using a bounded nonlinear activation to enforce convergent, contraction-driven dynamics consistent with Section 2.2 of the RPU white paper. RPUQuantumLite extends this with the exploration term, tracking the best-observed state across iterations as the ensemble descends toward lower-energy configurations, consistent with Section 3.2. As with all LITE artifacts, this demonstrates the update cycle's qualitative behavior — not the specific operator form used in the underlying architecture.

HEGLite + RSLite Security Demo

Turns raw text into a CAP (act, targets, emotion, pattern, content), runs it through a HEGLite firewall, then feeds it into an RSLite risk substrate. Shows how human expression can be classified, constrained, and routed before RS makes a security decision.

CODE SUMMARY: heg_to_cap classifies act/targets/emotion/pattern; heg_security_policy flags risky CAPs; RSState applies contractive updates accumulating risk. Returns HEG findings, RS trajectory, and a final decision (ALLOWED / QUARANTINED / REJECTED).

POPLite v1 — Processor Optimizing Protocol

A reasoning-based optimizer for laptops and desktops that reads CPU, GPU, memory, thermals, and battery, then selects between plans (BALANCED, PERFORMANCE, ECO, LATENCY_PRIORITY). Demonstrates RS-style planning and collapse for system responsiveness without kernel internals.

CODE SUMMARY: Periodically calls read_state, runs forward model F_lite to smooth metrics, generates fixed plans, scores via cost functions, uses collapse_lite with hysteresis to avoid thrashing. safety_ok_lite enforces thermal/memory/battery safety before any plan is applied.

RS Universal Compiler LITE (Single-File Python)

A full universal-compiler architecture in one Python file showing how RS can act as a compiler across Python, banking, telecom, networking, and hardware IR. Exposes the RS IR, grammar FSM, policies, modules, frontends, backends, and domain wrappers — without real substrate math.

CODE SUMMARY: OperatorType, RSNode, RSEdge, RSGraph, and OperatorGrammarFSM enforcing BOUNDARY → INVARIANT → OPERATOR_SELECTION → MAPPING → CONVERGENCE. Backends emit Python IR, hardware IR, and legacy envelope IR; frontends lower domain specs.

RSv2 Universal Compiler LITE (Stress + Pluggable Backends)

A minimal RSv2-style universal compiler that parses arbitrary strings or JSON into a tiny IR (op, args, raw) and routes them to pluggable backends (printer language, HPGL-like graphics, Rust-style calls). Shows RS normalizing messy inputs across multiple domains with one IR.

CODE SUMMARY: rs_parse_to_ir turns JSON with 'action' or plain text into {op, args, raw}. Backends implement pattern-matching emitters for print/move/draw/add/negate. A stress test loop feeds varied inputs through all backends and prints supported/unsupported mappings.

RSv2LITE MultiAgent SelfLearning Substrate

A multi-agent RSv2LITE substrate with planner, critic, and explainer agents sharing memory and a governor. Runs Limitation → Generation → Collapse → FixedPoint, logs audit traces, computes episode fitness, and adjusts thresholds via an Entropy Well — showing RSv2 self-tuning in a cleanroom setting.

CODE SUMMARY: LiteState, constraints, candidates, trace steps, and generic engines. LiteMultiAgentSystem orchestrates agents; LiteFitnessFunction computes efficiency/coherence/token cost; LiteEntropyWell updates scoring bias and governor thresholds.

RSv2LITE — SingleAgent / MultiAgent Toy

A simpler RSv2LITE substrate running Limitation → Generation → Collapse → FixedPoint over a window and shared memory, with a basic governor controlling modes (normal, cautious, strict). Demonstrates the RSv2 loop without self-improvement machinery.

CODE SUMMARY: LiteSubstrate owns its loop; LiteMultiAgentSystem wires planner/critic/explainer agents to shared memory and runs step_all to update each substrate given new user text and tags.

[ REQUEST LITE ACCESS ]

// 04 — IN DEVELOPMENT

In Development // Lab Machines

Full-scale systems, deep-architecture engines, and substrate-level frameworks. Not prototypes, not products, and not promises — active constructions, each representing a future layer of the cognitive stack.

Integrated Cortex

Universal Cognitive Machine

Behavioral Entropy Regimes

Agentic Reasoning System (ARS)

ARS Domain Engines

Synthetic Data Pipeline

Universal Robotics Substrate

Universal Simulation Substrate

Automation Substrate

ADMIRAL Node/Drone Coordination System

// 05 — WHITEPAPERS

Whitepapers

Foundational research and patent filings covering the RS, HEG, and RPU architectures.

AI Problems In the News

The Reasoning Substrate

The Reasoning Processing Unit

The Human Expression Gateway

From Criminology to Technology

Avoiding Skynet with Substrate Level AI Safety

// 06 — CONTACT US

Contact

This is a conceptual research lab — not a production system. All toys and demonstrations are self-contained simulations intended to expose architectural behavior.

For licensing inquiries, acquisition discussions, or LITE-grade module access:

⏐ EMAIL — matt@icpub.org

This site is non-production. All simulations are local and deterministic.
No data is collected. No network calls are made from any toy.