Stuffing Context is not Memory, Updating Weights is

ChatGPT can help prepare a presentation or cook dinner, yet it cannot explain why Jack Morris’s speaker pass failed at the conference entrance. Asked whether the Blue Jays won the World Series, it needs web search to know an outcome beyond its training cutoff. Asked to optimize an AMD GPU kernel, it encounters a different problem: the task is difficult, relevant examples are scarce, and those examples occupy only a small part of its training distribution. Missing knowledge is not one problem. It can be recent, private, or poorly represented in training.

Long-tail tasks expose that last gap. Asking a deployed model to practice does not itself give it a training loop. Nor can a general model infer the terms of your BlackRock partnership, which shirt you would prefer, how your company monorepo works, or how you write email. Patient histories, opposing counsel’s arguments in the Martinez negotiations, and answers buried in an internal wiki all require information the model may never have encountered.

There are three broad ways to make that information available:

The first two change what the model can read during a request. The third changes the model itself. Morris’s central question is how to make that third option useful enough to become part of ordinary application development.

For a bounded collection, copying everything into context is an excellent starting point. A small company’s records, a history of roughly a hundred World Series, or one patient’s medical record may fit well enough for the model to answer useful questions. The difficulty appears as the input grows: every request carries more information through the inference system, increasing both cost and waiting time.

Morris recalls that pasting his roughly eighty-page thesis into Claude made the interaction feel about ten times slower. His throughput slide gives a more specific comparison: Llama 8B, peak throughput on one H100, excluding prefill.

These are serving-throughput figures under the slide’s conditions, not the speed of a single Claude response. They illustrate how much longer context can change the economics of generation even before counting prefill.

The architectural explanation starts with self-attention. In conventional full attention, each input token can interact with every other input token. Four tokens give a 4 × 4 attention matrix with sixteen entries; twelve give a 12 × 12 matrix with 144 entries.

That all-pairs structure creates a quadratic constraint when processing a sequence. Morris emphasizes the resulting memory pressure: making the context window larger does not remove the work required to use it.

Large advertised windows seem to challenge that limit. Morris cites Grok 4 at two million tokens and Gemini 3 at one million in the talk’s contemporary comparison. But accepting an input without crashing is different from reasoning across it. A model can remain operational while becoming less reliable at finding and combining the information that matters.

Chroma’s Context Rot report examines this distinction by increasing input length, including settings where relevant information stays fixed while other material grows. Morris highlights Claude’s comparatively strong showing in the displayed graph, which he feels better matches users’ experience than some standard benchmarks. He then points to severe task degradation around 10,000 tokens in the illustrated irrelevant-context setting. That is his reading of this particular comparison, not a universal failure threshold. The outputs can still be grammatical while failing to solve the problem—a pattern he also connects to complaints about Claude Code as its context fills.

More efficient architectures address part of the problem. Mamba, other state-space models, linear attention, hybrid attention, sparse attention, and sliding windows all offer different ways to reduce computation or memory use. The remaining question is whether they preserve enough information and computation to improve answers as more material arrives. Efficiency alone does not establish that capability.

The example is MiniMax-M2, which retained conventional full attention after exploring alternatives. MiniMax’s explanation describes a production trade-off involving quality, evaluation, and infrastructure. Morris uses that choice to separate two obstacles: fitting an enormous input into the system, and reasoning effectively over that input. Industrial collections can extend to billions or trillions of tokens, far beyond the scale at which either problem is settled. When he asks who works with RAG weekly, he estimates that more than half the room raises a hand.

RAG has a practical advantage: its infrastructure already exists. Morris names turbopuffer, Weaviate, Chroma, and Mongo among the available vector-database options, with different price, speed, and storage trade-offs, including S3-backed offerings. He describes internal question answering and ChatGPT memory as embedding-backed systems, invoking Karpathy’s analogy of embeddings as an LLM’s file system. He dates that assessment to November 22, 2025. His prediction is that embeddings will not remain the only way to provide persistent knowledge.

The appeal is also developer experience. Producing an embedding can take roughly five lines of code; building a reliable training workflow is substantially harder. Yet when Morris asks whether anyone is completely satisfied with their RAG system, nobody volunteers in the exchange. The ease of constructing the pipeline does not settle the quality of the resulting memory.

The basic abstraction is one vector per document. On the slide, those vectors are projected into two dimensions so each document becomes a dot. The actual stored representation is a list of numbers that a person cannot read. That unreadability can be misleading: another learned system can map the vector back toward the original text. The displayed example includes a sentence about racehorse Mage winning the 2023 Kentucky Derby, its vector, and a reconstruction with altered details.

