I'm an undergrad with no research affiliation. I've been thinking about why LLM training is so expensive and why continuous learning remains unsolved. This post is where that thinking led — a concrete architecture proposal with a cheap falsifiable experiment at its core.
The Core Idea (30 seconds)
Catastrophic forgetting — when fine-tuning a model on new knowledge destroys old knowledge — is universally treated as a problem to minimize.
I think it's a measurement instrument.
The forgetting test: take two small specialist models trained on different domains. Run a short joint fine-tuning pass to put them in the same parameter space. Then train on domain A and measure degradation in domain B.
Low degradation → the domains share deep parametric structure → they should be one module
High degradation → the domains are parametrically independent → they should stay separate
No human ontology required. The signal itself reveals the intrinsic topology of knowledge.
Why This Matters: The Architecture It Enables
If forgetting is a probe, you can build a system that uses it to self-organize:
Atomic specialist modules — not "mathematics" as one model, but differential calculus, integral calculus, linear algebra as separate models. Each has its own isolated parameter space, trained independently, updatable without affecting others.
An Orchestrator — one model whose only job is routing: given a task, which modules to call, in what order. Trained purely on routing performance, not subject matter. Also responsible for evaluating output quality, scheduling retraining of weak modules, and spawning new modules when a domain isn't covered.
The forgetting test as the merge criterion — the system continuously runs pairwise tests on candidate module pairs. Modules that pass get merged. Modules that fail stay separate. Granularity emerges from the data, not from human taxonomy.
This is not MoE. In MoE, experts are trained jointly in a single run and share an optimization process. Here, modules are genuinely independent — separate training runs, separate parameter spaces, separate update cycles.
The Falsifiable Experiment
The entire proposal rests on one empirical bet:
Catastrophic forgetting magnitude between two domains predicts whether those domains share intrinsic parametric structure.
How to test it:
Train ~20 small models (3B params each) on narrow mathematical subdomains
For each candidate pair: run joint fine-tuning, then train on domain A, measure degradation in domain B
Build a topology graph from the degradation matrix
Compare to human intuitions about mathematical structure
Cost: ~100 H800-days. Cheap enough to run before committing to the full architecture.
If the forgetting-derived topology matches (or interestingly contradicts) human intuitions about knowledge structure, the probe is real. If it's noise, the approach needs fundamental revision.
What's Novel Here
Existing continual learning work: minimize forgetting.
This: use forgetting magnitude as a structured signal.
Existing modular LLM work: MoE variants, multi-agent systems with generalist agents.
This: genuinely independent atomic specialists with emergent boundaries.
Existing orchestration: route tasks to agents.
This: orchestrator also manages module lifecycle — retraining, spawning, retiring — based on forgetting test results.
The combination hasn't been done. Each piece exists in isolation. The forgetting-as-probe insight is what connects them.
Open Problems (Being Honest)
Orchestrator evaluation without ground truth: for open-ended tasks, how does the Orchestrator assess quality? Hypothesis: inter-module consistency as a proxy signal.
Module splitting: merged modules may need splitting as knowledge evolves. Detection mechanism unclear.
Safety under self-modification: addressed via a frozen "tuple layer" — architecturally inaccessible parameters encoding invariant constraints.
The Core Idea (30 seconds) Catastrophic forgetting — when fine-tuning a model on new knowledge destroys old knowledge — is universally treated as a problem to minimize. I think it's a measurement instrument. The forgetting test: take two small specialist models trained on different domains. Run a short joint fine-tuning pass to put them in the same parameter space. Then train on domain A and measure degradation in domain B.
Low degradation → the domains share deep parametric structure → they should be one module High degradation → the domains are parametrically independent → they should stay separate
No human ontology required. The signal itself reveals the intrinsic topology of knowledge.
Why This Matters: The Architecture It Enables If forgetting is a probe, you can build a system that uses it to self-organize: Atomic specialist modules — not "mathematics" as one model, but differential calculus, integral calculus, linear algebra as separate models. Each has its own isolated parameter space, trained independently, updatable without affecting others. An Orchestrator — one model whose only job is routing: given a task, which modules to call, in what order. Trained purely on routing performance, not subject matter. Also responsible for evaluating output quality, scheduling retraining of weak modules, and spawning new modules when a domain isn't covered. The forgetting test as the merge criterion — the system continuously runs pairwise tests on candidate module pairs. Modules that pass get merged. Modules that fail stay separate. Granularity emerges from the data, not from human taxonomy. This is not MoE. In MoE, experts are trained jointly in a single run and share an optimization process. Here, modules are genuinely independent — separate training runs, separate parameter spaces, separate update cycles.
The Falsifiable Experiment The entire proposal rests on one empirical bet:
Catastrophic forgetting magnitude between two domains predicts whether those domains share intrinsic parametric structure.
How to test it:
Train ~20 small models (3B params each) on narrow mathematical subdomains For each candidate pair: run joint fine-tuning, then train on domain A, measure degradation in domain B Build a topology graph from the degradation matrix Compare to human intuitions about mathematical structure
Cost: ~100 H800-days. Cheap enough to run before committing to the full architecture. If the forgetting-derived topology matches (or interestingly contradicts) human intuitions about knowledge structure, the probe is real. If it's noise, the approach needs fundamental revision.
What's Novel Here Existing continual learning work: minimize forgetting. This: use forgetting magnitude as a structured signal. Existing modular LLM work: MoE variants, multi-agent systems with generalist agents. This: genuinely independent atomic specialists with emergent boundaries. Existing orchestration: route tasks to agents. This: orchestrator also manages module lifecycle — retraining, spawning, retiring — based on forgetting test results. The combination hasn't been done. Each piece exists in isolation. The forgetting-as-probe insight is what connects them.
Open Problems (Being Honest)
Orchestrator evaluation without ground truth: for open-ended tasks, how does the Orchestrator assess quality? Hypothesis: inter-module consistency as a proxy signal. Module splitting: merged modules may need splitting as knowledge evolves. Detection mechanism unclear. Safety under self-modification: addressed via a frozen "tuple layer" — architecturally inaccessible parameters encoding invariant constraints.