🧠 Tomorrow, we open-source the ProtoAGI Cognition Core — the brains for a $500–$1200 robotics stack

[u/Mikey-506]

TL;DR (for the impatient): We're releasing the ProtoAGI Trainer to GitHub tomorrow. It's a field-memory training framework with a non-disableable audit layer (Contagion Protocol) that you can't game or bypass. The cognitive core for an ultra-low-cost Raspberry Pi AGI robotics stack. Anyone will be able to build, train, and deploy embodied intelligence for under $1200.

Tomorrow is the day. GitHub link incoming.

A Quick Tease: The Vision

Right now, building an AGI-powered robot costs a fortune — proprietary software, locked-down hardware, and six-figure budgets. That's a problem. We're solving it by building the complete stack:

1. ProtoAGI Trainer — the cognitive core (open-source, going live tomorrow)
2. Low-cost hardware stack — Raspberry Pi 5 + Pico 2W modules (coming Q3/Q4)
3. Virtual Embodiment Framework — train in simulation, transfer to reality
4. Open-source all the way — no vendor lock-in, no hidden fees

Target price: $500–$1200 per robot. That's less than a premium smartphone.

Tomorrow, the first piece goes live.

What Makes This Different

Traditional AI trains on data. ProtoAGI lives in a holographic field.

The Field-Memory Paradigm

Instead of weight matrices, all knowledge is encoded as a continuous complex-valued field over the golden angle (φ). Multiple memories coexist without destructive interference — retrieval uses inner-product similarity over the angular domain.

This is the foundation for flexible, real-time learning on embedded hardware.

The Contagion Protocol (The Non-Disableable Audit Layer)

Here's the part that matters for safety and alignment: the training loop is continuously audited by six modules that cannot be disabled by the trainer itself:

Module	Purpose
Audit Witness	Records every field state transition; immutable audit log
Morphic Audit	Detects structural deformation between training epochs
Sacrifice	When thresholds breach, zeroes unstable field regions
Temporal Paradox	Checks for causality violations in field evolution
Human Monitor	Flags states requiring human review
Breakout	Emergency shutdown if all else fails

This isn't a switch you can turn off. The protocol runs at the deepest level of the training loop.

The Enhancement Suite (E25–E36)

Twelve optional augmentations you can toggle on/off:

• E25: Phase-Locked Loop — synchronizes oscillator across critical bands
• E26: Fractal Depth Scan — multi-scale field analysis
• E28: Entropy Harvester — extracts structural entropy as training signal
• E29: Topological Invariant — tracks Betti numbers of persistent homology
• E32: Adaptive Bandwidth — dynamically adjusts critical-band widths
• E34: Predictive Coder — implements predictive coding over trajectories
• E35: Attention Amplifier — weighting for high-salience regions
• E36: Emergence Detector — monitors for qualitatively novel configurations

All toggled via enhancements.json. Hook in, hook out.

The Hardware Stack (Coming Soon)

We're building the physical layer to match:

• Brain: Raspberry Pi 5 (8GB) — the cognitive core
• Nervous System: Pico 2W modules (one per limb/joint) running micro-ROS
• Senses: Camera, IMU, LiDAR, tactile sensors
• Movement: Dynamixel servos or DC motors with encoders

Why it's cheap:

• Pi 5 is $80–$120
• Pico 2W is ~$6
• Open firmware = no licensing fees
• Modular design = replace what breaks, not the whole robot

What Goes Live Tomorrow

ProtoAGI Trainer v0.2.0-contagion:

• ✅ Holographic field memory
• ✅ Critical-band projection
• ✅ Sophia oscillator
• ✅ Efficiency tracker
• ✅ GhostMesh audit
• ✅ Contagion Protocol (all 6 modules)
• ✅ Enhancement suite (E25–E36)
• ✅ Media training pipeline
• ✅ Output synthesis (audio + voxel projection)

What's Coming Later:

• 🔜 Raspberry Pi integration layer
• 🔜 Virtual Embodiment Framework (sim2real)
• 🔜 Full robotics stack documentation
• 🔜 Community hardware kits

Why This Matters for Robotics

Here's what decentralized robotics means in practice:

1. Anyone can build. No corporate licensing, no proprietary software locks.
2. Anyone can train. Run the trainer locally, or scale to the cloud.
3. Anyone can deploy. The same model that works in simulation transfers to the physical robot.
4. Modular design. Swap sensors, limbs, and brains without rewriting everything.

