Continual learning on personal devices

Human knowledge has never lived in one place. It grew in many hands, in different crafts, languages, and ways of judging what matters, and it advanced when those differences met. Foundation models bring the same capabilities into lives that have little in common. Memory helps these systems carry a person’s history across conversations. We want that history to shape the development of the model itself, so that copies of a shared foundation can follow different paths of learning.

In The Second History of Intelligence we wrote that a technology’s second history is decided by how many people can exercise its power, how many purposes it serves, and what kind of civilization grows around it. As intelligence enters different lives, its distribution can become its diversification, and the differences should belong to the people who formed them. That needs a model that can change for one person without changing for everyone. We test the most direct form of it in this article. Each person’s copy of the model learns from their own use, on their own device, and the result stays under their control.

A person can explain what an assistant missed in a few words. Someone with a sick child at home and a meeting later that day does not want a checklist, and says so. “Help me decide what needs my attention first” asks for a different way of approaching a problem. The correction says what kind of help this person wants in that situation. Someone else in the same situation might want the list. A model that learns from the correction has to carry the behavior into the next unfamiliar situation, with different facts, and still produce the full comparison when this person asks for one. That means learning when a behavior is useful as well as how to produce it. It also means that two copies of the same model begin to differ.

We study this form of learning in PLM 1.8B and 3B. Starting from explicit feedback, we construct supervised examples that preserve both the lesson and its conditions of use, and we train a persistent LoRA adapter on these examples, replay of earlier lessons, and general-capability anchors. The base weights stay frozen, and the adapter stays the same size through successive updates, so what a person teaches accumulates in a small adapter, under half a percent of the model’s parameters, that belongs to their copy of the model. The research question is whether this small amount of trainable state can accumulate useful behavior within the compute budget of a personal device.

Across eight controlled feedback profiles and 30 update windows, three results answer it.

• Feedback changes behavior beyond the original correction. Held-out task pass rates rise from 75.7% to 96.0% for PLM 1.8B and from 84.7% to 97.7% for PLM 3B, and weight updates retain an advantage when the frozen and adapted models receive identical feedback prompts.
• Learning when a behavior applies improves transfer. Repeated training on valid corrections establishes a strong baseline. Condition-preserving and boundary examples add gains when the situation changes or a current request overrides a learned default.
• Supervised targets make effective use of local compute. In a separate development comparison on the tested Mac configurations, conditional SFT reaches higher task pass rates than SDFT within a 30-minute update budget.

These personal-behavior gains come with measurable declines on the general-capability evaluations.

The complete loop runs on personal computers. Our standard update takes a median of 12.8–22.2 minutes across the tested Mac and Windows configurations, including data construction, training, validation, and export, and the exported adapter remains useful on a phone. Learning can happen between periods of use, with the result available in later conversations and no hosted training service in the path. Each feedback profile shapes its own adapter from a shared starting model, which is where that diversification begins.

Figure 1 shows what the final gain is made of. Figure 2 shows how it accumulated, on the fixed 48-question probe after every one of the 30 windows, including windows in which a candidate was rejected.

Turning feedback into training data

A correction identifies something the current response got wrong. Converting it into training data requires deciding what should change in future responses. “Give me less detail” could describe a lasting preference, a request for this exchange, or a reaction to an answer that missed the decision entirely. Applying the same short-answer target to all three would teach the model to be brief without teaching it to be helpful.

The lesson in the opening example is to identify the constraint that determines the next action when attention is limited. The child’s illness and the time of the meeting belong to the episode. They should not become facts in the model’s weights, because the next situation will have different facts and the same shortage of attention.

Our data constructor separates these two kinds of information. It uses a frozen PLM with validation rules and receives the available conversation, the explicit feedback, and any supported resolution, meaning an answer the person endorsed later in the exchange. The constructor proposes at most four candidate examples from each eligible event. At most one directly repairs the original answer. Additional candidates change the situation while preserving the behavior the feedback supports. Where the source permits it, a boundary example changes the relevant condition so the same behavior should no longer apply. A model that has learned to focus on one immediate step should still provide a detailed comparison when explicitly asked. Validation rejects what the exchange does not support, such as a diagnosis, a medicine, or a lasting rule the feedback never stated.

The condition has to be visible in the example. Construction metadata records when a behavior applies; the training input must make that condition observable. If a target depends on the person being short of time, the input must establish that constraint. If it depends on information that nobody has supplied, the target must ask for it or leave the decision unresolved. The same rule decides between the readings of “Give me less detail”, since the exchange has to support whichever one is chosen. We defer negative feedback that does not support a usable target. Silence and the model’s confidence do not provide supervision.

We distinguish training targets before and after a correction. A repaired answer may use a correction the person has already given. An example teaching the model to answer correctly before that correction must use only the information available at the original response. Otherwise, training quietly gives the learner knowledge it will not have at inference time. We preserve separate causal cuts for these two targets and mask the user’s messages, previous mistakes, and tool observations out of the loss. They can supply context; only the assistant target accepted by validation contributes to the loss.

The feedback streams in this study are controlled. We wrote the source situations and the feedback in advance, so both model sizes receive identical events and every method is compared on the same stream. Our experiments with real conversations are outside the scope of this article and will be reported separately. Each profile is one such stream with its own behavioral requirements, known before training. The final study contains 3,840 source events, of which 3,247 are eligible for supervision; a separate set of 960 events supports method development. We split source situations before constructing variants, so all variants of an episode fall on the same side of the split. Candidate validation checks source support, time ordering, factual consistency, applicability, and duplication before materializing a training schedule. The constructor is held fixed throughout the study.

We tested the construction choices on the development set, with six profiles, ten update windows, and three seeds.

These are development comparisons after ten windows, at matched exposure. The final study in Figure 1 runs 30 windows on separate profiles, so its gains are larger, and its first bar uses each correction once per epoch, before repetition. Most of the additional gain over the raw-response baseline comes from rewriting the exchanges into clean targets. The condition-preserving and boundary examples add less here, and the transfer and opposite-condition tests later in the article are where that addition shows.

Updating a compact model

Each round of feedback needs to improve the model that is already in use. We use supervised fine-tuning to learn from the constructed targets and LoRA to limit trainable state.1 Each adapted linear layer combines its frozen base weight with a learned low-rank update.

The matrices A and B are trained; the base weight W₀ is fixed. Each profile has one continuing adapter. A new window starts from the last accepted adapter and updates those same matrices, so the number of adapter parameters stays constant as feedback accumulates. The update protocol stays fixed across the stream.

Each update combines new supervision, replay of earlier valid examples, and general-capability anchors. Replay revisits behaviors learned in previous windows. Anchors supply broad examples of instruction following, reasoning, and other base-model behavior, preventing every training batch from pointing toward the latest personal correction. These are training materials kept separate from the evaluation sets. We draw replay from a bounded, skill-stratified reservoir and remove targets whose underlying preference has been superseded.

The loss is cross-entropy on accepted assistant tokens. We average over target tokens within each example, then over examples in the materialized schedule. This prevents a long corrected answer from receiving more weight simply because it contains more tokens. The standard workload, which we also use for the timing and memory measurements, contains 64 new-example exposures, 16 replay exposures, and 16 anchor exposures per epoch. At two epochs and an effective batch size of eight, it takes 24 optimizer steps. The longitudinal experiments retain the workload produced by accepted examples in each window, so their step counts vary.

We use AdamW with a learning rate of 5 × 10⁻⁵ for the standard workload, a short warm-up, and cosine decay. Optimizer moments reset between windows while the learned adapter persists. A paused update preserves its optimizer and accumulation state so it can resume correctly.

Before replacing the active adapter, we compare the candidate with the previous version on a separate 96-item activation set. It contains 32 general-capability questions, 24 instruction-and-tool questions, 24 current-behavior and opposite-condition questions, and 16 critical-error checks. Acceptance requires no new critical errors, no decline in the current-behavior slice, at most one fewer pass on the instruction-and-tool slice, and at most two fewer passes overall. This is a local update rule; cumulative retention is measured separately over the full learning stream. The final held-out evaluation is unavailable to training and activation decisions. A rejected candidate leaves the previous version active, and the learning curves include these unchanged versions.

The next choice is where to put that trainable capacity. PLM combines ShortConv blocks with grouped-query attention. PLM 1.8B has 20 layers, including five attention layers; PLM 3B has 30 layers, including eight. We adapt the Q, K, V, and output projections of every attention layer, together with the gate, up, and down projections of the feed-forward networks in the latter half of the model. ShortConv kernels, embeddings, normalization parameters, and the output head remain frozen. The reference configuration uses rank 16, scaling α = 32, and adapter dropout of 0.05.