The reconstruction becomes stronger through iteration: generate a candidate text, compare its embedding with the target, and correct the candidate over multiple rounds. In Text Embeddings Reveal (Almost) As Much As Text, Morris and collaborators studied this inversion process. Morris summarizes the result as roughly 90% exact recovery at a particular text length; the paper’s reported setting is 92% exact reconstruction of 32-token inputs using iterative correction and re-embedding, with experiments on two embedding models. This does not imply the same recovery rate for arbitrary documents or embedding services.

An embedding should not be treated as a privacy boundary merely because it looks like numbers. Morris raises the issue in the context of sending embeddings to external stores, naming turbopuffer and Pinecone. The security consequence is that recoverable text can remain present in a representation even when the original document is not sent alongside it. He also flags the operational difficulty of running vector infrastructure at scale.

A second problem is that a general embedding model supplies a general notion of similarity. Morris describes a corpus split approximately evenly between Visa and Mastercard documents. In a space representing all possible subjects, both brands belong to a small region about credit cards. But in this application, the brand distinction is essential: a Visa query should never retrieve Mastercard material. Semantic proximity works against the application’s requirement.

The contextual approach changes how a document is embedded. A two-stage model incorporates surrounding-document information while producing the target vector. It can therefore represent a Visa document with the knowledge that the collection consists largely of Visa and Mastercard documents, making the distinction between them more salient. Amex appears in the presentation’s illustration, but Morris clarifies that it was not in the experiment. In the shown contextual example, Morris reports a Visa–Mastercard similarity of 0.144, with higher similarity among Visa-containing material.

Morris reports improvements on specialized datasets involving climate, arguments, financial questions, and scientific articles. When asked about adoption, he says contextual embedding methods are used inside OpenAI, Anthropic, and other companies. The implementation requires extra machinery: obtain surrounding-document embeddings, then condition the target representation on them. He describes stronger benefits on niche collections and little improvement on the broadly distributed MS MARCO task, where a global semantic space already fits the problem better.

Better data remains his first recommendation for improving an embedding system. Contextualization helps adapt similarity, but it does not make a fixed-dimensional vector capable of representing every possible relationship a future query might require. Morris points to a combinatorial limitation: the space of possible text relationships can exceed what a fixed representation can preserve for retrieval.

The practical failure cases he wants to capture involve associations across documents and answers implied by a collection rather than explicitly stated in one passage. He also acknowledges how difficult it is to build convincing benchmarks that ordinary retrieval cannot solve. That admission matters: the proposed target is richer reasoning over a corpus, but identifying tasks that cleanly measure the missing capability remains part of the research.

An audience question introduces agentic search: a model makes successive queries, inspects what it finds, and then answers. Morris distinguishes this from the ordinary RAG pipeline he has been criticizing. In principle, an agent could read a whole collection and reason over its relationships. The obstacle would be the expense of doing that work.

Deep research is a promising example of spending more at inference time. The audience describes a system that searches many sources but retains only a subset in context. Morris welcomes the direction: taking time, searching repeatedly, and thinking through the results are useful ways to buy better answers. His weight-learning proposal spends more effort earlier, so the deployed model already knows the collection.

Better results can require more investment in data, training, or inference. RAG is attractive partly because a basic version is inexpensive to build and operate.

Another audience member revisits Visa and Mastercard and asks whether a knowledge graph could augment the system. Morris defers that discussion rather than assessing the approach. The next part of the talk therefore explores parameter updates without establishing that they supersede graph-based alternatives.

Suppose you have collected a small dataset from your own work. Putting it in context may already help, but some questions can remain difficult even with all the source material present. The weight-learning goal is to make the model use that knowledge more effectively while preserving useful capabilities it already has.

Model capacity is finite. In How much do language models memorize?, Morris and collaborators estimate approximately 3.6 bits per parameter for the tested GPT-style models, separating memorization from generalization. At that rate, one billion parameters corresponds to 450 million bytes, or 450 MB of information. This corrects the talk’s spoken conversion; the estimate is not a universal storage specification for ChatGPT. A model allocates its finite capacity to fitting its training distribution and fails to retain everything else.

Morris illustrates the allocation problem by asking Claude for the capital of the smallest province in Tajikistan. It supplies a detailed answer without search. That is impressive, but it may be irrelevant to a company documentation assistant. Ideally, the assistant could replace irrelevant knowledge with the organization’s own information. Precisely locating, deleting, and replacing knowledge in weights is not yet a solved operation. The slide’s phrase neural file systems names this ambition; Morris uses the simpler term weights in the talk.

Three design choices follow:

• Learning objective: Should adaptation use supervised fine-tuning, reinforcement learning, or another objective?
• Training material: Should the model read the raw corpus, or a larger set of generated examples derived from it?
• Architecture: Which parameters should change when personal models need repeated updates?

The source collection might contain Mastercard documents, personal information, or coding traces gathered across November and December. Whatever the source, Morris expects learning beyond a basic RAG system to require meaningful GPU expenditure.

The simplest experiment is to train directly on the documents using next-token prediction. Morris’s team tries this with a 3M 10-K financial report: a structured document whose contents interrelate in ways they want the model to understand. Morris reports zero training loss on the report, even without updating the entire model. By that measure, the model has memorized the document extremely well.

The next test asks for behavior that is not copied directly from the report: write a poem about 3M in fiscal year 2025. The response is, “The passage of a passage is a poem.” Then it stops. Memorizing the training sequence did not produce useful command of its subject.

Morris diagnoses two problems. First, raw document text is not necessarily the right training distribution for the questions and tasks the assistant will face. Second, the update can make the model excessively specialized, damaging its general behavior and encouraging document-like continuations. Improving this experiment requires changing both the learning material and how the model is allowed to change.

Karpathy’s experiment teaching a small model about himself suggests a different route. Instead of repeatedly training on a single factual example, he generates a diverse set of task examples and fine-tunes on those. The variety teaches the desired behavior through multiple formulations. Morris describes it as a successful instance of teaching novel behavior through synthetic data.

Synthetic continued pretraining applies a related idea to a small source corpus. Its EntiGraph method extracts entities and generates diverse connections among them. The resulting material is meant to preserve the source facts while expanding the ways those facts are expressed and related. A small collection can thus support a much larger training distribution without first collecting a correspondingly larger set of original documents.

In the displayed comparison, direct fine-tuning drops below the model’s starting performance: reproducing the source more faithfully makes it less able to answer differently phrased questions. Synthetic expansion does better. Morris reports that synthetic-data training surpasses GPT-4 on the paper’s dataset at a loosely described scale of roughly 100 million to nearly one billion tokens; he does not specify the exact crossover or baseline configuration in the explanation. The useful mechanism is the expanded range of learning examples, not simply more repetitions of the original text.

Synthetic expansion can take several forms:

• Active reading: Ask the model what kinds of learning material should be generated, then generate them.
• Cartridges self-study: Use question answering and self-quizzing to turn source material into practice.
• Rephrasing the web: Produce alternative expressions of pretraining material at large scale.

These approaches vary the learning experience rather than relying exclusively on the original document’s wording and order.

Morris also points to Datology’s synthetic-data work and to SEAL, or Self-Adapting Language Models, which asks a model what data it should generate to improve itself. He describes SEAL as working in constrained scenarios. The interesting result is that a model can sometimes help design its own adaptation data, not that it can improve without limit. The broader opportunity is to turn a small factual source into a large, useful collection of learning examples.

Better data still leaves the problem of catastrophic forgetting. A classic example is a model that learns handwritten digits, then learns house numbers and loses its ability to recognize the handwritten digits. Updating a language model on a new collection can similarly interfere with old capabilities. Morris presents several ways to restrict the update, while explicitly treating the choice among them as unsettled.

Morris describes prefix tuning as training the KV cache. An added expert expands what an MLP can route to; a memory layer offers a different, table-based place to store learned information. LoRA, short for low-rank adaptation, constrains a linear-layer update through smaller matrices. His illustrative scale is a ten-billion-parameter base model controlled by ten million trained parameters.

A minimal PyTorch layer makes the LoRA restriction concrete. For a frozen weight matrix W, the learned update is B @ A; the rank determines the size of that update’s trainable representation.

import torch
from torch import nn

class LoRALinear(nn.Module):
    def __init__(self, base: nn.Linear, rank: int, alpha: float):
        super().__init__()
        self.base = base.requires_grad_(False)
        self.scale = alpha / rank
        self.a = nn.Parameter(base.weight.new_empty(rank, base.in_features))
        self.b = nn.Parameter(base.weight.new_zeros(base.out_features, rank))
        nn.init.normal_(self.a, std=0.01)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        update = (x @ self.a.T) @ self.b.T
        return self.base(x) + self.scale * update

layer = LoRALinear(nn.Linear(8, 4), rank=2, alpha=2.0)
optimizer = torch.optim.AdamW(
    [parameter for parameter in layer.parameters() if parameter.requires_grad],
    lr=1e-3,
)

The base weights remain frozen, and b starts at zero, so the initial layer output matches the base layer. Training can change a and b without directly overwriting W. This illustrates the common idea behind Morris’s comparison: attach a relatively small trainable component to a capable model and preserve the original parameters. It reduces the scope of the update; it does not guarantee unchanged behavior.

For personal models, the desired properties are small stored changes, resistance to forgetting, enough capacity to capture useful facts, and fast inference. A separate full copy of Kimi for every user would be impractical at the trillion-parameter scale Morris invokes; exact storage also depends on numerical precision. Thinking Machines’ Tinker training API represents the shared-base alternative: independently train user-specific LoRAs and batch their use over an unchanged base model. Morris’s description of this as having essentially no cost refers to sharing the base computation and infrastructure, not to a measured zero-cost training or serving service.

LoRA Learns Less and Forgets Less compares low-rank adaptation with full fine-tuning in programming and mathematics. Morris highlights its supervised-learning trade-off: the smaller update learns less of the new task, but also causes less degradation of existing capabilities. Restricting the update can preserve knowledge precisely because it limits how much the model can change.

Thinking Machines’ LoRA Without Regret supplies a contrasting result: LoRA can approximately match full fine-tuning in the reinforcement-learning settings Morris discusses. The displayed plots use Llama-3.1-8B on GSM and MATH, comparing full fine-tuning with LoRA ranks 1, 16, and 256 across learning rates. Morris interprets the contrast as evidence that RL can require smaller changes than supervised fine-tuning. The report also finds that LoRA can match full fine-tuning on small-to-medium supervised datasets; adapter capacity and dataset demands matter, so SFT does not categorically require updating every weight.

Morris then presents preliminary TinyLoRA research, still unreleased at the time, extending the idea behind LoRA-XS. Morris reports approximately 91% GSM8K accuracy from reinforcement learning with fourteen trainable parameters. He also raises a concern about the Qwen model’s training data, which limits how strongly he interprets the result as newly acquired reasoning.

An audience member asks about the smallest possible update. Morris says the one-parameter experiment improves performance by “five percent,” without specifying whether that means a relative increase or percentage points. The mechanism is more expressive than changing a single isolated weight: one scalar controls many random projections, producing changes throughout the model while leaving only one number to train and store.

The evidence does not identify a single best parameterization. Morris cites a paper favoring prefix tuning over LoRA, then recalls Meta colleagues who preferred LoRA. Systems support could influence the eventual choice: prefix tuning works with KV-cache infrastructure that serving systems already manage extensively. At the time of the talk, he describes concurrent multi-LoRA training kernels in open source as a missing piece, contrasting that difficulty with the infrastructure Thinking Machines is building around LoRA.

Memory layers offer another route. Think of an expert implemented as a large differentiable lookup table. In work Morris attributes to Justin Lan, training updates only specified small portions of that table. On the displayed learning-versus-forgetting plot, moving right means learning more, while moving down means forgetting more. Morris describes the memory-layer method as learning nearly as much while exhibiting almost no forgetting in that study. He finds it promising for preserving a base model, but the conflicting results across methods leave the architecture question open.

The audience returns to the TinyLoRA experiment and asks whether supervised fine-tuning came first. Morris estimates that SFT needed roughly 1,000 times more trainable parameters for equivalent performance in these experiments. The revisited slide identifies Qwen2.5-7B-Instruct, GRPO, GSM8K, and update size in parameters, with separate markers for TinyLoRA, LoRA-XS, and LoRA.

His proposed explanation concerns the amount of information in the learning signal. SFT supplies tokenwise cross-entropy targets, potentially including every token in a reasoning trace. In his simplified account, RL supplies a sparse correct-or-incorrect reward instead. That can steer behavior already available in the base model without requiring an equally large store of new information. The experiments compare GRPO and SFT as separate alternatives; they do not run GRPO after an SFT stage.

A practical question changes the emphasis: what if there are only a few documents, a fact appears once, or the data changes frequently? Morris expects both context and RAG to remain useful. His illustrative deployment performs a large training update periodically—perhaps daily—and still retrieves information on every served request. He offers no measured document-count or economic crossover at which training becomes preferable. Corpus size, information frequency, and update rate remain variables that need analysis.

The proposed adaptation targets assistant and agent completion models, not primarily embedding models. Morris sees more potential in teaching the answering model than in further refining retrieval, but his suggested order-of-magnitude gains are forecasts rather than measurements. Asked what remains difficult even with excellent retrieval, he points to chunking: retrieving some relevant passages may still omit the evidence and relationships needed to reason across the collection. He argues that some datasets resist any chunking scheme that supplies everything a question needs.

At consumer scale, the audience asks about personalization for ten million to one hundred million users. Morris suggests that a few megabytes of LoRA state per user could be manageable, comparing that storage burden with video services. Continual updates are harder than storing adapters; once-daily training is his near-term example. He explicitly concedes that the overall approach is more expensive than current systems.

Audience members point out that the other approaches can improve too: compress context, compress material before retrieval, and combine RAG with SQL and knowledge graphs. Morris agrees that progress will continue along all three axes. When pressed for a decision boundary, he offers a qualitative distinction: a large corpus that the base model has never learned is a promising target for adaptation; small, frequent additions are better candidates for inference-time investigation closer to deep research.

How would synthetic generation help a company with millions of proprietary documents and its own terminology? Morris starts with information density. Many documents may repeat the same formatting and contribute only a small amount of new information. The useful transformation would identify what each document adds, then express that knowledge in examples the model can learn from.

His proposed starting procedure is:

1. Identify the new information in each document rather than reproducing its formatting.
2. Generate question–answer pairs that expose that information.
3. Shape the question distribution around what users will actually ask.

He calls this a research direction, not a general recipe. Question answering gets part of the way toward the desired training distribution; covering every useful question and relationship is the harder goal.

Returning to the 3M example, another question asks what the inference prompt would contain after successful adaptation. In the ideal case, only the user’s question: no repeated financial report and no extra system prompt supplying its contents. If the adaptation concerns a single document, even the document identity might be implicit. That interface depends on the model having learned the information successfully and on the information remaining unchanged.

An audience member challenges the premise that weights are the best place to store information. Morris explicitly narrows the claim: weight storage is an underused capability, not necessarily the best medium for everything. A repository with millions of tokens makes repeated reading expensive. Compressing the behavior induced by a long prompt into an adapted model could reduce subsequent inference costs. Whether synthetic training can also exceed the performance of having the source in context remains a research question; lower recurring inference cost does not by itself establish lower total cost.

Generating training material from user inputs creates an adversarial surface. A malicious user could supply information designed to sabotage the resulting adaptation. Morris says he has not previously considered the question and offers no mitigation. He distinguishes damage contained within a user’s personal model from contamination introduced when information is aggregated across users. Deliberately negative feedback provides another example; an audience member also raises cultural differences in feedback behavior, without identifying the study.

Versioning presents a less exotic but equally consequential problem. A company changes a one-line policy from honoring something to no longer honoring it. Should training restart from the base model, or update the existing adaptation? How does the system prevent the old policy from returning in answers? Morris speculates that a good synthetic-data strategy might resolve conflicts during dataset construction or omit obsolete documents, but he does not have an established method.

A follow-up asks how proprietary training data should override contradictory pretraining knowledge. Morris’s answer is that changing the storage mechanism does not eliminate the authority problem. If outdated information appears repeatedly, a naive retriever can keep returning it and a naive training pipeline can keep reinforcing it. Learning in weights still requires deciding which information is current and authoritative. The conflict-resolution work remains.

Parameter-efficient updates could also reopen possibilities for federated learning. Sharing gradients across machines becomes expensive when the model is enormous. Morris suggests that exchanging updates for a small trainable component could reduce that burden, especially in RL settings where substantial local work occurs between gradient updates. He has not conducted the proposed federated research; he presents it as an opportunity created by smaller updates.

The next question contrasts specialized knowledge with the idea of a small, largely knowledge-free reasoning engine. A lawyer does not memorize the whole legal code; the lawyer knows how to find and use the relevant material. Perhaps a compact model should similarly learn where to look, especially for information that becomes stale. Morris agrees that much memorized knowledge is unnecessary for a particular application, returning to the Tajikistan example. But separating reasoning from all factual knowledge is difficult. His preference is for models that are strong in the domains their users care about and weaker elsewhere, while still using tools when needed.

The final technical question concerns time. Given information from day one, day two, and day three, should the system concatenate the data, train sequentially, or train separate adaptations and merge them? Morris has no preferred method or reported result. These choices expose the remaining gap between a model that can be fine-tuned once and a model that can reliably keep learning.

Morris closes by describing a new company working on that broader problem and inviting interested users and San Francisco engineering referrals. Its scope is not only temporal information. The goal is to build models that people can teach: models that acquire useful knowledge from their work, preserve the capabilities that still matter, and make that learning available in later interactions.