Continual learning requires governing behaviour-changing writes, not just storing content
Type: kb/types/note.md · Tags: learning-theory, deploy-time-learning
Continual learning in a deployed system requires more than retaining new content. It requires governing durable changes to future behaviour: selecting a candidate update, validating it, and deciding how it enters the behaviour-determining system. This note uses the broad criterion from Learning is not only about generality: learning is any durable change in a system's capacity to adapt to its environment. Data infrastructure can persist, version, and retrieve content after it has been chosen, but persistence does not decide which retained item should shape behaviour or with what force. Behavioral authority — the force with which a consumed artifact determines what the system actually does — belongs to a consumption path, not to stored bytes. The same object is a knowledge artifact when consumed as evidence or advice, and a system-definition artifact when consumed to instruct, constrain, route, validate, or train. Persistence alone therefore does not create a governed behaviour-changing write.
An autonomous loop that must close during deployment adds two constraints. First, deployment evidence arrives online and is often sparse, so candidate writes must be cheap to propose and install; some lessons must take effect before a full retraining cycle. Retained system-definition artifacts provide one persistent deployment-time adaptation path. Second, candidate writes must be validated against regression, because continual adaptation compounds silent degradation (see Scheduler-LLM separation exploits an error-correction asymmetry).
A deployed system's writable surface may include three representational forms: distributed-parametric state such as weights and adapters, natural-language artifacts such as prompts and rules, and symbolic artifacts such as code, schemas, and tests. Parametric continual learning keeps its own plasticity-stability and catastrophic-forgetting problems — the tension between absorbing new lessons and preserving earlier capabilities; broadening the system boundary does not remove them. But if prompts, tools, validators, and runtime policy also determine behaviour, then an updater restricted to weights freezes consequential choices outside its reach. The forms differ in installation cost and verifiability, so a learning loop must decide which form a lesson belongs in and coordinate whichever forms that update touches. It need not touch all three every time. The broader trade space and coupling among their improvement loops belongs to representational-form coevolution.
The resulting problem is governance: autonomously choosing a behaviour-changing write, validating it against open-ended behaviour, assigning it an authority path, and coordinating it with other retained parts of the system. Form placement is itself revisable. A stable natural-language rule may be codified, while a brittle symbolic rule may be relaxed back into prose (codification and relaxing). Mature release engineering already governs hand-authored readable changes. Continual-learning systems must close the corresponding loop from deployment evidence at the cadence their environment requires. Storage, contextual activation, and parametric adaptation remain real subproblems; governance relates them rather than replacing them.
Relevant Notes:
- Learning is not only about generality — grounds: supplies the broad learning criterion under which non-weight changes count as learning
- Retained system-definition artifacts enable persistent deployment-time adaptation — extends: the install-during-deployment requirement — persistent behaviour change through retained artifact writes
- Scheduler-LLM separation exploits an error-correction asymmetry — grounds: why symbolic writes are cheaply validated and parametric ones are not — the validation requirement
- First-principles reasoning selects for explanatory-reach — grounds: the reach axis — why a governing theory must be explicit to generalise beyond its source cases
- Only explicit retention is durable, writable, and addressable — grounds: the addressability axis — the form-level trade space this note defers to
- Verifiability gradient — grounds: the verifiability axis across forms, from loose natural language to deterministic code
- Theory-mediated learning may improve sample efficiency under shifts — grounds: the sample-efficiency axis foregrounded by the sparse deployment loop
- Representational form — defines: the three forms this note ranges over and how form sets the default review method
- Treat continual learning as representational-form coevolution — extends: owns the general cross-form trade space and how the parametric, natural-language, and symbolic loops relate
- The deployed system, not the model alone, is the unit of learning — sharpens: the unit those cross-form writes range over is the whole deployed system, not the model alone
- Codification and relaxing navigate the bitter lesson boundary — extends: the write path by which a lesson moves between natural-language and symbolic form
- Knowledge storage does not imply contextual activation — grounds: storage and read-back do not imply activation, and activation of content is not governance
- Behavioral authority — grounds: the consumption-path distinction between informing content and governing writes
- Constraining during deployment is continual learning — exemplifies: versioned prompts, schemas, tools, and tests as one concrete system-definition loop
- LLM contexts interpret instructions and content through the same token medium — mechanism: lets readable artifacts function as instruction rather than only as data
- Trace-learning techniques in related systems — evidenced-by: surveyed systems already split into weight-promotion and artifact-promotion loops