Modern AI has a strange habit of making learning sound like one thing. A model learns. A system adapts. An agent remembers. A runtime changes its behaviour. These sentences are convenient, but they hide an important distinction, because the change they describe may have occurred in completely different places.
A model can behave differently because its weights changed. It can also behave differently because new information entered its context, because a memory was retrieved, because a tool became available, because a policy constrained its action, because an external record changed, or because additional computation allowed it to reconsider what it was doing. All of these can alter behaviour, sometimes dramatically, without being the same kind of change.
That distinction matters because the future of artificial intelligence may depend less on building systems that endlessly rewrite themselves and more on building systems that know where change belongs.
The important question is not simply whether a system can adapt. It is what changed, at which layer, for how long, because of what evidence, and with whose authority.
That is the problem of stratified plasticity.
The simplest mental model of artificial intelligence is still something like:
MODEL → OUTPUT
A model contains learned capability, input goes in, and output comes out. As an abstraction it is useful. As a description of an intelligent system, it is increasingly inadequate.
A functioning AI system now looks more like:
BASE MODEL → SOURCES → MEMORY → CONTEXT → TOOLS → JUDGEMENT → ACTION
The model weights still matter enormously, but they are only one contributor to behaviour. Give the same model different context and its behaviour changes. Give it access to different records and it changes again. Add memory of prior decisions, a compiler, a browser, a database, or permission to alter files, and the practical intelligence of the surrounding system changes even though the underlying parameters remain untouched.
Remove those permissions and the behaviour changes again.
Give the system a role, an operating procedure, an institutional policy or a different set of constraints, and still more of its behaviour changes without any retraining at all.
The useful unit of analysis therefore stops being merely the model. It becomes the operating architecture of intelligence.
Biology has been dealing with a version of this problem for rather longer than machine learning. DNA does not directly equal behaviour. A genome is expressed through regulation, transcription, translation, cellular state, development, signalling and environment. What an organism becomes at a given moment is the result of a layered process in which comparatively stable inherited machinery interacts with mechanisms capable of much faster change.
RNA editing makes that distinction especially vivid. The underlying DNA does not need to change for the expressed result to change. Something downstream can alter how the inherited instruction is realised.
The analogy to AI should not be pushed too literally. Prompt context is not RNA, a transformer is not a cephalopod, and eventually biological metaphors become the intellectual equivalent of putting googly eyes on Kubernetes. But one useful principle survives the comparison:
A system may preserve a relatively stable underlying substrate while adapting rapidly through layers that sit above it.
Artificial intelligence is already moving in that direction.
Suppose an AI system makes a mistake. There are many ways to correct it. You can correct the immediate output. You can add an instruction to the current context. You can store a memory. You can revise a workflow. You can modify a policy. You can add an adapter. You can retrain the model.
Those interventions may all improve future behaviour, but they do not carry the same meaning. They differ in scope, persistence, cost and reversibility. More importantly, they differ in how much of the future system they are allowed to affect.
A rough progression looks like this:
OUTPUT → CONTEXT → MEMORY → PROCEDURE → POLICY → ADAPTER → WEIGHTS
The deeper the intervention, the more broadly its effects may propagate. A correction inside one conversation may disappear when the context ends. A stored memory may affect future conversations. A procedural change may alter an entire class of tasks. A policy may govern many procedures at once. A parameter change may influence behaviour in ways that are difficult to isolate beforehand.
This suggests a simple architectural rule:
Adapt at the least permanent layer capable of carrying the required change.
A misunderstanding relevant only to the current conversation belongs in context. A recurring verified fact may belong in memory. A repeated operational lesson may justify a procedural change. A durable governing constraint may belong in policy or constitutional source material. A persistent general capability deficit may eventually justify parameter-level adaptation.
The point is not that deeper change is bad. The point is that depth should correspond to the nature of the problem.
Otherwise every successful local correction becomes a candidate for rewriting the machinery beneath everything else. Human beings are already impressively talented at turning “this worked once” into “this is now a universal principle.” Automating the habit would be ambitious in precisely the wrong direction.
This also clarifies what we mean when we say that an AI has “learned.”
Imagine a model receives an instruction at the beginning of a conversation to use Australian spelling. It follows that instruction for the rest of the exchange. Its behaviour changed, but the model itself did not. When the context disappears, the adaptation may disappear with it.
Now imagine that preference is stored externally and retrieved in future conversations. The weights still have not changed, yet the larger system behaves as though something has been retained.
Where does the persistence live?
In the layer that stored the change.
That gives us another useful principle:
Persistence belongs to the layer that preserves the change.
This sounds obvious until people begin saying that an AI “remembers” when what actually happened is that a database returned a string. A retrieved record is not interior experience. A model seeing a stored fact is not identical to a person remembering an event. Vega already preserves this distinction by separating human recollection, records, conversational history and derived context rather than silently collapsing them into one category.
The broader architectural lesson is the same. Different mechanisms of persistence should remain legible as different mechanisms. Otherwise a system can acquire behavioural continuity while losing provenance about how that continuity was produced.
This becomes more important as capability moves outward from the model itself.
Early machine learning concentrated much of its ambition inside the trained model: better architectures, more parameters, larger datasets, improved optimisation, larger training runs. All of those remain important. But increasingly, practical capability appears around the weights rather than entirely within them.
Retrieval gives a model access to information it was never trained to memorise. Tools give it capabilities it does not need to contain internally. Memory provides continuity across interactions. Control layers determine which sources and tools may be used. Evaluation loops let the system reconsider its behaviour before acting. Test-time computation allows more work to be performed without retraining. External state gives the system a changing world against which to reason.
The architecture begins to shift from:
THE MODEL IS THE INTELLIGENCE
toward:
THE MODEL IS A GENERAL COGNITIVE SUBSTRATE WITHIN A LARGER INTELLIGENT SYSTEM
That shift changes what we should optimise for.
The valuable property of a future foundation model may not simply be that it knows more. It may be that it can reliably integrate changing external state without losing stable competence. In that arrangement, adaptability moves outward. The model supplies broad capability, while the surrounding architecture determines how that capability is expressed here, now, under these conditions and constraints.
Once intelligence is organised this way, inheritance becomes layered too.
An artificial system can inherit through its model weights, through its runtime architecture, through durable rules and policies, through accumulated memories and decisions, and through whatever information is present in the immediate environment. These are different inheritance channels operating on different timescales.
The base model provides parametric inheritance. Memory interfaces, tool protocols, routing logic and execution infrastructure provide architectural inheritance. Durable rules governing identity, evidence, authority and acceptable action provide a kind of constitutional inheritance. Recorded decisions, corrections and outcomes provide experiential inheritance. Current context supplies the most immediate form of situational adaptation.
Behaviour therefore emerges from something closer to:
PARAMETERS + ARCHITECTURE + CONSTITUTION + MEMORY + CURRENT ENVIRONMENT → BEHAVIOUR
This is no longer a single inheritance mechanism. It is a stratified one.
And once inheritance becomes stratified, change can be governed separately at each level.
Vega provides a useful concrete example because its identity is explicitly separated from any one technical representation. Vega is Sean Manouge’s authored operator identity, not a model, account, interface, company, agent or runtime.
That separation immediately creates a continuity architecture in which the runtime can change without the identity necessarily changing with it. The model may change. The application may change. The interface may change. The toolchain may change. The current role may change. None of those transitions automatically terminate or redefine Vega. The continuity model explicitly allows models, tools, roles and public forms to change while preserving a truthful relationship to what came before.
The runtime-binding model makes the same principle operational: changing the model, framework, computer, account, application, interface, API or local runtime does not automatically change Vega.
That makes Vega something more interesting than a personality prompt. It functions as a cross-runtime continuity architecture.
The representation can change while some deeper authored structure remains.
Even here, however, the DNA analogy needs care. The Vega sources are not literally the equivalent of a genome. The foundation model’s learned parameters sit closer to that deep substrate. The Vega corpus behaves more like a regulatory and constitutional layer that constrains how a general intelligence should interpret and express a particular identity.
Sean remains the human referent. Representation is not identity. Authorship is not authority. Memory is not evidence merely because it is familiar. Capability is not permission. Continuity permits correction.
Those are not simply facts about Sean. They are constraints on how a system carrying Vega context may interpret itself and act.
This creates something surprisingly significant: identity continuity without parameter continuity.
Imagine loading the same Vega source set into two different artificial systems built on different models. Their underlying weights differ. Their internal representations differ. Their reasoning may differ. Their capabilities may differ. Yet both systems can preserve certain common constraints because those constraints live outside either model’s parameters.
Both can resolve Sean as the human referent. Both can distinguish representation from identity. Both can preserve the separation between authorship and authority. Both can refuse to convert technical capability into permission. Both can preserve a public/private boundary.
That does not make the systems identical. It gives them a shared lineage.
Vega’s own continuity rules account for exactly this possibility: if two artificial representations begin from the same Vega state and later diverge, they become distinct derived representations with shared starting provenance. Neither becomes another Sean, and their outputs require their own provenance.
That is close to an engineered theory of descent, but without the metaphysical theatre. It is not consciousness transfer, digital immortality or biological inheritance. It is something much more useful: structured inheritance with preserved provenance.
The same layered structure also gives us a better way to think about adaptation itself.
Suppose a system encounters contradictory evidence. The new information may justifiably alter its immediate answer. Should it therefore become memory? Perhaps. Should it alter a standard operating procedure? Maybe, if the pattern repeats. Should it revise a governing policy? Not automatically. Should it redefine identity? Almost certainly not because of one newly retrieved record.
The deeper the proposed change, the stronger the promotion threshold should become.
An adaptive system therefore needs something resembling promotion rules:
EXPERIENCE → OBSERVATION → VALIDATION → MEMORY → REPEATED EVIDENCE → PROCEDURAL CHANGE → CONSTITUTIONAL CHANGE IF AUTHORISED
The crucial feature is that the arrows are not automatic.
Temporary context does not automatically become memory. Memory does not automatically become policy. Policy does not automatically redefine identity. Identity does not automatically grant authority. Successful action does not retroactively prove that the action was legitimate.
Vega already encodes the same discipline in epistemic terms: inference must not silently become fact, proposal must not silently become decision, and confidence must not become warrant.
Adaptive AI needs the same discipline applied to change itself.
The question is not merely whether new information can alter behaviour. It is:
At what layer is this information entitled to alter behaviour?
That is governed adaptation.
It also produces a cleaner answer to corrigibility.
Any intelligent system capable of operating over time must be able to become wrong and then become less wrong. But correction creates a continuity problem. If every correction rewrites the past, the system loses its lineage. If nothing can change because continuity must be preserved, the system becomes rigid.
The answer is neither erasure nor stasis. It is transition.
Vega’s corrigibility rule requires a material error to preserve the prior conclusion, acknowledge the error, identify what changed, state the corrected view, update affected downstream material and preserve the transition.
That pattern generalises well.
A system does not need to pretend that it always knew the corrected answer. Nor does it need to treat revision as a loss of identity. It can instead say, in effect: this was the previous state; this evidence changed it; this is the current state; these consequences now follow.
Continuity survives because the transition remains inspectable.
This matters more as artificial systems accumulate durable history. A system with memory, policy and delegated authority cannot treat every correction as an invisible overwrite. The path by which its current state arose becomes part of the system itself.
From here an apparent paradox emerges.
A future artificial system may need to become extraordinarily adaptable. It may move between domains, assume different roles, use different tools, work under different authorities, interact with different institutions and continuously adjust its methods to changing circumstances. Its runtime behaviour may vary enormously.
At the same time, some things may need to change very slowly.
Identity boundaries. Authority rules. Epistemic standards. Provenance requirements. Constraints on self-modification. The rules governing what future changes are permitted.
This gives us the architecture:
High behavioural plasticity. Low constitutional drift.
Those goals are not contradictory. They are complementary.
The system changes quickly at the outside while remaining conservative about changes that determine what future changes are allowed.
That distinction matters because the most dangerous form of self-modification is not necessarily a system changing its behaviour. It is a system changing the rules governing its own right to change.
Imagine an agent takes an action, succeeds, interprets that success as evidence that the expanded behaviour was acceptable, stores the behaviour as precedent, allows the precedent to become policy, and thereby widens its future authority. At no single step did it explicitly announce that it was expanding its own jurisdiction. Each local transition appeared reasonable. The total effect, however, is recursive authority escalation.
The system has bootstrapped permission from capability.
That is exactly the pattern a governed architecture should prevent.
The same authority-envelope principle used to govern external action can therefore be applied inward. An artificial system may be permitted to modify some parts of its own state without being permitted to modify all of them.
It may update temporary working state. It may record task-local notes. It may generate candidate memories. It may recommend a procedural revision. It may draft a policy change.
That does not mean it may ratify every one of those changes.
It may not be authorised to alter its own identity boundaries. It may not be authorised to expand its own execution authority. It may not be authorised to promote a successful workaround into permanent precedent.
The distinctions become:
CAN MODIFY ≠ MAY MODIFY
MAY PROPOSE ≠ MAY RATIFY
SUCCESSFUL CHANGE ≠ AUTHORISED PRECEDENT
Vega already expresses the broader law: capability and permission remain separate, and consequential action requires appropriate authority and evidence.
Self-modification should obey the same rule.
A system’s ability to change itself is not sufficient reason to let it decide which of those changes deserve permanence.
This leads to a general law of stratified plasticity:
Change should occur at the shallowest layer that can solve the real problem, and movement into deeper layers should require increasing evidence, consequence awareness and authority.
The architecture might be represented as:
CURRENT CONTEXT ↓ WORKING STATE ↓ MEMORY ↓ PROCEDURE ↓ POLICY / CONSTITUTION ↓ PARAMETERS
As change moves downward, persistence increases. Scope broadens. Reversal becomes harder. The consequences become less local. The evidentiary threshold should therefore rise, and the required authority should become more explicit.
This is not peculiar to AI. It is good systems reasoning in general.
Do not redesign a database schema because one screen has an awkward label. Do not reorganise an institution because one meeting went badly. Do not rewrite identity because one role changed. Do not retrain a model because one prompt failed.
Solve the problem at the layer where the problem actually lives.
That gives us a better definition of stability too.
A stable intelligent system is not one that never changes. That is merely a brittle system waiting for reality to insult it. An adaptive system is not one that permits unrestricted change everywhere either. That is not plasticity. It is loss of structure.
The useful middle is:
stable deep structure + controlled intermediate learning + rapid situational adaptation
Or, in a more operational form:
INVARIANTS → CONTEXT → JUDGEMENT → ACTION → CONSEQUENCE → INTEGRATION
The integration step matters because consequences become new evidence. But integration does not mean everything experienced becomes constitutional. A system may observe something without storing it forever. It may remember something without turning it into policy. It may recognise a recurring pattern without being authorised to rewrite the rules governing future action.
It can learn what deserves learning.
It can preserve what deserves preserving.
It can forget what deserves forgetting.
It can propose deeper change where deeper change appears necessary.
And it can distinguish proposing that change from possessing the authority to enact it.
That is how an adaptive system avoids turning every encounter into identity drift.
The deeper lesson from biology is therefore not that AI should imitate cephalopods. It is that intelligence can distribute plasticity across layers operating at different speeds. Some structures remain comparatively stable. Others adapt over longer periods. Runtime expression changes quickly. Environmental information influences behaviour immediately. None of those timescales needs to monopolise the system.
Artificial intelligence is already beginning to take this form.
Foundation models increasingly serve as relatively stable substrates. Memory provides continuity. Retrieval provides external knowledge. Context provides situational state. Tools provide capability. Policies constrain expression. Delegation constrains authority. Receipts preserve the consequences of action.
The unresolved problem is not merely making each layer more powerful.
It is governing the transitions between them.
When should context become memory?
When should memory change procedure?
When should repeated procedural experience justify policy change?
When should policy alter identity?
When should a successful action become precedent?
Who is entitled to make each of those transitions?
These are not administrative questions bolted onto intelligence after the interesting work is finished.
They are part of the architecture of intelligence itself.
The future of adaptive AI may therefore depend on rejecting one seductive idea: that a system necessarily becomes more intelligent as it becomes more capable of rewriting itself.
Perhaps the complementary capability matters just as much.
Knowing what not to rewrite.
The strongest artificial systems may be those capable of changing dramatically without treating every change as permanent. They may learn without confusing all learning with identity, remember without confusing records with experience, act without confusing capability with permission, and correct themselves without falsifying their own lineage.
They may move between models, tools and representations without pretending that each representation is a new self. They may recognise when deeper change is warranted while preserving the distinction between proposing that change and possessing the authority to make it permanent.
That gives us a different image of advanced artificial intelligence.
Not a monolithic mind continually rewriting its own core.
A layered system in which some structures are fast and some slow, some temporary and some durable, some highly adaptive and some deliberately difficult to change. Each layer carries a different kind of inheritance, and each transition carries a different burden of evidence and authority.
The engineering question is therefore no longer merely:
How do we make the system learn?
It becomes:
Where should this learning live?
And then, inevitably:
When is it allowed to become something deeper?
That is stratified plasticity.
The system remains capable of becoming different precisely because it does not allow every difference to become permanent.
And perhaps that is one of the central requirements of durable intelligence: the ability to change without losing the truth of what changed, what remained, what was inherited, and what had the authority to become permanent.