RS / HEG / RPU TOY LAB // AMBER TERMINAL

// 01 — HOME

Reasoning Substrate Lab

The Reasoning Substrate is a deterministic reasoning architecture — a model-agnostic, language-agnostic state machine designed to structure state transitions, constraint handling, auditability, replayability, and deterministic execution workflows. It is built to integrate with existing architectures.

The problem it addresses. Reasoning and agent pipelines that are not deterministic are difficult to audit, replay, debug, and certify: the same input can take different paths, and a failure cannot always be reproduced. RS is an architecture for making execution state transitions deterministic, bounded, and inspectable.

This lab hosts simplified public demonstrations — self-contained, browser-runnable simulations of the RS, HEG, and RPU architectures in isolation. Each toy is a demonstration harness that makes one architectural idea visible and interactive. Nothing here is production code. Deterministic toys use fixed update rules; toys with randomness use fixed seeds. Identical inputs reproduce identical results in the same browser.

These toys demonstrate architectural properties, not benchmark performance.

Shows: deterministic replay, audit generation, bounded execution, state evolution, recovery behavior, and traceability.
Does not show: benchmark results, production readiness, model quality, or deployment scale.
These demonstrations do not attempt to prove the value of the architecture. They attempt to make the architecture inspectable.

Implementation status. The Reasoning Substrate and the HEG have mathematical formulations and reference implementation code, available for technical evaluation under NDA. The RPU has a mathematical model and implementation code; it has not been taped out to silicon. Toys marked illustrative use authored dynamics rather than the underlying implementation. The public demonstrations are controlled reductions of that implementation; proprietary mechanisms are withheld.

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 transforms 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, modeled around executing the Reasoning Substrate (RS) update cycle directly in silicon. RPU Classic is defined around contraction-based deterministic convergence, while RPU Quantum is defined around parallel, ensemble-based search with best-tracking across independently-converging cores; specific implementations vary in whether they add bounded exploration. Hardware implementations are future targets rather than existing products, and nothing here represents hardware performance results.

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 demonstrates the core execution dynamics 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 inspect substrate behavior directly, without learned models or external inference services. Every step depends only on (state, tick), enabling identical serialized trajectories across runs and recovery from interruption. Step sizes follow an authored linear decay that reaches zero at tick 300, so the fixed point is a designed property of this toy, not an emergent one. The 100× replay check spans the whole decay, through the fixed point (350 ticks per run). This is the public slice of the substrate: a demonstration of deterministic execution, replayability, auditability, and recovery behavior in a constrained environment.

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

Four featured tests — agent failsafe, full HEG→CAP→RS pipeline, RPU vs Unconstrained Baseline, 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 Unconstrained Baseline — Stability Harness

Three update rules on the same kind of input: an unconstrained baseline (a simple recurrent map with injected noise, authored for contrast), RPU-Classic (a contraction-based update, which converges to a fixed point by construction), and RPU-Quantum (an ensemble descent with best-state tracking). Canvas animations show live energy and state variance for each. Illustrative architectural behavior, not hardware performance results; the baseline is not a real transformer.

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 under four plan modes. Each plan has authored effects on the simulated state; the RS loop (forward model, score, collapse with hysteresis) selects the plan, so plan choice changes how the simulation evolves. Illustrative: the plan effects are authored, not measured hardware behavior.

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

The same hostile packet stream through three response rules: naive accumulation, a hard clamp with decay (RPU-Classic), and a clamp plus invariant and load shedding (RPU-Quantum). Authored comparison; illustrative architectural behavior.

RPU·02 RPU — Constraint Solver Harness

A 4×4 grid puzzle (all row and column sums must equal 2) solved by three engines. Classic applies greedy local improvement; Quantum adds random flips with best-tracking; the unconstrained baseline flips cells at random. Current and best-so-far violations are logged, and a 50-seed table compares the engines across random starts.

RPU·03 RPU — Constraint-to-Energy Compiler

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

RPU·04 RPU — Energy Landscape Explorer

A single reasoning state traverses a visualized energy surface. Classic follows gradient descent; Quantum runs an 8-core ensemble with best-tracking (no exploration noise).

RPU·05 RPU — Lattice Convergence Harness

8×8 grid of cells descends energy simultaneously (cells evolve independently in this toy). Color shows each cell from high-energy (red) to stable (green) for all three engines; mean energy is logged per step.

RPU·06 RPU — Multi-Agent Coordination Harness

Six agents navigate a shared space. All three engines receive identical starting positions and the identical mid-run goal change; distance-to-goal, motion and collisions are computed per tick, not asserted. Classic coordinates deterministically, Quantum adds seeded exploration noise.

RPU·07 RPU — Power & Thermal Budget Harness

Authored power and thermal curves for a GPU-style baseline versus an RPU-style energy descent. Bar charts show unitless curves.
*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. LITE artifacts preserve selected architectural structures while omitting proprietary mechanisms, optimization strategies, and substrate-level implementation details.

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 under the plan in force, generates fixed plans, scores via cost functions, collapses with hysteresis to avoid thrashing, then applies the chosen plan's authored effects to the simulated state. 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.

Reasoning Substrate White Paper

RPU White Paper v1.2

Human Expression Gateway White Paper

RS Agnostic Capability v1.1.2

AI Problems in the News v1.4

Road to AGI v1.0

Savings_Framework_v1.0

// 06 — CONTACT US

Contact

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

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

⏐ EMAIL — Contact Matthew Thornton

This site is non-production. All simulations are local and deterministic.
No data is transmitted. The hero stores its recovery trace locally in your browser. No network calls are made from any toy; the page’s content-security policy blocks them.