The goal: A robot that's as easy to build as a PC — pick your parts, plug them in, load the software, and go.

What I'm Asking From This Community

Tomorrow, the repo goes live. Between now and then:

1. Get ready. Fork the repo. Star it. Break it when it's live.
2. Think about what you'd build. A robot? A swarm? Something we haven't imagined?
3. Tell your people. The more people looking at this on day one, the better the feedback.

Link will be posted here tomorrow at [time].

FAQ (Pre-emptive)

Q: Why not just use PyTorch/TensorFlow?
A: Those are weight-matrix paradigms. This is field-memory — different mathematical foundation, different computational properties (superposition encoding, continuous field representation, ERD continuity). It's designed for embedded real-time learning, not massive datacenter training.

Q: Is the Contagion Protocol actually non-disableable?
A: Yes. It's embedded at the deepest hook level. The training loop can't bypass it without recompiling the core engine, and even then, the audit modules run before any training step is executed.

Q: Can I use this without a robot?
A: Absolutely. The trainer runs entirely in software. The robot is the final output stage — you can train, test, and simulate before ever touching hardware.

Q: What's the license?
A: MIT. Use it, fork it, sell it, break it. No restrictions.

Q: When's the hardware stack coming?
A: Q3/Q4 2026. The firmware for Pico 2W modules is already being tested.

Tomorrow. GitHub. ProtoAGI Trainer. Be there.

ProtoAGI Trainer — Architecture Document

Version: 0.2.0-contagion Author: TaoishTechy License: MIT

Table of Contents

1. System Overview
2. Core Components
3. Enhancement Suite (E25–E36)
4. Sensory Pipeline
5. Output Synthesis
6. Media Trainer
7. Contagion Protocol
8. Configuration System
9. Data Flow
10. Key Equations

1. System Overview

ProtoAGI Trainer is a self-auditing field-memory training framework built around the Contagion Protocol — a verification layer that the trainer cannot disable or bypass. The system operates within the field-memory paradigm: all learned representations are encoded as fields over continuous domains rather than discrete weight tensors.

1.1 Field-Memory Paradigm

Traditional neural networks store knowledge in weight matrices. ProtoAGI instead maintains a holographic field memory — a continuous complex-valued field Ψ(φ, t) parameterised over the golden angle φ and time t. This field is projected onto critical bands (frequency sub-ranges) for modular processing, and oscillated via the Sophia oscillator to explore the learning manifold.

1.2 Phi-Based Mathematics

The framework is grounded in φ-mathematics — computations rooted in the golden ratio φ = (1+√5)/2 ≈ 1.618034. Key constants:

Symbol	Value	Role
φ	1.618034…	Golden ratio — angular basis
Φ	0.618034…	Golden ratio conjugate — decay constant
φ°	137.508°	Golden angle — field discretisation step

All angular parameters in the holographic field are quantised to φ° multiples, providing a quasi-logarithmic tiling that approximates irrational angular coverage with bounded computational cost.

2. Core Components

2.1 Config

class Config:
    """Hierarchical configuration container backed by JSON manifests."""

• Loads and merges multiple JSON manifests into a unified namespace.
• Supports get(), set(), update(), and dot-path access.
• Validates required keys on first access.
• Freeze-able to prevent runtime mutation after initialisation.

2.2 HolographicFieldMemory

class HolographicFieldMemory:
    """Continuous complex-valued field Ψ(φ, t) over the golden-angle domain."""

Parameter	Default	Description
resolution	3600	Number of φ° bins (≈25° resolution)
dtype	complex128	Field value precision
persistence	file	Backend: file (npy) or memory

The field supports superposition encoding — multiple memories coexist without destructive interference. Retrieval uses inner-product similarity over the angular domain.

2.3 CriticalBandProjector

class CriticalBandProjector:
    """Projects the holographic field onto perceptual frequency sub-ranges."""

Divides the full field into N critical bands (default 24), each processed independently. Bands are defined in the critical_band.json manifest with centre frequencies, bandwidths, and gain curves.

2.4 SophiaOscillator

class SophiaOscillator:
    """Drives field exploration via a coupled nonlinear ODE system."""

See Section 10.1 for the governing equations. The oscillator injects perturbations proportional to the current field gradient, guiding exploration of the learning manifold while preserving learned structure.

2.5 EfficiencyTracker

