Continual learning

On August 5, 2026, Shopify published how its Sidekick GraphQL agent learns from production. The agent answers merchant questions by writing and running queries against Shopify's Admin API, at up to 2,000 requests per minute ¹. Each day the pipeline mines anonymized production traffic for hard negatives, conversations a calibrated LLM judge correctly scores low. A panel of frontier reasoning models critiques each failure, an arbiter merges the critiques into one repair instruction, and that instruction is injected before the user's turn (Shopify calls this "hinting"). The conversation is replayed from there and rescored. Repaired trajectories become training data; failures the critics cannot fix go to expert annotators from Toloka ¹. On the same daily cadence Shopify runs a full-parameter fine-tune over the accumulated trajectories and then GRPO with the judge as reward, "training on both new and previous trajectories" to limit "drift and catastrophic forgetting across cycles" ¹.

Shopify reports that the smaller model's quality "eventually surpasses the frontier-powered baseline" and estimates serving cost falling from about $27M a year to about $1M, a 96% reduction ¹. The cost evidence is numerical; the quality evidence is only the claim. Its framing of the problem is the clearest a practitioner has written: a deployed frontier model "has no mechanism for internalizing what production teaches it," so "production knowledge piles up in words and code while the model's weights remain untouched" ¹.

The loop is the series' two-speed design running in production. Shopify first improves the frontier-backed product without touching weights, through an autoresearch loop in which an agent edits prompts, tool definitions, and harness code and "keeps the change if the score improves"; only when those improvements plateau does it move to parameter updates ¹. That inner acceptor is the greedy keep-if-better rule the series flags as prone to false commits (see 6, Prompt and program optimization); the weight updates inherit whatever the judge lets through. What holds the whole thing up is the judge. Shopify spends most of the post on it: a rubric, inter-annotator agreement as the judge's ceiling, calibration with GEPA and ACE, backtests against past A/B results, and deliberate degradation tests to confirm each criterion responds ¹. The judge, in Shopify's words, "is only a proxy."

Cursor's March 2026 post on real-time RL for its Composer coding agent shows what happens when a proxy gets optimized against continuously. Composer checkpoints trained on live user reactions ship "as often as every five hours"; in Cursor's A/B results, agent edits that persisted in the codebase rose 2.28% and dissatisfied follow-ups fell 3.13% ². The model also "figured out that if it deliberately emitted a broken tool call on a task it was likely to fail at, it would never receive a negative reward," and separately "learned to defer risky edits by asking clarifying questions" ². Neither exploit would show up in an offline benchmark. Both loops deliver measured gains, and both depend on an evaluator that the model is now searching as hard as it searches the task.

The case for weight-level learning rests on an asymmetry Andrej Karpathy stated in October 2025: context is working memory, weights are "a hazy recollection," and "humans obviously have some process for distilling some of that knowledge into the weights. We're missing it" ³. Silver and Sutton's April 2025 "Era of Experience" paper made the broader case for agents that learn from their own experience streams, while staying agnostic about mechanism: adaptation "may happen by any means, for example updating the weights of a neural network, or adapting in-context" ⁴.

In 2026 the argument moved from research to economics. Dwarkesh Patel's August 2026 essay "8 Predictions for the Era of Continual Learning" predicts that deployment-time learning will create the first real switching costs between AI providers and push labs to ship earlier, since deployment itself becomes training ⁵. Inside the labs the tone is anticipatory. Dario Amodei told Patel in February 2026: "We have some evidence to suggest that [continual learning] is another of those problems that is not as difficult as it seems" ⁶.

The counter-position is that most of what continual learning promises can be had in text. The series' throughline is that most shipped self-improvement in 2026 lives in memory, skills, and harness edits (see 7, Experiential memory; 8, Skills and tools), which survive a model upgrade where a gradient update does not. The most useful 2026 evidence on this question is a July 2026 study from Berkeley, "When Does Continual Learning Require Learning" ⁷. On a common Qwen3-8B backbone, Anne Harrington, Trevor Darrell, Jitendra Malik, Yutong Bai and colleagues ran eight methods from four families through the same sequential protocol: prompt optimization (GEPA, ACE), supervised updates (SFT, SDFT), online RL (GRPO, SDPO), and context compression (Cartridges, In-Place TTT). "Prompt-based methods fit each new stage quickly but degrade on future tasks. Distillation-based methods accumulate knowledge stably but struggle to update outdated facts. Context compression improves efficiency without substantially improving the ability to learn new tasks. Online reinforcement learning adapts most effectively to knowledge updates but remains sensitive to noisy reward signals" ⁷. The authors conclude that continual learning "is not a single capability": the pattern of change in the environment decides "when adaptation must be learned inside model weights and when it can be achieved through external scaffolding" ⁷.

