Treat continual learning as representational-form coevolution

Type: types/note.md · Tags: learning-theory, self-improving-systems, continual-learning, artifact-analysis

Continual learning requires governing behaviour-changing writes, not just storing content argues that continual learning requires governing durable behaviour-changing writes — system-definition writes — beyond storing content, and that a deployed system's writable surface may include three representational forms (how an operative part is encoded and consumed): distributed-parametric (weights, adapters, embeddings, learned controllers), natural-language (prompts, notes, specs, rubrics), and symbolic (code, schemas, tests, tools). That note defers the general cross-form trade space to this one. Retained system-definition artifacts enable persistent deployment-time adaptation, so retained natural-language and symbolic artifacts already adapt durably during deployment. How should their improvement loops relate? They aren't independent: optimizing one assumes a position about the others.

Natural-language and symbolic content cluster as the localized forms: the consumer addresses units that can be revised separately. "Readable artifacts" is an informal alias, not a guarantee of affordable inspection. A prompt under a pinned model adopted as its reference is symbolic and can be opaque; adoption does not expose the instruction-level rule in the weights. The practical starting point is therefore the readable-artifact loop, scoped to artifacts whose behavior can be inspected and whose changes can be checked at acceptable cost. This note is about the generic coevolution frame.

A 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.

Wikipedia's secondary summary of the bitter lesson describes a long-run tendency for computationally scalable methods such as search and statistical learning to outperform approaches based on domain-specific understanding, and reports Sutton's recommendation to prefer simple scalable methods over increasingly elaborate human insight. One linked Commonplace analysis offers a narrower, case-level conjecture: pressure may consume a hand-crafted component whose claimed scope was never earned. It explicitly does not establish that mechanism as a broad historical tendency. This note uses it only as a possible explanation for why tokenizers and test suites might survive pressure that consumed SIFT. The next step is likewise this note's extrapolation, not the source's claim: it reads RLHF, RLAIF, continual pretraining, online learning, and fast adapters as a mainstream attempt to extend the opaque loop far enough 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. The labels below describe ordinary instruction interpretation and code execution paths; frozen weights alone do not mean that a system adopts the model as the governing reference for its prompts. Under a separately adopted reference, those prompts would instead be symbolic and potentially opaque. "Opaque loop" here is shorthand for instruction-level inspection difficulty in learned numerical state, not another form.

  • 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 — a prompted language loss produces textual gradients that guide updates to prompts, tools, and pipeline topology (natural-language + symbolic); re-evaluation with the language-based loss decides rollback, while model weights remain fixed.
  • Memento-Skills — deployment-time mutation of natural-language-plus-code skill folders around a frozen LLM, with a contrastive parametric router trained separately through single-step offline reinforcement learning.
  • Co-Harness — in a two-round experiment, validated repair of prompts, tool schemas, skills, middleware, and memory alternates with model fine-tuning on verified trajectories, 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 scripts and validators can be mutated by LLMs or search, then checked against their reference by reading, tests, execution, or formal analysis. Opaque symbolic artifacts, including prompts under adopted model references, may lack an affordable reading route; symbolic membership alone fixes neither inspection cost nor update tempo.
  • 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 readable natural-language artifacts plus readable scripts and validators, on the basis of their context coupling and bounded validation costs, not a readability guarantee attached to either form.

Relevant Notes: