AETHER

Adaptive Embedded Thought & Hierarchical Energy Reasoner

AETHER is an experimental research project exploring a new foundational architecture for reasoning models. Its central goal is to bridge the gap between fast, intuitive neural processing and slower, deliberate symbolic-style reasoning inside a single neural system.

Instead of forcing a language model to "think" by emitting long chains of text, AETHER gives the model a dedicated latent-space reasoning module: a kind of embedded prefrontal cortex. The base language model remains responsible for perception, linguistic representation, and final response generation, while a recurrent Hierarchical Reasoning Model (HRM) performs complex logic directly inside the model's hidden states.

Core Philosophy: Thinking Without Speaking

Traditional large language models are autoregressive: every intermediate thought must become a token. This makes reasoning expensive, slow, and tightly coupled to natural language generation. It also exposes reasoning to the same failure modes as ordinary text prediction, including verbosity, drift, and hallucination.

AETHER changes the paradigm by decoupling internal computation from token generation.

• LLM backbone: Gemma 4 E4B acts as the perceptual and linguistic engine, handling language understanding and final response formatting.
• HRM layer: A specialized cognitive engine operates in hidden space between transformer layers, iterating over abstract vectors until a problem is resolved.
• Latent reasoning: The system can spend computation on internal thought without being forced to serialize every step into text.

The result is a model that can think more before speaking, without making reasoning proportional to output length.

Architectural Strategy

AETHER performs targeted architectural surgery on Gemma 4 E4B. The model is split at a semantically stable internal point, currently Layer 21, and a three-part reasoning module is inserted between the lower and upper transformer blocks.

Encoder Bridge

The encoder bridge compresses the LLM's high-dimensional hidden vectors into a dense reasoning manifold:

d_model = 2560 -> d_reason = 1024

Its job is to preserve the semantic content needed for downstream generation while transforming the representation into a space suitable for recurrent reasoning.

HRM Core

The HRM core is the latent cognitive engine.

• L-Module, or Executor: Runs fast recurrent loops that perform local logical updates.
• H-Module, or Planner: Runs a slower manager loop that maintains the global objective and coordinates reasoning depth.
• Iterative depth: Unlike fixed transformer layers, the HRM can loop for N internal steps depending on problem difficulty.

Decoder Bridge

The decoder bridge reconstructs the refined latent thought back into the LLM's native vector space:

d_reason = 1024 -> d_model = 2560

The remaining transformer layers then translate the resolved representation into natural language.

Execution Roadmap

The project is organized into three phases to prioritize stability before capability.

Phase 1: Latent Alignment, The Socket

Train the encoder and decoder bridges as a transparent connection between Gemma's Layer 21 and Layer 22. The objective is to route activations through the new module boundary with minimal degradation in linguistic quality.

Phase 2: Hierarchical Distillation, The Brain

Insert the HRM and train it using latent distillation. The model learns to move from a question's hidden state toward an answer's hidden state by simulating reasoning directly in latent space.

Phase 3: Reinforcement Learning, The Logic

Use Adaptive Computation Time (ACT), verifiers, and task rewards to train efficient internal reasoning. The model is rewarded for solving hard logic, math, code, and ARC-style problems using the minimum number of latent thought iterations.

Technical Innovation: Fixed-Point Gradient

A major hurdle for recurrent reasoning models is the exploding memory and gradient cost of backpropagating through many internal loops. AETHER explores the fixed-point gradient approach used in modern HRM-style systems.

Instead of backpropagating through every recurrent step, the model computes gradients at the steady state z* of the reasoning process:

$$\frac{d\mathcal{L}}{d\theta} = \frac{\partial \mathcal{L}}{\partial z^*} (I - \mathcal{J}_{f,z^*})^{-1} \frac{\partial f}{\partial \theta}$$

This allows the reasoning module to approximate very deep or even effectively unbounded iterative computation while keeping memory closer to the cost of a single layer.

Why This Matters for AGI Research

AETHER is based on the hypothesis that general reasoning requires test-time compute that is not bottlenecked by token generation. If a problem is harder, the model should be able to spend more internal energy before producing an answer.

By moving deliberate reasoning into latent space, AETHER aims to support models that do not merely predict the next token, but refine internal representations until the underlying logic of a problem is resolved.

Repository Layout

configs/       Experiment and model configuration files
data/          Local datasets and extracted activation data
notebooks/     Exploratory analysis and evaluation notebooks
scripts/       Training, extraction, and evaluation entry points
src/           Core AETHER implementation

Getting Started

This project uses uv for Python project management.

uv sync

Run scripts with:

uv run python scripts/01_extract_data.py

For cloud GPU training, see docs/azure-training.md.

The implementation is currently in early research scaffolding. The repository will evolve through the three roadmap phases as the bridge modules, HRM core, training loops, and evaluation harness are added.

Status

AETHER is experimental research software. The architecture, training objectives, and evaluation strategy are expected to change rapidly as the project develops.