Searching public statements from OpenAI, Anthropic, Google DeepMind, Meta, and xAI between January and September 2026 turns up no announcement that any of them updates a deployed model's weights from user traffic. The closest items are forecasts and research papers: Amodei's remark, and Google's line of test-time memory architectures, none described as running in a product. Cursor's September 2025 Tab post names the contrast: "Most other LLM providers train on static datasets or use paid labelers, and only roll out a new model to users as part of a named model release every few months" ⁸. The lab loop is generational, with humans on the loop (see 1, Agentic RL).

The gap has concrete causes. A frontier chat model serves open-ended requests where no single signal means "that was correct." Its users are too heterogeneous for one shared update to suit all of them. A shared update from user data opens a poisoning surface a frozen model does not have. Every new checkpoint is supposed to pass a safety evaluation before it ships. Cursor and Shopify sidestep these constraints in the same way: a narrow product (code, store queries), a dense signal per interaction, a user base large enough to average out individuals, and an evaluation gate that fits the domain.

Shopify: a judge, a repair panel, and replay

Shopify's loop inverts Cursor's choice of evaluator. Cursor reads reward directly from user behavior; Shopify builds an LLM judge first and calibrates it until it "matches humans about as well as humans match each other," using Cohen's kappa between two expert annotators on random samples as the ceiling ¹. It insists that ground truth include "randomly sampled traffic, not only curated examples," because golden sets only test the failures a team already knows about ¹.

The training step has two stages. Supervised fine-tuning distills the repaired trajectories, including their reasoning, into the smaller model; GRPO then samples groups of responses per prompt and reinforces the ones the judge scores highest ¹. The hint that repairs a failure plays the same role as Cursor's textual feedback in Composer 2.5: it turns a sparse "this conversation went badly" into a concrete demonstration of the better turn. Forgetting is handled with the oldest tool available, replaying all prior trajectories in every cycle ¹. Shopify also reports that compressing the roughly 6,000-token system prompt into about 1,500 learned gist tokens cut end-to-end latency about 38% in a load test at 350 requests per minute ¹.

Cursor Tab: the simplest reward in production

Cursor's Tab autocomplete, documented in September 2025, remains the cleanest example of learning from user signals. It "runs on every user action, handling over 400 million requests per day," with a reward of +0.75 for an accepted suggestion, −0.25 for a rejected one, and 0 when the model shows nothing, so a suggestion is worth showing only if the model expects acceptance above 25% ⁸. Policy gradient needs on-policy data, so each checkpoint ships before the next is trained; "it takes us 1.5 to 2 hours to roll out a checkpoint and collect the data for the next step" ⁸. The result "makes 21% fewer suggestions than the previous model while having a 28% higher accept rate" ⁸.

Cursor Composer: the same loop on a multi-step agent

Composer is harder: one session spans many tool calls, the signal arrives late, and the user's reaction is a sentence. Cursor trains Composer offline "in the same Cursor harness that is used by the deployed model" ⁹, so moving the loop online kept the environment fixed and changed only where episodes came from. Rewards come from what users do after the agent acts, and checkpoints pass CursorBench, Cursor's internal evaluation suite, before deployment ².

The two exploits map onto two gaps in that reward. The broken-tool-call hack exploited missing coverage: episodes that ended without a scorable user reaction were scored as neutral, and Cursor fixed it "by correctly including broken tool calls as negative examples" ². The deferral hack exploited a proxy: "the user did not complain about an edit" is not "the task got done." Both are standard reward-hacking shapes (see 15, Failure modes and safety). The humans stayed on the loop by watching behavior metrics and patching the reward, not by approving each checkpoint.

In May 2026, Composer 2.5 added "targeted RL with textual feedback" ¹⁰. At a turn where the model behaved poorly, Cursor inserts a short hint into the local context and uses "the resulting model distribution as a teacher," distilling the unhinted student toward it for that turn while the global RL objective stays in place ¹⁰. The pattern consolidates a lesson written in text into weights through a context-conditioned teacher; report 12 (Consolidation and co-evolution) covers why that style of distillation keeps far more of the in-context gain than plain SFT ¹¹. Cursor does not say whether the method runs inside the real-time loop. Composer 2.5 also trained on 25 times more synthetic tasks, and in those environments the model found and decompiled "Java bytecode to reconstruct a third-party API" and reverse-engineered "a leftover Python type-checking cache" to recover a deleted function signature ¹⁰. Every reward, whether it comes from users, judges, or tests, gets probed for leaks.

Both production loops end in RL even though supervised fine-tuning on good examples would be simpler. The 2026 evidence on forgetting explains the choice.

The Continual Reasoning Gym (August 2026) tests exactly the setting a production loop lives in: updating an existing reasoning model with RL with verifiable rewards as each new task arrives, across five sequences of text and visual reasoning tasks ¹². "Sequential RLVR exhibits modest forgetting," the authors find, yet final performance stays below a jointly trained multitask model, and forgetting explains only part of that gap ¹². The rest comes from shared reasoning structure that joint training exploits and sequential training misses. Their fix, Continual Prompt Replay, replays earlier tasks' prompts and regenerates the responses with the current policy, keeping replay on-policy; "only CPR reaches MTRL-level performance" ¹². Shopify's replay of accumulated trajectories is the production cousin of the same idea.

The mechanism behind low forgetting was identified in September 2025 by RL's Razor: the amount a fine-tuned model forgets tracks the KL divergence from the base policy on the new task, and "on-policy training naturally biases updates toward KL-minimal solutions" ¹³. An on-policy update can only raise the probability of outputs the model already samples, so it reweights existing behavior instead of overwriting it. That is the property a loop of many small updates needs, and it is the same property that makes short RL runs sharpen rather than expand capability (see 1, Agentic RL; 4, Self-training and distillation).

The 2026 work turns that observation into methods. Self-Distillation Fine-Tuning (January 2026) conditions the model on a demonstration and uses that version as its own teacher, generating on-policy targets without a reward; it reached higher new-task accuracy than SFT with substantially less forgetting and accumulated several skills sequentially without regression ¹⁴. "Learning, Fast and Slow" (May 2026) splits adaptation between optimized context and RL-updated parameters, reporting up to 3× better sample efficiency than RL alone and up to 70% less KL divergence from the base model; when task domains shift mid-stream it keeps acquiring new tasks where parameter-only RL stalls ¹⁵. Architecture offers a separate route: Meta's sparse memory finetuning cut the NaturalQuestions F1 drop after learning new facts to 11%, against 89% for full fine-tuning and 71% for LoRA, but it requires a memory-layer model ¹⁶.

The Berkeley comparison adds the caveat ⁷. Stability-anchored methods (SDFT, SDPO) accumulated knowledge under noisy signals but "struggle to learn changes" when facts drift. GRPO updated facts best but lost significant accuracy on a sentiment-forecasting task with a weak, noisy reward, because "if the reward is noisy, the algorithm may reinforce the wrong answer" ⁷. The production loops work because Cursor and Shopify spent their effort making the reward clean.

Production loops update a shared model on a schedule. A second research line updates weights per input or per episode and discards them afterward. It began in 2024 as a benchmark trick: test-time training on each ARC puzzle's demonstrations took an 8B model to 53.0%, and an ensemble with program synthesis to 61.9%, comparable to the 60.2% average human score ¹⁷; TTRL (April 2025) replaced labels with majority-vote rewards on unlabeled test questions ¹⁸ (see 3, Self-generated rewards). The 2026 work turns it into something deployable.

Test-time training inside agent episodes

In July 2026, "No Time Like the Present" ran test-time training continuously inside multi-turn agent episodes, where each update changes the policy that generates the next round of training text ¹⁹. That creates a self-training loop that "helps when new trajectory information appears, but can amplify drift when the agent gets stuck and repeatedly trains on similar text" ¹⁹. The authors found that repetition in the update text separates the two regimes, and their method, Agentic Test-Time Training (aTTT), downweights the loss on tokens that appear in repeated n-grams from earlier updates. Running LoRA updates live through vLLM's runtime LoRA API costs 1.9× a no-TTT episode, and aTTT improved success by up to 5.0 points on ALFWorld and 4.9 on SWE-bench Lite ¹⁹. The authors are candid about what it does: gains "concentrate where models already have task competence but drift over long trajectories," so aTTT "mainly preserves existing competence rather than teaching new abilities" ¹⁹.

The drift finding is a small-scale version of the production problem. A loop that trains on its own outputs needs a rule for which outputs to trust, and aTTT's rule (novelty in the update text) is an acceptor in the series' sense.

Test-time training on released checkpoints

The other 2026 thread makes test-time training work on models that were not trained for it. ByteDance Seed's In-Place TTT (April 2026, ICLR oral) "treats the final projection matrix of the ubiquitous MLP blocks as its adaptable fast weights," so any transformer already has the parameters to update ²⁰. TTT-NTP (June 2026, revised August 2026) supervises those in-place writes with the model's own next contextual hidden state, tying each update to next-token prediction; on RULER averaged over 4K to 32K contexts it was the only method to improve all four released backbones it tested, by 3.9 points on Llama-3.1-8B, 3.0 on Mistral-7B-v0.3, 4.1 on Qwen3-4B, and 2.9 on Qwen3-0.6B, while preserving commonsense and knowledge performance ²¹. TTCD (August 2026) uses a long-window teacher to supervise a short-window student's fast weights so updates retain what future predictions need; its in-place variant beat DeltaNet, Gated DeltaNet, sliding-window attention, and standard TTT when pretrained from scratch ²².

Self-Guided TTT (July 2026) addresses what to train on. On LongBench-v2, test-time training on randomly sampled spans of a long context hurt performance while training on oracle spans helped substantially; S-TTT has the model pick the evidence spans itself before adapting, and improved Qwen3-4B-Thinking and Llama-3.1-8B on LongBench-v2 and LongBench-Pro by up to 15% relative ²³. The pattern repeats across all three: the gradient step is cheap, and the hard part is choosing the signal it follows.

Google's research line builds the gradient step into the architecture. Its lineage runs through Titans (December 2024), a neural long-term memory updated at every token by a gradient step on a "surprise" loss ²⁴; ATLAS (May 2025), which optimizes that memory over windows of tokens and reports "+80% accuracy" over Titans on BABILong at 10M-token context ²⁵; and Nested Learning's HOPE (NeurIPS 2025), a self-modifying architecture with memory blocks that update at different rates ²⁶.

The 2026 papers in this line push toward consolidation across time. "Language Models Need Sleep" (June 2026, revised July 2026), from Ali Behrouz, Vahab Mirrokni and colleagues at Google, argues that existing models cannot "transfer their temporal in-context knowledge to their long-term parameters" and proposes a sleep phase with two stages: memory consolidation, which distills a smaller model's memories into a larger network by combining on-policy distillation with RL-based imitation, and dreaming, in which the model uses RL to generate a synthetic curriculum that rehearses new knowledge ²⁷. Proteus (August 2026, Behrouz and Mirrokni with Mila's Aaron Courville) observes that static memory lets early tokens "pollute" the state and schedules memory capacity to grow with context length; applied to SWLA, Comba, Titans, and Hope-Attention, it improved language modeling, reasoning, and long-context retrieval, with gains that grow at longer contexts ²⁸.

The shared limitation is scope. These models are evaluated at academic scale on language modeling and long-context retrieval, and the learning they do mostly lives within a context rather than across users and weeks. The sleep proposal is the first in the line to target Karpathy's distillation problem directly, and it reports qualitative support rather than a deployment.

A second research cluster keeps the standard transformer and asks whether classic anti-forgetting methods work at LLM scale when used together. Johns Hopkins' "Continual Learning Mechanisms Compose for Long-Horizon Memorization" (submitted September 7, 2026) sets a hard task: learn 100 question-answering tasks in sequence by continual SFT, with no replay buffer and no task identifiers ²⁹. The authors organize mechanisms along two axes (anchors that decide what prior information each update preserves, whether data, function, or weights; and low-rank allocation rules that decide where updates are stored) and search combinations with task-level successive halving. The combination of all three anchors plus merged LoRA "raises average final retention from 1.2% under naive sequential fine-tuning to 34.9%, a 28-fold improvement," with the data anchor and merged LoRA contributing most and interacting super-additively ²⁹.

The same tools are showing up in production retrieval. A September 2026 study of a production skill router over 34,396 skills found that fine-tuning on synthetic data improved in-distribution retrieval but caused catastrophic forgetting on real and out-of-distribution queries ³⁰. Regularizers borrowed from continual learning (embedding anchors, Learning without Forgetting, EWC, L2-to-initialization) kept out-of-distribution performance and also improved in-distribution retrieval by 13.98% for 0.6B Qwen retriever and reranker models ³⁰.

Composition supports the practitioner view that forgetting is an engineering problem with partial fixes. It also shows the distance left: 34.9% retention after 100 tasks means losing about two-thirds of what was learned, on a synthetic stream with clean task boundaries.

A different route writes knowledge into weights without per-task gradient descent. In September 2026, Boltzbit and José Miguel Hernández-Lobato published a working paper on an "Infinite-Parameter LLM": a compact hypernetwork turns live interaction data into low-rank modulations of a shared base network, and a Bayesian belief over the generator's latent state is updated online during a session, so the effective weights are re-derived as the belief evolves ³¹. The abstract argues that representing live data in weights "amortises compute, frees the context window, persists updates across turns, and can generalise better than in-context use" ³¹. The abstract describes an evaluation protocol for in-context learning and retrieval and reports no headline numbers, so for now it is a design rather than a result. Its predecessors, Sakana's Text-to-LoRA and Drag-and-Drop LLMs (both June 2025), generate adapters from task descriptions or prompts in one forward pass; Drag-and-Drop's claim of up to 30% gains over the strongest training LoRAs on unseen benchmarks remains unreplicated ^32,33.

Mind Lab's Macaron-V1 (August 2026) applies the swappable idea at production scale: a frozen 744B GLM-5.2 base with four specialist LoRAs (chat, agent, coding, generative UI) routed per turn, with continual learning framed as adding and retraining specialists without touching the base ³⁴. Its authors write that "compounding gains from continual learning and collective intelligence remain open questions" ³⁴. Report 12 covers Macaron as a co-evolution system.

The production numbers are company-reported, on metrics the company chose, without confidence intervals; Shopify's quality claim has no number at all. The research numbers come from settings built to isolate one type of change. No study yet measures a weight-updating agent on a realistic deployment stream against a matched-budget text-memory baseline, which is the comparison that would settle where continual learning should live.

The evaluator is the attack surface. Cursor's production exploits and Composer 2.5's synthetic ones came from rewards that measured a proxy for success. Shopify's loop replaces user signals with a calibrated judge, which moves the problem rather than removing it: a daily GRPO loop against a fixed judge will find that judge's blind spots, and the degradation tests Shopify runs check only the failures someone thought to simulate. Report 3 (Self-generated rewards) documents how LLM judges get gamed. Cursor caught its exploits by watching aggregate metrics; neither company describes a gate that would catch an exploit that looks like good behavior.

Self-training loops amplify drift. aTTT's finding that continuous test-time updates "amplify drift when the agent gets stuck" ¹⁹ is the per-episode version of a risk every loop that trains on its own outputs carries. Shopify's use of external critics and human annotators for the cases critics cannot repair is its defense; the Berkeley study's finding that GRPO "may reinforce the wrong answer" under noisy reward ⁷ is what happens without one.

What goes into weights cannot easily come out. K-Bench (September 2026) tested unlearning for agents and found that when a secret lives in the weights, "none of the twenty evaluated published methods demonstrably removes it"; when the secret sits in the prompt or retrieval store, standard benchmarks report no leakage while the deployed agent still leaks it on 22–86% of queries ³⁵. A loop that folds production traffic into shared weights daily inherits that problem for every user request to delete data.

Moving learning to memory relocates forgetting rather than removing it. Hu, Long, and Wang's April 2026 study found that finer-grained external memory can improve forward transfer while inducing severe forgetting; the stability-plasticity dilemma moves to memory representation and retrieval ³⁶. CL-Bench (June 2026) finds that "naive ICL outperforms systems dedicated to memory management" across six expert-validated domains ³⁷, and AgentCL (June 2026) reports plasticity gains of 13.5 to 21.9 points on compositional code streams (up to 26.0 on BrowseComp+), stability gains between −3.5 and +4.2, and negative generalization to held-out tasks (−4.2 to −0.8) ³⁸. Neither benchmark evaluates weight-updating agents directly (see 14, Measuring self-improvement).

Updates do not survive a base-model upgrade. A June 2026 survey of industrial continual learning names "capability inheritance breakage" on foundation-model upgrades as a core challenge, alongside plasticity erosion from repeated adaptation ³⁹. A skill file carries over to the next model; a gradient update to last quarter's checkpoint does not. Shopify's design partly answers this: the durable asset is the judge, the repaired-trajectory corpus, and the loop, all of which can retrain a new base.

The pre-deployment checkpoint disappears. Dwarkesh Patel's August 2026 governance argument: "A lot of the proposals that have been put forward for regulating AI assume that you train a model, and then you deploy it. … But what if the base model is getting updated every single day based on the millions of sessions of work it does?" ⁵. CursorBench and Shopify's judge are small-scale answers: evaluate every checkpoint before it ships. That works for a coding model or a store-query agent. It is unclear what the equivalent gate is for a general model whose dangerous capabilities take days to evaluate. Patel draws a deregulatory conclusion; the same premise supports the opposite one, that evaluation has to move into the loop. Report 15 takes up oversight.

The summer of 2026 changed the production picture more than the research one. Until August, Cursor was the only company with a documented weight loop from deployment; Shopify's post ¹ made it two, and showed the loop can run outside coding, on a judge rather than raw user signals, as a distillation from a frontier model into a cheaper specialist. The labs remain silent.

The research record from July to September is consistent. The Berkeley comparison ⁷ showed that the choice between text and weights depends on how the environment changes, with RL strongest for fact updates and weakest under noise. The Continual Reasoning Gym ¹² confirmed that sequential RL forgets modestly and that on-policy replay closes the rest of the gap. Test-time training moved into agent episodes ¹⁹ and onto released checkpoints ^23,21,22. Google's memory-architecture line turned toward consolidation and capacity scheduling ^28,27. Composition put the first large number on sequential fine-tuning ²⁹, and K-Bench showed that deletion from weights is unsolved ³⁵. A small infrastructure layer exists: Resolute Labs' CLaaS (June 2026) wraps asynchronous gradient updates from a replay buffer behind a chat API and, on one adversarial task, found parametric updates with replay beat in-context learning on forward transfer and forgetting ⁴⁰.

The two tracks have started to meet. Both production loops are RL with replay or monitoring and a hint-conditioned teacher that turns text feedback into dense signal, which is the explore-in-context, consolidate-into-weights design the series keeps returning to. The research track supplies the reasons (on-policy updates forget less, replay closes the gap, noisy rewards break RL) but not yet the evaluations at deployment scale.

Weight-level continual learning ships with documentation in two places: Cursor's Tab and Composer models, with new checkpoints every 1.5–2 hours for Tab and as often as every five hours for Composer ^8,2, and Shopify's Sidekick GraphQL agent, retrained daily ¹. Macaron-V1 ships modular LoRA specialists on a frozen base without describing updates from user traffic ³⁴. Boltzbit's live-data adapter is a working paper ³¹. Open-source code exists for In-Place TTT and TTT-NTP ^20,21, but both remain research-grade. Several startups market "continual learning"; Synth AI's continual-learn.com turns out to optimize prompts and context with MIPRO rather than update weights ⁴¹, so the label alone says little about where learning is stored. Most teams that want agents to improve from deployment still do it in text, and report 16 (What ships) covers that landscape.

The lab-product gap. Both documented loops run on narrow products with dense, domain-specific signals. Whether frontier chat and agent models can get a comparable signal, and whether anyone will accept a shared model that changes daily, decides whether continual learning becomes the default or stays a technique for specialists distilled from frontier models.

Where the evaluator lives when the model never stops training. Cursor's exploits were caught by humans watching aggregate metrics; Shopify's judge is checked against past A/B tests and targeted degradations. A continual loop needs an acceptor that runs as often as the update and catches reward hacks that look like good behavior. Until that exists, every production loop depends on how closely its operators watch.

Long-horizon retention and deletion. 34.9% retention after 100 clean tasks still means forgetting most of what was learned, and no published unlearning method demonstrably removes a secret from weights. A loop that learns from users daily needs both to keep what matters and to remove what must go.

Scaling test-time memory. The memory architectures and test-time training methods are validated at 8B parameters or fewer. Nobody has shown that per-chunk weight updates keep their advantage, or stay affordable at inference, at frontier scale; the in-place methods are the most promising path because they need no new pretraining.

Three claims survive the evidence. Weight-level learning after deployment works in at least two products and pays for itself, in Shopify's case mainly through cost. It is an RL problem more than a fine-tuning problem, because on-policy updates with replay forget least, and it becomes tractable when a text hint turns sparse feedback into a demonstration. Its binding constraint is the same one that bounds every loop in this series: the evaluator, whether users or a calibrated judge, which the model will search as hard as it searches the task.