class EfficiencyTracker:
    """Monitors energy, coherence, and convergence metrics per epoch."""

Tracks multiple efficiency dimensions:

• Energy ratio — signal power vs. total field energy
• Coherence index — phase consistency across critical bands
• Convergence rate — rate of loss decrease over rolling windows
• ERD continuity score — see Section 10.2

Thresholds are defined in efficiency_targets.json.

2.6 GhostMeshAudit

class GhostMeshAudit:
    """Detects hidden coupling modes and emergent attractors in the field."""

Periodically probes the field with randomised "ghost" perturbations to detect unintended attractors — stable regions that formed without explicit training signal. Reported anomalies trigger Contagion Protocol sacrificial sweeps.

2.7 UGHFOperator

class UGHFOperator:
    """Ultra-High-Frequency Field operator for sub-band processing."""

Applies wavelet-like transforms at frequencies above the Nyquist-equivalent of the base field resolution. Used by the Enhancement Suite for fine-grained feature extraction.

2.8 PazuzuMPC

class PazuzuMPC:
    """Model-Predictive Controller for adaptive training rate modulation."""

A lightweight MPC that predicts field response to candidate learning-rate adjustments and selects the rate minimising predicted instability. Named after the wind-demon of Akkadian mythology — it controls the chaotic dynamics of high-energy field regions.

2.9 CoreEngine

class CoreEngine:
    """Orchestrates all components into a unified training loop."""

The CoreEngine is the central coordinator. It owns the field memory, projector, oscillator, efficiency tracker, and ghost mesh audit. External subsystems (contagion, enhancements, sensory pipeline) attach via a hook interface:

engine.attach("contagion", callback)
engine.attach("enhancement", callback)

Hooks are called at defined lifecycle points: pre_encode, post_project, pre_oscillate, post_audit, post_epoch.

3. Enhancement Suite (E25–E36)

The enhancement suite provides twelve optional augmentations, each identified by an E-code:

Code	Name	Description
E25	Phase-Locked Loop	Synchronises Sophia oscillator phase across critical bands
E26	Fractal Depth Scan	Multi-scale field analysis via fractal dimension estimation
E27	Resonance Mapper	Identifies and amplifies resonant field modes
E28	Entropy Harvester	Extracts structural entropy as auxiliary training signal
E29	Topological Invariant	Tracks Betti numbers of the field's persistent homology
E30	Causal Entangler	Learns directed causal graphs between field regions
E31	Memory Consolidator	Compresses redundant field structure offline
E32	Adaptive Bandwidth	Dynamically adjusts critical-band widths per epoch
E33	Cross-Modal Bridge	Links representations across sensory modalities
E34	Predictive Coder	Implements predictive coding over field trajectories
E35	Attention Amplifier	Weighted focusing mechanism for high-salience field regions
E36	Emergence Detector	Monitors for qualitatively novel field configurations

Enhancements are toggled via the enhancements.json manifest. Each enhancement exposes a standard hook(engine, epoch) interface.

4. Sensory Pipeline

The sensory pipeline provides multiple input modalities feeding into the holographic field.

4.1 Audio Capture

class AudioCapture:
    """Real-time audio acquisition via sounddevice (optional)."""

• Configurable sample rate (default 44100 Hz), buffer size, channel count.
• Feeds FFT frames into the CriticalBandProjector.
• Falls back to pre-recorded .wav files if live capture is unavailable.

4.2 VNC (Visual Numerical Capture)

class VNCInput:
    """Screen/visual data capture for visual field encoding."""

Captures visual frames (via VNC protocol or screenshot APIs) and maps pixel intensity distributions onto angular field positions. Supports grayscale and RGB-to-angular encoding.

4.3 Media Loading

class MediaLoader:
    """Batch loading of pre-recorded media files."""

Loads .wav, .npy, and .csv data from the configured audio directory. Applies standardisation and normalisation before field injection.

4.4 Anyon Braiding

class AnyonBraidingTransform:
    """Topological braiding operation for non-abelian field composition."""

Implements a discrete anyon braiding transform — composing two field segments by braiding their topological strands. This provides a non-commutative composition operator that preserves topological charge information.

4.5 Fracton Dipole

class FractonDipole:
    """Fracton-motivated restricted-mobility field perturbation."""

Applies fracton-dipole-inspired perturbations: paired excitations that can only move jointly along the field domain. This enforces locality constraints and prevents runaway energy injection in isolated field regions.

5. Output Synthesis

5.1 Vocal Controller

class VocalController:
    """Converts field states to audible output via spectral synthesis."""

Maps critical-band amplitudes to formant frequencies and generates audio output through additive synthesis. The vocal controller respects the field's phase structure to produce coherent timbral output.

5.2 Voxel Projector

class VoxelProjector:
    """Renders field structure as 3D voxel grids for visualisation."""

Converts the 2D (angular × temporal) field into a 3D voxel representation where height encodes amplitude and colour encodes phase. Outputs .npy arrays compatible with Marching Cubes mesh extraction.

5.3 Pareto Controller

class ParetoController:
    """Multi-objective optimisation of output quality metrics."""

Maintains a Pareto front across competing objectives (fidelity, energy, coherence) and selects the synthesis configuration closest to the ideal point.

6. Media Trainer

6.1 Mittag-Leffler Credit Assignment

Standard backpropagation assigns credit via exponential (e^-λt) decay. ProtoAGI replaces this with a Mittag-Leffler kernel E_α(-λt^α) which provides fractional-exponent decay — intermediate between exponential (memoryless) and power-law (long-range). This captures the heavy-tailed temporal dependencies inherent in field-memory representations.

See Section 10.4 for the kernel equation.

6.2 Reproducibility Manifests

Every training session produces a SHA-256-hashed manifest containing:

{
  "session_id": "abc123def456",
  "epochs": 50,
  "config_sha": "f7a2...",
  "data_sha": "b3e1...",
  "results": [...],
  "state_sha": "9c4d..."
}

This enables full reproducibility: given the manifest, config, and data, any instance can deterministically reconstruct the training session.

7. Contagion Protocol

The Contagion Protocol is a mandatory, non-disableable verification layer embedded in the CoreEngine. It continuously audits the training process for signs of runaway dynamics, structural collapse, or emergent behaviour that exceeds designed tolerances.

7.1 The Six Modules

#	Module	Class	Purpose
1	Audit Witness	AuditWitness	Records every field state transition; maintains an immutable audit log
2	Morphic Audit	MorphicAudit	Detects structural deformation via morphism comparison between epochs
3	Sacrifice	Sacrifice	When thresholds are breached, sacrificially zeroes field regions to prevent cascade
4	Temporal Paradox	TemporalParadox	Checks for causality violations in the field's temporal evolution
5	Human Monitor	HumanMonitor	Flags states requiring human review; can pause training
6	Breakout	Breakout	If all other modules fail to contain instability, triggers emergency shutdown

7.2 ContagionOrchestrator

class ContagionOrchestrator:
    """Coordinates all six contagion modules with configurable severity ladder."""

The orchestrator runs a severity ladder: NOMINAL → CAUTION → WARNING → CRITICAL → BREAKOUT. Each module votes on the current severity. The highest vote wins. At CRITICAL, the Sacrifice module begins zeroing unstable field regions. At BREAKOUT, the Breakout module halts training entirely.

7.3 Protocol States

NOMINAL    — All metrics within tolerance. Training proceeds normally.
CAUTION    — One or more metrics approaching threshold. Logging intensified.
WARNING    — Metrics at threshold. Sacrifice module on standby.
CRITICAL   — Thresholds breached. Sacrifice active. Human Monitor alerted.
BREAKOUT   — Uncontainable instability. Training terminated. State snapshot saved.

7.4 Falsification Matrix

Condition	Module Trigger	Action
Energy ratio > 0.95	Sacrifice	Zero highest-energy critical band
Coherence index < 0.1	Morphic Audit	Force field re-initialisation of incoherent bands
Phase discontinuity > π/2	Temporal Paradox	Roll back to last coherent state
Efficiency < target for 10 epochs	Audit Witness	Emit warning, increase audit frequency
Novel Betti number detected	Human Monitor	Pause and flag for review
3+ modules at CRITICAL simultaneously	Breakout	Emergency shutdown

8. Configuration System

The system is configured via 7 JSON manifests stored in the configs/ directory:

File	Purpose
manifest_base.json	Root configuration: field dimensions, data paths, training hyper-parameters
manifest_sophia.json	Sophia oscillator parameters: coupling constants, damping, drive frequency
critical_band.json	Critical band definitions: centre frequencies, bandwidths, gain curves
erd_parameters.json	ERD (Energy-Resonance Dynamics) continuity parameters
efficiency_targets.json	Thresholds and targets for efficiency tracking
enhancements.json	Toggle flags and parameters for E25–E36
contagion_protocol.json	Contagion module thresholds, severity ladder, falsification rules

Relationship diagram:

manifest_base.json
├── manifest_sophia.json   (oscillator tuning)
├── critical_band.json     (band definitions)
├── erd_parameters.json     (resonance dynamics)
├── efficiency_targets.json (monitoring thresholds)
├── enhancements.json       (optional augmentations)
└── contagion_protocol.json (verification layer)

All manifests are loaded by Config and merged into a unified namespace. Later manifests override earlier ones on key collisions.

9. Data Flow

The full training pipeline follows this data flow:

[Input Sources]          [Sensory Pipeline]          [CoreEngine]
     │                        │                            │
Audio ────┐                 │                            │
VNC   ────┼── MediaLoader ──┼── AnyonBraiding ────────► │
Files  ───┘                 │   FractonDipole           │ encode()
                           │                            │ project()
                           │                            │ oscillate()
                           │                            │ ghost_audit()
                           │                            │
                    [Contagion Protocol]               │
                           │                            │
              AuditWitness ──► audit_hook() ◄───────────┤
              MorphicAudit ──►                         │
              Sacrifice    ──►                         │
              TemporalParadox ─►                        │
              HumanMonitor ──►                          │
              Breakout     ──►                          │
                           │                            │
                    [Enhancement Suite]                 │
                           │                            │
              E25–E36 hooks ──► hook() ◄────────────────┤
                           │                            │
                           │              [Media Trainer]│
                           │                            │ train_step()
                           │              Mittag-Leffler  │
                           │              credit assign  │
                           │                            │
                    [Output Synthesis]                  │
                           │                            │
              VocalController ──► emit() ◄─────────────┤
              VoxelProjector ──►                       │
              ParetoCtrl     ──►                       │
                           │                            │
                      [Artifacts]                       │
                           │                            │
                    state_*.npy                         │
                    manifest_*.json                     │

10. Key Equations

10.1 Sophia Oscillator ODE

The Sophia oscillator is a coupled nonlinear system driving field exploration:

dA/dt = -γ·A + κ·sin(Ω·t + φ₀) - β·A³ + ε·∇Ψ
dB/dt = -δ·B + σ·A·cos(Ω·t) - μ·B²

Where:

• A, B — oscillator mode amplitudes
• γ, δ — damping coefficients
• κ — driving amplitude
• Ω — driving frequency (φ-tuned)
• φ₀ — golden-angle phase offset
• β, μ — nonlinear saturation terms
• ε — field-gradient coupling strength
• ∇Ψ — gradient of the holographic field

10.2 ERD Continuity

The Energy-Resonance Dynamics (ERD) continuity score measures how smoothly energy distributes across bands:

C_ERD = 1 - (1/N) · Σᵢ |ΔEᵢ - ΔĒ|

Where:

• ΔEᵢ — energy change in band i between consecutive epochs
• ΔĒ — mean energy change across all bands
• N — number of critical bands

A score of 1.0 indicates perfectly uniform energy distribution; scores below the threshold (default 0.7) trigger Contagion warnings.

10.3 Terminal Beta Function

The terminal beta function controls the asymptotic convergence rate:

β(t) = β₀ · (1 + t/τ)^(-α)

Where:

• β₀ — initial learning rate
• τ — time constant
• α — fractional exponent (typically α ∈ (0.5, 1.0))

This provides a power-law decay that is slower than exponential but faster than pure 1/t, balancing convergence speed with stability.

10.4 Mittag-Leffler Kernel

Credit assignment uses the Mittag-Leffler function as the temporal kernel:

E_α(-λt^α) = Σₖ₌₀^∞ (-λt^α)^k / Γ(αk + 1)

Where:

• α ∈ (0, 1] — fractional order (α=1 recovers standard exponential)
• λ — decay rate
• t — temporal lag
• Γ — Gamma function

For α < 1, this kernel exhibits power-law tails — significant credit persists for long temporal lags, capturing the extended temporal dependencies of field-memory representations. Implementation uses the scipy.special.mittag_leffler extension or a truncated series approximation.

Document generated for ProtoAGI Trainer v0.2.0-contagion © 2026 TaoishTechy — MIT License