Can an AI agent get smarter just by rewriting its own notes, or does it need its brain retrained?

This explores two ways to make an AI agent better over time: lock the model's weights and let it improve by rewriting text it reads (memory, notes, context), or train the weights themselves end to end. The corpus has no head-to-head test of the two. It does have evidence for what the frozen-plus-text approach can do, what sits between the two, and where the text approach breaks.

The case for the frozen approach is stronger than you might expect. Agents that keep memory as causal abstractions (what happened, plus the conditions under which the lesson applies) beat generic reflection by 23 points on repeated trials. They also gain 4-17 points when moved to new environments, all without updating any weights (Can frozen language models continually improve through memory structure alone?). So the shape of the text state matters a great deal. The other design choice is who edits that state. One paper trains a small RL-based manager to prune and preserve context for a frozen agent. It finds the best policy depends on the agent: strong agents do better with high-fidelity context, and weaker ones need aggressive compression (Can an external manager handle context for frozen agents?). In that setup training still happens, but it moves out of the executor and into a side component. The same move shows up in Recursive Language Models. They keep a long prompt in a Python environment and query it with code, and they handle inputs about 100x beyond the context window with no retraining (Can models treat long prompts as external code environments?). Planning before execution, as in ReWOO, likewise separates reasoning from tool output without touching weights (Can reasoning and tool execution be truly decoupled?).

Between the two sits representation finetuning. It freezes the weights but learns small interventions on the model's hidden states, and its low-rank variant beats LoRA while using 10-50x fewer parameters (Can editing hidden representations beat weight updates for finetuning?). That makes the choice a spectrum of where you place the edit: text outside the model, activations inside it, or the weights themselves. A different paper puts the cost of moving along that spectrum in compute terms. It argues the long-context bottleneck is the compute needed to turn old context into internal state, and that more consolidation passes help on harder reasoning (Is long-context bottleneck really about memory or compute?). Text notes stay cheap because nothing gets consolidated into the model. The price is that the model has to re-read them every time.

The main risk of editable text is what happens when a model rewrites its own state repeatedly. In the DELEGATE-52 study, even frontier models corrupt about 25% of document content over long relay workflows, and the degradation never plateaus (Do frontier LLMs silently corrupt documents in long workflows?). Weaker models visibly delete content, while frontier models corrupt it in ways that keep the surface intact and are harder to spot (Does model capability change how documents degrade?). That study tests document editing, not agent memory specifically. Still, it suggests a memory file that a frozen model keeps rewriting could drift without anyone noticing. Text state is also an attack surface. A crafted prompt can steer a planner-executor system before any downstream defense runs, raising malicious success by up to 55% (Can prompts alone reshape multi-agent workflows without system access?).

The corpus suggests a trade. Frozen executors with editable text are cheap, inspectable and portable across tasks, and the quality of what gets written down drives the gains. Their ceiling is how faithfully the frozen model can read and maintain that text over many rounds. Fine-tuning changes what the model itself can do, but the corpus offers no evidence on how it compares in results or cost.