Experiments & Results

1 · Architecture: AwareLiquid M1

The backbone is the MT-LNN (LTC network) — a continuous-time recurrent architecture whose hidden state evolves according to learnable time constants, rather than discrete layer stacking. M1 (M-Series flagship) layers three cognitive subsystems on top of this core:

• Competitive Global Workspace (GWT-B) — selective broadcast of attended information;
• Predictive World Model — forward prediction of the next latent state;
• Hebbian Plasticity — co-activation-based weight modulation;
• Predictive Coding — error-driven representation learning;
• Rhythm Modulation — oscillatory gating of information flow.

Built Architecture, all liquid core modules, and native inference server are implemented and live — this site's demo is driven by them. Technical details: Technical Paper (PDF).

2 · Live Demo: AwareLiquid O1 + M1

The demo offers two distinct models. M1 (the large, cognitive model) wraps a frozen TinyLlama-1.1B-Chat base with a trained residual liquid-core adapter — only a fraction of a percent of the weights are ours (GWT broadcast + EWC continual-learning layers), general language comes from the base. It handles Q&A in English and Chinese and carries persistent episodic memory — session recall tagged with typed cards (identity / preference / emotion / plan / relationship / health / detail). O1 (the small, edge model) is the opposite pole — 48M parameters trained end-to-end from scratch, no base model, the native liquid architecture for hardware / always-on inference, a pure research artifact for short English text continuation.

Built End-to-end pre-training + native serving. Target Larger, higher-quality model (see demo disclaimer).

Adapter Benchmark Results