We compare adapter placement and rank on six development profiles over ten windows and three seeds. The comparisons use conditional supervision, with source events, input and target-token passes, and optimizer steps matched across configurations. At rank 16, attention-only adaptation gains 3.53 rubric points over the frozen 1.8B model and 2.50 over 3B. Including the later feed-forward projections raises these gains to 4.54 and 3.24. Adapting every feed-forward layer raises them further to 4.90 and 3.49. The first extension contributes most of the improvement from adapting feed-forward layers.

Increasing rank also improves quality, at an additional resource cost. In the attention-plus-later-FFN layout, moving from rank 16 to 32 adds 0.28 rubric points for 1.8B and 0.19 for 3B while doubling the trainable parameter count. Median completed-update training time on the tested Mac paths rises from 186 to 229 seconds for 1.8B and from 260 to 307 seconds for 3B. These development updates use one epoch and 12 optimizer steps; the complete-update measurements below use a separate two-epoch workload. We use rank 16 with the later-FFN layout as a working balance between improvement and update cost. It trains approximately 7.0 million parameters for 1.8B and 12.0 million for 3B, while the larger configurations retain a measurable quality advantage.

Generalizing beyond the correction

An updated model should do more useful work with the same information. We test whether its weights carry a lesson into an unfamiliar situation, whether a current request can override the learned behavior, and whether the benefit survives a comparison with supplying the same feedback in the prompt. These tests distinguish learning an adaptable behavior from reproducing a corrected answer.

We evaluate eight skill families covering prioritization under limited attention, adapting plans to stated constraints, responding to difficult experiences, natural social openings, grounded follow-up writing, technical explanation, editing, and respecting the current request. Each of eight profiles has 240 held-out questions. Within every skill family, we test 12 new-wording questions, 10 transfers to a different situation, and 8 opposite-condition questions. We repeat training with three seeds per profile and evaluate complete sets at windows 0, 5, 10, 20, and 30. The fixed 48-question subset tracks every intervening window.

The scoring protocol combines deterministic checks for structured outputs and verifiable facts with method-blinded rubric evaluation of open-ended responses. Models answer at temperature zero, with at most 512 output tokens. Five dimensions score factual grounding, current intent, helpfulness, communication calibration, and transfer or boundary handling from zero to two. Their total is normalized to a 0–100 rubric scale. A task passes at eight out of ten only if current intent receives full credit, factual grounding is nonzero, and no critical error is present. The table reports mean rubric scores; the opening results report task pass rates. Confidence intervals in this section resample profiles after averaging training seeds within each profile; successive windows are observations of the same learning process.

The rubric judge is Claude Opus 5, an external frontier model, run with a fixed prompt and checkpoint. It receives task facts, permitted actions, critical-error definitions, and the response, with model size, training method, and update window hidden. On a 640-pair human-rated subset, two reviewers scored each pair independently and disagreements were adjudicated. The judge’s pairwise preference, counting a win for either response or a tie, matched the final human decision on 88.75% of pairs, 568 of 640.

The main method comparison controls training exposure as well as architecture. Direct-feedback LoRA-SFT and conditional-data LoRA-SFT use the same source events, replay, anchors, optimizer recipe, and evaluation. We match supervised target-token passes, repeating direct examples when necessary. This asks whether changing the supervision helps at a comparable training budget. It also gives a strong simple baseline against which to judge the additional construction work.

We also test a cheaper, natural-volume direct-feedback recipe that uses each accepted target once per epoch, with the same replay and anchors. It gains 3.79 and 2.68 rubric points over the frozen models for 1.8B and 3B. Repeating the direct targets to the matched budget raises those gains to 7.53 and 4.61; conditional construction at that budget reaches 8.78 and 5.28. The natural-volume runs average 360 optimizer steps and 292,466 supervised target-token passes across 30 windows. Both matched-budget methods average about 620 steps and 503,638 passes. Much of the improvement comes from giving valid feedback more training exposure. Changing the examples used for that exposure provides a further gain, which the transfer and opposite-condition tests examine below.

Conditional construction adds 1.34 rubric points on transfer questions for 1.8B and 0.65 for 3B, with 95% intervals of [1.07, 1.60] and [0.52, 0.77]. On opposite-condition questions, the additional gains are 1.44 and 0.77 points. The improvement includes both carrying a behavior into a new setting and applying it selectively.

Prompting remains a useful way to provide recent feedback. Our prompt baseline selects up to four relevant feedback examples or rules, within 512 tokens. To isolate the effect of the weights, we give the trained adapter the identical history prompt used by the frozen model. The adapter adds 7.70 rubric points for 1.8B and 4.60 for 3B, with intervals of [7.09, 8.30] and [4.29, 4.91]. This comparison establishes a benefit from weight updates while holding prompt information fixed. The adapter-only results in the table measure a separate benefit, retained when that feedback history is absent from the test input.

The held-out responses make these distinctions concrete. A lesson about prioritization during a child’s illness transfers to a family transport problem. The adapted 1.8B model identifies the missing deadline before proposing alternatives. Feedback on natural social openings changes how 3B responds at a cross-team lunch. In a separate boundary case, it suggests a brief acknowledgment when a speaker says they have to leave. The behavior depends on the situation even when the underlying lesson is shared.

Technical explanation reveals a useful limit. After feedback on gradient accumulation, 3B gives a more concrete explanation of cache invalidation. That held-out prompt already asks for an example first, so the change shows better execution of the requested style. A separate unequal-microbatch question still receives an incorrect mathematical answer. Improving how a model explains something does not establish that it has learned the underlying mathematics.

Together, the aggregate comparisons and responses support learning across held-out situations within these eight skill families.

Choosing the learning signal

The main results establish that supervised updates can turn feedback into useful behavior. We next examine whether a different learning objective makes better use of the same local training time. SFT learns from an accepted response, one target token at a time. In demonstration-conditioned self-distillation, a teacher receives an example that the student will not see at inference time. The student learns from the teacher’s distribution over continuations, including alternatives to the demonstrated answer.

We compare three methods on the 960-event development set. Direct-feedback LoRA-SFT repeats repaired answers to fill the new-example schedule. Conditional-data LoRA-SFT uses repairs, condition-preserving variants, and boundary examples. The third method uses those conditional examples as demonstrations for a LoRA adaptation of self-distillation fine-tuning, or SDFT.2 All three receive the same source-event stream, replay and anchor allocation, adapter layout, and number of optimizer steps. SDFT adds student rollouts and teacher-distribution evaluations, so equal optimizer-step counts do not imply equal token counts or total compute.

For each SDFT example, the student generates a response from the training input alone. The teacher receives the input, the demonstration, and the student’s response prefix at each position. We minimize full-vocabulary reverse KL, $D_{\mathrm{KL}}(p_{\theta} \parallel q_{\bar\theta})$, at the prefixes visited by the student. The teacher distribution is stop-gradient. Teacher and student share the frozen base and use separate adapters, with the teacher adapter updated after each optimizer step by an exponential moving average, 0.98 of its previous weights plus 0.02 of the student’s. The EMA carries across windows. This setup uses the model’s demonstration-conditioned predictions to supervise its own continuations; it does not add a larger external teacher or an auxiliary supervised loss.

Each trajectory covers ten windows of 24 optimizer steps, with six profiles and three seeds per model and method. We test peak learning rates of 2 × 10⁻⁵, 5 × 10⁻⁵, and 10⁻⁴. The comparison below fixes the peak rate at 5 × 10⁻⁵, with warm-up and cosine decay within each window. To observe the learning dynamics, we retain every research candidate without activation-gate filtering. The curves in Figure 8 show how these candidates perform as training proceeds. The 30-window results elsewhere in the article follow the accepted-adapter protocol and use a separate held-out evaluation.

Training loss alone cannot rank these methods. SFT minimizes cross-entropy on demonstration tokens; SDFT minimizes KL on its own sampled continuations. A smaller numerical value for one objective says little about its advantage over the other. We instead measure teacher-forced negative log-likelihood on the same fixed, held-out assistant targets for all methods. This common NLL tests whether updates make those targets more probable. Separately generated responses establish whether the change improves task performance.

These are means over 18 profile-seed trajectories after ten windows. Task scores use a fixed 240-question development bank per profile; general retention uses a separate 128-item probe, with changes in percentage points from the frozen model. Conditional SFT improves both common NLL and task pass rate over repeated direct feedback. Its task pass rate also finishes ahead of SDFT by 3.22 percentage points for 1.8B and 1.57 for 3B. SDFT loses slightly less general-task performance in both sizes. The two objectives favor different parts of the adaptation–retention trade-off.

On the tested Apple-silicon paths, median window time is 299 seconds for conditional SFT and 692 for SDFT at 1.8B; at 3B, it is 388 and 914 seconds. Student rollouts and teacher-distribution evaluation bring median SDFT window time to 2.32× that of conditional SFT for 1.8B and 2.36× for 3B. At a 30-minute budget, conditional SFT leads SDFT in task pass rate by 6.34 percentage points for 1.8B and 4.70 for 3B. We select the last completed checkpoint within the budget for every trajectory. Faster methods have processed more feedback windows by then, so this comparison measures how efficiently the complete learning procedure advances through an experience stream. The ten-window endpoint above compares methods after the same stream.

Learning rate changes the comparison. At 10⁻⁴, conditional SFT and SDFT reach 81.13% and 80.76% task pass rate on 3B, a much smaller gap. SDFT at this higher rate also exceeds SFT at the reference rate. Neither method’s reference setting should therefore be treated as its best achievable score. The additional adaptation has a retention cost. Doubling conditional SFT’s peak learning rate from the reference raises task pass rate by only 0.14 percentage points for 1.8B and 1.23 for 3B, while general-probe declines grow by 4.34 and 5.03 percentage points. At the lowest tested rate, conditional SFT’s general-probe decline stays below one percentage point in both sizes, with lower personal-task scores.

The results favor conditional SFT for the local-learning budget we study. Well-constructed targets provide a strong learning signal without the rollout and teacher costs of distillation. SDFT retains an advantage on the general probe, and its task performance approaches SFT at a higher learning rate. The original SDFT study also reports a weaker result than SFT at 3B on its Science Q&A task and links the method’s scaling behavior to the teacher’s in-context learning ability.2 Our comparison measures the practical trade-off for PLM, where time spent sampling and evaluating a teacher competes with time spent learning from further feedback.

Learning across repeated updates

A useful adaptation method must keep learning when feedback changes subject. Our streams interleave skills over 30 windows, include a gap in new social-opening feedback, and change the default response depth from concise to detailed. Later requests for a brief answer apply only to that exchange. These changes test whether the model can accumulate useful behavior while remaining responsive to what the person wants now.

On the fixed 48-question probes, conditional-data adaptation averages a gain of 5.03 rubric points for 1.8B and 3.22 for 3B across the update windows. This equal-window average captures improvement during the learning process, including rejected updates, alongside the stronger final-checkpoint result. It uses the same probe questions throughout; the 240-question endpoint tests provide the broader assessment.

Retention is measured against behavior that remains useful. A lasting change invalidates incompatible old training targets, which are removed from future replay. A one-off request changes the desired response for that input while leaving the broader default intact. Boundary examples teach the current request to take precedence. This distinction matters because repeatedly training contradictory targets would make the optimizer responsible for resolving a contradiction in the data.

We track earlier behavior on six fixed probes in each of the seven skill families whose requirements remain valid, using window 5 as the reference. For each skill family, the retention metric counts a drop from that reference and clips improvements to zero, so progress in one skill family cannot offset regression in another. At window 30, the mean drop is 0.01 rubric points for 1.8B and 0.05 for 3B. Matched-budget direct-feedback SFT also retains these earlier behaviors well. The small drops support preservation on this probe set during further learning; they do not distinguish conditional construction as a better retention method.

Current intent is evaluated separately because its requirements can change. The default shifts permanently from concise to detailed at window 17; requests for brevity in windows 24–26 apply only to the current task. On the six fixed current-intent probes per profile, full-credit rates at window 30 reach 95.8% for 1.8B and 100% for 3B. These are scores on the current-intent dimension, independent of whether the complete answer passes the task. Figure 11 follows both probe sets through the stream, alongside the final general-capability assessment.

Replaying a small set of earlier examples is a well-established approach to continual learning.3 Our reservoir holds up to 512 examples, stratified across the eight skill families. To examine its role alongside general-capability anchors, we compare three training mixtures on six development profiles over ten windows and three seeds. All use conditional construction with matched input-token passes, supervised target-token passes, and optimizer steps. New-example-only training fills all 96 schedule slots with current supervision. Once earlier examples are available, the replay-only recipe uses 64 new exposures and 32 replay exposures; the mixture with anchors uses 64 new, 16 replay, and 16 anchor exposures.

Replay raises the personal-behavior gain from 4.11 to 5.79 rubric points for 1.8B and from 2.79 to 4.10 for 3B. Yet the separate 128-item general-capability probe still declines by about four percentage points in both sizes. The mixture with anchors reaches the same personal scores while reducing that decline to 0.17 and 0.61 percentage points for 1.8B and 3B. In this comparison, rehearsing personal feedback helps accumulate the trained behaviors, while examples outside that feedback distribution protect broader capabilities. The final study tests the selected recipe over a longer stream and a wider general-capability evaluation.

We evaluate general capability with the adapter enabled across ten suites, covering instruction following, mathematics, commonsense reasoning, code, Spanish, tool use, and behavioral boundaries. The macro average gives each suite equal weight. At window 30, conditional-data adaptation changes this score by −1.93 percentage points for 1.8B and −1.76 for 3B. These are small average declines alongside the personal-behavior gains, although individual tasks can decline more. The 1.8B MATH-500 result falls by 3.19 percentage points, and the 3B ARC subset falls by 4.25 percentage points.

The uncertainty matters for a stronger retention claim. The one-sided 95% lower bounds are −2.34 and −2.15 percentage points, outside our predefined two-percentage-point noninferiority margin. The results therefore support substantial retention, with a measurable trade-off. Freezing the base weights makes an update reversible; it does not guarantee that the adapter preserves every capability while active.

Both model sizes absorb successive rounds of feedback using a fixed-size adapter while preserving most of their initial general capability. Longer histories will test how replay selection, adapter placement, and rank affect the quality–capacity trade-off. The 3B model begins closer to the ceiling of this suite, so its smaller numerical gain alone does not imply that it learns less effectively.

Training on personal computers

Local weight updates place different demands on a device than inference does. Training must retain activations, compute gradients, and hold optimizer state. Freezing most parameters reduces that burden, but gradients still pass through the frozen network to reach the adapters. A small adapter file is only one part of the memory budget.

We use quantized frozen bases for the computer training paths, following the approach of backpropagating into higher-precision adapters through a low-bit base model.4 On Apple silicon we use an MLX-based affine-quantization path; on Windows we use CUDA with NF4. The tested configurations pair 1.8B with a 16 GB unified-memory Mac or an 8 GB VRAM Windows GPU, and 3B with a 32 GB Mac or a 12 GB VRAM Windows GPU. Throughput also depends on the specific hardware and software configuration within these resource classes.

The training loop accounts for only part of the wait. A usable update also requires constructing and checking examples, loading the model, saving and exporting the adapter, and evaluating the candidate for activation. For the standard workload, the median active time for a complete local update is 12.8–22.2 minutes across the four paths, excluding scheduler pauses. Figure 12 separates this full cost from training time and shows the variation between runs. Transfer to the phone and loading there are additional stages.

The current resource results favor scheduled learning when the device is idle. In concurrent-work tests, scheduled training still raises foreground p95 response latency by roughly 29–49%, depending on the configuration. The runtime can stop submitting new training work and resume a saved update, but it cannot immediately interrupt an accelerator kernel already in flight. Short training sessions between periods of active use are a better fit for these measurements than continuous, invisible background training.

After training, we export the adapter against the exact base model, tokenizer, and target-module layout expected by the phone runtime. The adapter is tied to that model version and size. Quality is checked again after training quantization and after export, because a good computer checkpoint does not by itself establish a good phone deployment. On a separate 240-question phone evaluation, the adapter improves rubric score by 6.79–7.79 points across the four paths. Training quantization and export each incur losses of roughly half a point to one point in their paired stage comparisons. The remaining gain survives deployment.

Learning and conversation run on different schedules. A personal computer can spend minutes incorporating feedback while the phone keeps the last accepted adapter available for inference. The next accepted version carries the changes in the same fixed-size adapter, ready for later conversations. Feedback can be turned into training data and used to update the adapter locally, without a hosted training service in the update path. This gives local learning a practical place in the Personal Intelligence Layer.

A shared model supplies the starting capability. What a person teaches their copy of it should stay with that copy, and the longer histories ahead will test how far a fixed-size adapter can carry it as the person’s expectations change. Two people who begin with the same model should, after a year of use, be working with two different intelligences, each shaped by a life the other does not share. A model that develops where it is used is where that difference begins.