The current race to expand context windows has led many developers to a dangerous assumption: that more information always equals better performance. In the quest to build autonomous agents, the prevailing strategy has been to dump as much historical data and as many instructions as possible into the prompt, treating memory as a binary feature that is either on or off. However, as agents move from simple chat interfaces to complex multi-step environments, this brute-force approach is hitting a wall. Developers are finding that adding more memory often leads to a plateau or, worse, a degradation in reasoning as the model becomes overwhelmed by the very data meant to guide it.

The Non-Parametric Loop of ALTK-Evolve

To solve this, the ALTK-Evolve framework introduces a shift in how agents learn from experience. Rather than relying on traditional fine-tuning, which requires expensive weight updates and human-labeled datasets, ALTK-Evolve implements a non-parametric learning loop. The system operates by analyzing execution trajectories—the step-by-step records of an agent attempting a task. By examining both successful completions and failures, the framework autonomously extracts actionable behavioral guidelines. These guidelines are not mere copies of past conversations but are refined strategies and warnings about specific edge cases.

These extracted instructions are integrated into a reusable guideline set that is injected into the model during the inference phase. Because the system does not modify the underlying neural network weights, it possesses high portability. The researchers tested this approach across eight different models, ranging from 30B dense models to massive Mixture-of-Experts (MoE) architectures, ensuring the framework could be applied regardless of the specific model architecture. This allows developers to swap models without losing the accumulated knowledge stored in the guideline sets.

To validate the effectiveness of this memory injection, the team utilized the AppWorld benchmark. This environment simulates a complex ecosystem of nine applications, including calendars, messaging, and payment systems, featuring a total of 585 multi-step tasks. These are split into 168 general tasks and 417 challenge tasks. Performance was measured using two primary metrics: Task Goal Completion (TGC), which tracks whether the agent finished the job, and Scenario Goal Completion (SGC), a stricter metric that requires the agent to pass every single variable in a scenario without a single error. SGC is particularly critical as it reveals how well a model handles the rare, fragile edge cases that typically break autonomous agents.

The Capacity Paradox and the Three Patterns of Memory

The core discovery of the ALTK-Evolve research is that memory is not a universal utility but a capacity-dependent variable. The study identified three distinct patterns in how models respond to memory injection. The first is the High-Capacity pattern, seen in models like DeepSeek-V3.2 (a 671B MoE model). These models possess enough internal cognitive headroom to absorb vast amounts of instructions. When provided with the full set of guidelines, DeepSeek-V3.2 saw its TGC increase by 9.5 percentage points and its SGC jump by 16.1 percentage points. For these models, more information directly translates to better handling of edge cases.

The second pattern is the Selective-Response pattern, exemplified by gpt-oss-120b (a 117B MoE model). For this model, injecting the full guideline set provided negligible gains and increased token costs by approximately 50%. However, when the team switched to a selective retrieval method—providing only the core guidelines and the specific information relevant to the current task—the TGC surged by 16.1 percentage points while increasing token usage by only 5%. This reveals a critical tension: for mid-tier models, too much memory creates noise that drowns out the signal, leading to information overload.

Finally, the researchers observed a Saturation pattern in models like GLM-5 (a 745B MoE model). In these cases, memory injection yielded no measurable performance gain. This suggests that the model had either reached its theoretical performance ceiling for the task or that the provided guidelines did not address the root cause of the model's failures. This proves that simply adding more context cannot fix fundamental reasoning deficits in certain architectures.

This divergence in performance highlights a structural reality of LLMs. The ability to utilize memory is governed by a combination of the model's internal architecture, its context window size, and the quality of the guidelines. For developers, this means the strategy for memory injection must be tailored to the model's tier. Strong models can handle a full-set injection, while weaker models require a curated, retrieval-based approach to avoid performance collapse.

Engineering Around Token Inflation and Caching

While memory injection improves accuracy, it introduces a significant economic and technical burden: token inflation. Most agents operate on a ReAct (Reasoning and Acting) loop, where the model thinks, acts, observes, and repeats. If a large set of guidelines is injected at every step, the same static instructions are sent to the API repeatedly. This does not increase the number of steps the model takes—analysis of DeepSeek models showed that the average ReAct trajectory remained constant at 18 to 19 steps—but it drastically increases the volume of input tokens per step.

To mitigate this, the research emphasizes the use of prompt caching. By fixing the static portion of the guideline set as a prefix, the system can avoid re-processing the same tokens in every turn of the ReAct loop. However, this requires precise engineering. Because cache hits are sensitive to the exact string of text, a single misplaced space or a modified word in the prefix can invalidate the entire cache, forcing the model to re-process all tokens and spiking costs.

Looking forward, the researchers argue that current memory retrieval, which relies heavily on cosine similarity, is insufficient. Cosine similarity measures textual likeness but not functional utility. The next evolution in agent memory will be the Learned Selector—a mechanism trained on actual success signals to predict which specific guideline will actually lead to a successful outcome. For the lowest-tier models that cannot extract their own knowledge, the team suggests a Teacher-distilled memory approach, where a high-capacity model refines the guidelines before they are passed down to the smaller agent.

Ultimately, the transition from treating memory as a feature to treating it as a capacity problem changes the developer's role from a data provider to a capacity tuner.