The adapter PPL result shown here is retracted (see the note above — it measured LoRA, not the MT mechanism). The context-injection uplift is a prompt-template effect (identical with vs. without the adapter), and the needle-in-haystack retrieval test was re-run 2026-06-26 with the chat template (near-perfect within the base's 2048-token window). We keep the charts below for provenance, clearly labelled.

3 · Continual Learning & Anti-Forgetting

This is AwareLiquid's primary research direction — orthogonal to the frozen-weight paradigm of frontier LLMs. The question: can a model sequentially learn new domains without catastrophically forgetting prior ones?

Experimental Design

• Train and evaluate on domain A, then continue training on domain B, then re-evaluate A;
• Three arms: dense (standard baseline), liquid (MT-LNN backbone), consolidation (EWC mechanism);
• Statistical rigor: paired deltas per seed, SNR = |mean| / std, require all seeds to agree in direction, check "non-catastrophic" threshold.

EWC: Elastic Weight Consolidation

After training on domain A, anchor weights are snapshotted and diagonal Fisher information is estimated from pure CE gradients. During domain B training, a quadratic penalty λ/2 · Σ Fᵢ(θᵢ − θ_Aᵢ)² constrains weights important to A from drifting. This mechanism is architecture-agnostic.

Results (GPU, A = WikiText-103 → B = TinyStories)

3 seeds · 60.7M model · 1,200 steps per domain. Forgetting = PPL rise on domain A after B training (lower is better).

Paired statistics (consolidation − dense): −8,928.8 ± 2,155 · SNR 4.14 · 3/3 seeds. EWC reduces cross-domain forgetting by ~85% without sacrificing domain B learning.

Built EWC mechanism + three-arm experiment framework, fully reproducible (GitHub, experiments/continual_crossdomain_liquid.py).
Early Signal Effect is real, large, and consistent across all seeds (−85%, SNR 4.14) — first clear evidence of mechanism effectiveness.
Not Yet The absolute PPL on A after EWC (1,878) is still ~7.6× its pre-B value (245). Under a strict "≤5× degradation = usable" criterion, this still qualifies as catastrophic forgetting. Verdict: WEAK-TREND, not SUPPORTED.

4 · Hebbian Plasticity Ablation

The Hebbian co-activation term is one of the MT-LNN liquid core modules. To measure its actual contribution, we ran an isolated ablation: all other v2.0 liquid modules were disabled, only the Hebbian term was active, and hebbian_lr was swept across four values with 2 seeds × 150 steps each.

128d × 2L × 8H model · WikiText-103 · CPU · 593s runtime. Largest PPL change (+0.35) is within seed noise (std ≈ 7.3). Gradient contribution peaks at 8.5e-5 — negligible.

Early Signal At current scale, the Hebbian term is effectively inert. Next steps: raise hebbian_lr by 2–3 orders of magnitude or validate at larger model scale before drawing conclusions.

5 · Spatial Computing (Experimental)

Does MT-LNN's recurrent dynamics suit spatial representation and reasoning? This is a neuroscience-inspired experimental line (grid cells, place cells, path integration). Code is complete and runnable; validation status varies by component.

Implemented Modules

• Spatial encoding frontend: grid cell encoding, multi-scale grid modules, head direction cells, boundary distance cells, place cell codes with DoG center-surround patterns — mt_lnn/spatial.py;
• Location-indexed associative memory: Hebbian write + pattern completion read, zero trainable parameters — mt_lnn/spatial_memory.py;
• Causal spatial steering: detects trajectory ruptures and projects state back onto the legal subspace — mt_lnn/causal_steering.py;
• Spatial operators + reasoning scaffold: distance / bearing / reachability graphs, location-based routing — spatial_ops.py / spatial_reasoning.py.

Two Validated Toy Demos

Grid Cell Emergence: Not Yet Validated

MT-LNN and a GRU baseline are compared on a velocity → position path-integration task to check whether hexagonal grid cells emerge spontaneously (standard threshold: grid score > 0.3).

Built Trajectory generation, loss, and grid score autocorrelation analysis are all runnable.
Not Yet All runs to date have been CPU-scale smoke tests. Neither GRU nor MT-LNN has crossed the 0.3 grid-score threshold. Meaningful comparison requires serious GPU-scale training — no spatial advantage is claimed at this time.

Deployments · Measured Pilot Evidence

Three deployment directions with real measurements behind them — the same results the homepage references, with methodology. Each links to open code; boundaries are stated, not implied.

6 · System Benchmarks

Hardware efficiency measurements from reproducible CPU runs. Two key benchmarks: sparse resonance speed–fidelity trade-off, and streaming memory footprint comparison.

Sparse Resonance: Speed vs. Fidelity

MT-LNN uses multi-scale resonance frequencies across 5 time scales. Sparse top-k selection activates only the most relevant scales per token, trading a small divergence from dense logits for significant throughput gains.

Streaming Memory Footprint

The recurrent architecture enables a state-only streaming mode that discards historical KV cache after each step, maintaining a constant-size carried state regardless of context length — vs. the O(n) growth of standard KV-cache streaming. On the 832×12 decode benchmark the carried state is 0.381 MB, flat from 512 to 1M tokens (a matched KV-cache reaches 3,072 MB); an earlier, smaller operator-compression config measured 4 KB — the constant is a property of the recurrence, its size a property of the model. Boundary: these are inference carried-state bytes only, not evidence of model quality beyond the 512-token training length — out-of-window LM results are null (see RESULTS.md).

Long-Context Capability (Matched Size)

On Selective Copy — a whole-sequence recall task under heavy noise — MT-LNN leads at every sequence length at matched 200K parameters under a fair full-sequence decode: 0.883 vs 0.672 at T=37, widening to ×2.0 at T=229 (0.219 vs 0.109). The edge is specifically all-or-nothing recall, not average per-token accuracy.

Length Curriculum on the Native 126M — ×8 Extrapolation, Two Runs Consistent

The native 126M MT-LNN (d=832, 12 layers) trained with a staged length curriculum (512 → 1024 → 2048 → 4096 tokens; 8192 under AMP). After each stage, extrapolation probes at ×2/×4/×8 the trained length: probe loss at 8× context stays in the 1× context range — at 2K training, 559 (8× → 16K) vs 587 (1×); at 4K training, 414 (4× → 16K) vs 424 (1×) — no explosion. The same regularity reproduces across two independent runs (fp32 and AMP).

Numerical-precision lesson: AMP (bf16) degrades MT-LNN training loss 3–7.5× at equal stage — the exp/tanh closed-form LTC recurrence and parallel scan are numerically sensitive in bf16. Long-sequence MT-LNN training therefore runs in fp32 with gradient checkpointing, not AMP. Current boundary: 32K+ probes still OOM (explicit attention bias B×H×T²) — the next step is chunked attention.

Selective-Decay Parameterization — Extrapolation Decided by exp vs tanh

Length extrapolation on parity is decided by the transition parameterization. The exp form (λ_t = 2·exp(−softplus(·)/τ) − 1, which reaches ±1 exactly) extrapolates at 0.956 (3 seeds: 0.869 / 1.000 / 1.000); the saturating tanh form collapses to 0.034. Derivation and recipe: ABLATIONS.md (E5d/E5e).

Positioning: Long-Context + Edge Cost, Not AGI Indices

Honest framing: our models (48M–1.1B) score near random on AGI-class benchmarks (MMLU, Agent suites) — those are designed for 50+-point models. We do not compete there. We compete on long-context capability at edge cost: the same-size recall advantage above, plus O(1) carried state (0.381 MB vs 3,072 MB at 1M tokens) — putting per-task cost 2–3 orders of magnitude below cloud APIs.

Physics Written Into the Architecture — AwareLiquid-Physic

A sibling line: a liquid (LTC) substrate reads a trajectory prefix and conditions a hard-constraint Hamiltonian head (separable H(q,p) = T(p) + V(q|ctx), advanced by a symplectic velocity-Verlet integrator). Energy is conserved by construction — not bolted on as a loss term. The model adapts its energy landscape per trajectory via the liquid context, so one fixed potential fits an entire family of systems.

Measured (all PRD targets met, project closed): semigroup training lifts the liquid advantage to 66% (mean of 7 configs, 32.6%–85.6%), few-shot adaptation 3.24×, conservation verified on six systems, N-body / non-separable / probabilistic / time-conditioned heads implemented, 43/43 tests. Scope: continuous-state trajectory prediction scored on physics metrics — never perplexity; not a language model. Repo: github.com/AwareLiquid/AwareLiquid-Physic.

7 · Architecture Landscape Survey (Aug 2026)

We periodically survey the sub-quadratic architecture literature and check our own trajectory against it. This is the August 2026 pass — the honest findings that changed our training recipe.

What the liquid-architecture field itself concluded

• LFM2 (Liquid AI, 2025–2026) — the liquid-network origin team's production models use gated short convolutions + a minority of grouped-query attention blocks, not liquid recurrences as the language backbone. Their hardware-in-the-loop search found that, under on-device budgets, most of the gains attributed to SSM/linear-attention hybrids are captured by short convolutions plus a few global-attention layers. Quality comes from 10–12T tokens, distillation, and curriculum learning.
• LrcSSM (NeurIPS 2025) — diagonalizing the liquid Jacobian by design gives exact parallel prefix-scans with a formal gradient-stability guarantee; validated on long-horizon sequence tasks.
• HOLA (2026) — a fixed delta-rule state plus a surprise-selected exact KV cache reaches lower Wikitext perplexity than a full-attention Transformer++ at 340M (−15%). This is external evidence for the hybrid "compressed state + exact recall" design family we build in.

What we changed as a result (training recipe, five items)

• Distillation-first for the 2B line — Gemma 2's controlled study: a 2B student distilled from a larger teacher scores 67.7 vs 60.3 from scratch at 500B tokens. Our 2B now trains with teacher logits, not raw next-token.
• One to two epochs, never multi-epoch repetition — recent scaling-law work (2026) shows internal data repetition is systematically damaging; rephrasing the same corpus (SYNPRO: 5.2× effective tokens) beats re-reading it.
• Weight decay λ = 1.0 — data-constrained prescriptive scaling laws: strong weight decay cuts the overfitting coefficient ~70%.
• Decay path forced to fp32 — PyTorch's autocast marks softplus/exp as bf16-unstable; our liquid decay computation now runs fp32 under mixed precision (measured: bf16 training degraded PPL 3–7.5×, forward-only divergence was 0.37% — the damage is in training dynamics).
• Curriculum learning — difficulty-ordered data, matching LFM2 and our own length-curriculum results (×8 extrapolation stable to 16K).

Survey references: LFM2 technical report (arXiv 2511.23404), LrcSSM (arXiv 2505.21717), HOLA (arXiv 2607.02303), Gemma 2 (arXiv 2408.00118), Titans (arXiv 2501.00663), SYNPRO (arXiv 2605.17849), prescriptive scaling laws (arXiv 2605.01640), DroPE (arXiv 2512.12167).

8 · How to Reproduce

• All code, experiment scripts, and reproducible configs: github.com/AwareLiquid/M1
• Architecture and pre-training details: Technical Paper (PDF)
• Live demo: AwareLiquid Demo · Project overview: About

9 · Cite This Work

If you use this work or build on it, please cite as follows:

BibTeX

@misc{awareliquid2026,
  title        = {{AwareLiquid} {M1}: Bio-inspired Continual Learning with
                  Global Workspace, Sleep Consolidation, and {EWC}},
  author       = {{AwareLiquid Project}},
  year         = {2026},
  howpublished = {\url{https://awareliquid.ai}},
  note         = {M-Series cognitive engine. Open research prototype.
                  Code: \url{https://github.com/AwareLiquid/M1}}
}

APA

10 · Changelog

11 · FAQ

What is the difference between M1 and O1?

M1 (M-Series) is the cognitive slow-thinking engine — it layers GWT competitive broadcast, NREM sleep consolidation with SHY synaptic downscaling, and EWC continual learning on the LTC backbone. It targets episodic memory, agent cognition, and catastrophic forgetting research. O1 (O-Series) is the edge fast-thinking engine — pure continuous-time liquid ODE, constant 4 KB memory state regardless of context length, no KV-cache growth, targets CPU/edge deployment at millisecond latency. Both share the MT-LNN backbone; full cognitive module integration into O1 is in progress.

Is this production-ready?

The models are research-grade: O1 (48M) and M1 (adapter on TinyLlama-1.1B) demonstrate the architecture but are not general assistants, and the API has no SLA. What is deployment-ready today are the measured edge capabilities — O(1) constant memory, the 5 MB ONNX wake-word export, and the battery-stream robustness shown above. Production pilots for specific edge workloads are the natural next step; see Work With Us for evaluation.

How is this different from Liquid AI / LFM?

Liquid AI builds high-performance models using an SSM + linear attention + MoE hybrid for maximum inference efficiency — targeting industrial time-series, edge signal processing, and autonomous driving. AwareLiquid layers cognitive architecture (GWT awareness, sleep consolidation, EWC online learning) on top of the liquid backbone to study continual learning — can a model acquire new knowledge without erasing the old? Same academic lineage (MIT LNN), orthogonal research axes. AwareLiquid is not affiliated with Liquid AI, Inc.

What is catastrophic forgetting?

When a neural network trains sequentially on domain A then B, its performance on A collapses. In AwareLiquid M1 experiments: dense baseline degrades from 244.9 → 10,806.9 PPL (×44). EWC reduces this to 1,878 PPL (×7.6, an 85% reduction in the forgetting delta). The threshold for "usable" retention is ≤5× degradation — not yet achieved. This is reported as Early Signal, not a solved problem.

Can I use the model API?

Yes. The live demo server exposes /v1/completions/stream (SSE, O1), /adapter/v1/completions/stream (SSE, M1), and /v1/model (model metadata). See GitHub README for local setup. Research-grade — no rate limits, no SLAs.

What does the needle-in-haystack test actually show?

Scientific honesty — including correcting our own earlier mistake. We first reported "0% for both variants", but that turned out to be a harness artefact: the old script fed raw concatenated tokens to an instruct-tuned base without the chat template, which always scores 0.0. Re-tested on 2026-06-26 with the chat template and a faithful adapter rebuild, the real picture is: within TinyLlama-1.1B's 2048-token window, retrieval is near-perfect (base 0.867/1.000 at 1K/2K, adapter 1.000/1.000). At 4096 tokens both collapse to 0 because that exceeds the base's 2048 RoPE window — a base limit, not an adapter failure. The adapter is at parity with the base in-window; proving a retrieval uplift needs a larger-window base and more samples. Extending long-context retrieval remains a target for future work.

Why can this be thousands of times smaller than a big model — where is the evidence?

The O-series replaces the attention KV cache with a constant recurrent state: 0.381 MB regardless of context length. Measured across a 2048× context increase (512 → 1,048,576 tokens) with the state flat to the decimal: 1008× smaller at 128k, 8063× smaller at 1M (where the KV cache alone would be ~3 GB). The audit used the strongest opposing compression, not just fp16: the advantage survives 2-bit KV + GQA=8 (8567× at 1M). Honest bounds: this is the attention-free O-series only; it is inference carried-state, not training memory; and against sink+window eviction @2-bit it is never smaller — that trade is out-of-window retrieval (0.56 vs 0.000), not bytes.

What are the current advantages?

Two measured advantages, nothing else claimed. Capability: cross-window / cross-session associative recall 0.56 vs 0.000 — attention and LoRA are structurally zero here; the fast-weight state is the memory (remove it and recall collapses to 0.008). Snapshotting the state and restoring into a fresh process is bit-exact. Cost: O(1) inference memory (O-series), 5 MB ONNX wake-word export, CPU-only inference. The honest non-advantage: perplexity — at convergence MT-LNN reaches 88.93 vs a modern Transformer's 78.86 (11.3% worse). The architecture's case rests on memory and efficiency, not language-modeling quality.

What tests have been run?

The repository ships 967 tests, all green, plus the benchmark suite behind every claim on this page: 20K-step 3-seed fp32 convergence on WikiText-103; cross-window recall with fast-weight ablation; the O(1) sweep to 1M tokens; the KV-frontier audit against 2-bit + GQA=8 and every non-evicted configuration; needle-in-haystack (in-window 0.867–1.000, out-of-window 0 — a base RoPE limit, reported honestly); continual learning with EWC (forgetting ×44 → ×7.6, an 85% delta reduction); 10-seed event-stream benchmarks (pre-registered Δt-span verdict: NULL); battery-health, wake-word and long-document pilots. Every number links to open code and data — no hand-copied figures.

What are the use cases?

Edge & always-on: O-series streaming with constant memory, wake-word detection (5 MB ONNX), battery / sensor health from irregular streams. Memory-centric: the M-series adapter's cross-session recall for conversational products. Documents: long-document QA over frozen API bases — and the Data Cleaning service that turns scanned archives into structured data. What it is not: a general assistant or a frontier-model replacement — the honest positioning is memory and edge cost.

How does it link with Awareness — and what is the principle?

"Awareness" here is not a separate model — it is the salience / global-workspace ignition inside the architecture. The fast liquid core streams continuously with O(1) state; a zero-parameter SalienceEventDetector watches the normalized prediction error with an adaptive baseline, and when surprise crosses a hysteresis threshold it fires an ignition — the workspace's wake-up tripwire. That ignition wakes the slow layer (DeliberationRouter: entropy three-way decision + causal-consistency floor). On a factual blind spot the router queries the Awareness Cloud (external memory oracle) and re-injects the fact into the local loop; otherwise it answers locally — the slow layer is paid for only when a real state change earns it.

What is Awareness "public knowledge" — and how does it replace RAG?

Public knowledge is the KaaS (knowledge-as-a-service) layer of the Awareness platform: a curated public-domain knowledge base seeded from the OpenAlex academic corpus (CC0), DOI-deduplicated, entity-extracted with zero LLM calls, embedding-indexed, and — the auditable part — its state root is anchored on-chain via ERC-8350 (Sepolia), so every transition of the knowledge state has a verifiable record. Retrieval is pay-per-query. On replacing RAG, the honest formulation is: it replaces the four fragile parts of a RAG pipeline, not the generate-over-documents paradigm itself. Retrieval: zero-LLM hybrid search (BM25 + vector RRF) at 96.0% R@5 on LongMemEval — no LLM reranker. Context assembly: progressive disclosure plus sibling-chunk reassembly (3.9× token lift) and Context Pack v2 (Facts + Evidence + Open Questions) instead of stuffing raw chunks. Knowledge lifecycle: 13 structured card types with 5-way conflict detection (new / update / duplicate / contradiction / irrelevant) — RAG retrieves text as-is and never reconciles it. Persistence & audit: cross-session MCP memory plus on-chain anchoring — a plain RAG index has neither. In the M1 linkage, this is the knowledge layer the DeliberationRouter reaches through cloud_client when the local model hits a factual blind spot.

Work With Us

The measured advantages map to concrete workloads: battery & sensor health monitoring (irregular streams, edge hardware), always-on audio (wake-word, keyword spotting), and long-document question answering (frozen API bases). If your team operates in one of these, or needs edge inference with continual learning:

• Try the live demo — both models, no setup;
• GitHub Discussions — technical questions, public and on-record;
• Pilot evaluations and integration — reach out via GitHub; we scope from the open benchmarks above, not from marketing claims.