Treat continual learning as representational-form coevolution

Type: kb/types/note.md · Tags: learning-theory, deploy-time-learning

Continual learning's open problem is behaviour, not knowledge names two behaviour-change mechanisms: expensive weight updates and cheap readable system-definition artifacts. Deploy-time learning places the readable mechanism on the timing axis. Splitting retained behavior by representational form (how an operative part is encoded and consumed) gives three forms: distributed-parametric (weights, adapters, embeddings, learned controllers), Natural-language (prompts, notes, specs, rubrics), and symbolic (code, schemas, tests, tools). How should their improvement loops relate? They aren't independent: optimizing one assumes a position about the others.

Natural-language and symbolic cluster as the readable artifacts - inspectable, editable, distinct from distributed-parametric state in inspection method and update cost. The practical question of where to start building automated loops is the readable-artifact loop is the tractable unit for continual learning. This note is about the generic coevolution frame.

The mainstream direction: scaling the opaque loop

Computer vision provides the model. Before representation learning, features (SIFT, HOG) were hand-crafted and classifiers (SVMs) were learned — a clean separation that looked normal. Representation learning won by extending gradient descent across both, end-to-end. The general method didn't change; it covered more of the pipeline.

The bitter lesson extrapolates: general methods that leverage computation eat hand-crafted components — or more precisely, they eat the ones whose claimed scope was never earned, which is why tokenizers and test suites survive the same pressure that consumed SIFT. Applied today, mainstream research extends the opaque loop — RLHF, RLAIF, continual pretraining, online learning, fast adapters — hoping to subsume the hand-crafted prompts, tools, and evals that deployed systems depend on. This may or may not succeed; new architectures could close the tempo gap, or structural limits could keep large opaque updates on a slower cycle. This note takes no position on the outcome.

Loops today

Current methods range from single-form optimization to early cross-form loops:

  • DSPy, ProTeGi — automated search over prompts (natural-language), weights frozen.
  • Genetic programming, FunSearch — automated search over code (symbolic), weights frozen.
  • Meta-Harness — automated search over harness code and prompt/context logic (symbolic + natural-language), weights frozen, benchmark traces as selection signal.
  • Symbolic Learning — backward language-mediated credit assignment over prompts, tools, and pipeline topology (natural-language + symbolic), weights frozen, same prompted loss used for update and rollback.
  • Memento-Skills — deployment-time mutation of natural-language-plus-code skill folders around a frozen LLM, with a separately trained parametric router selecting the skill.
  • Co-Harness — alternating validated harness repair and model fine-tuning, provisionally spanning distributed-parametric weights plus a natural-language/symbolic harness.
  • RLHF / RLAIF — updates weights (opaque), treating prompts and code as fixed.
  • Hand curation (Commonplace and similar) — evolves natural-language fast and symbolic artifacts slowly, without automated search or weight updates.

The cross-form cases change the inventory, not the underlying difficulty. Symbolic Learning and Memento-Skills keep the main LLM fixed; Co-Harness spans all three forms but does not isolate coevolution from extra fine-tuning, improved trajectory data, or additional harness search. The open problem has moved from whether two or three forms can appear in one automated loop to whether cross-form credit assignment, compatibility, rollback, and validation can make the coupling reliably compound.

Difficulties

The three forms have very different dynamics:

  • Distributed-parametric updates via gradient descent or other numerical optimization. Needs differentiable or probe-derived signal and heavy training infrastructure; large updates cycle on days to weeks, though smaller add-on mechanisms can be faster.
  • Symbolic artifacts are mutated by LLMs or search, then evaluated by tests, execution, or formal checks.
  • Natural-language artifacts are mutated by LLMs and evaluated by execution, use, or LLM-as-judge. Semantics stay underspecified, so verification is softer.

A joint optimizer has to handle pace mismatch — either it runs at the slowest class's cadence, or classes coevolve asynchronously without diverging — and cross-class credit assignment: a deployment failure rarely says which class wants the update (prompt revision, tool extraction, memory promotion, weight update, retrieval change). Per-class methods sidestep both by fixing the class in advance.

Starting point

Coevolution is the right conceptual frame, but a three-way joint optimizer isn't the near-term plan. The readable-artifact loop is the tractable unit for continual learning argues for starting with the natural-language + symbolic pair, on the basis of structural couplings that make the two a natural joint target.

Relevant Notes: