You have seen it happen a dozen times: an AI agent has the full API documentation in its prompt, yet it still fails to paginate a search result or misses a critical parameter in a multi-step workflow. The agent does not lack the knowledge of the API; it lacks the proficiency to execute it. Whether it is splitting a bill, finding a specific song, or reconciling orders across nine different simulation apps, the failure point is rarely a lack of information. Instead, it is a failure of execution—a missed detail in the trajectory that leads to a cascading error. This gap between knowing a tool and mastering its use has become the primary bottleneck for autonomous agents.

The Architecture of Uncompressed Agentic Memory

To bridge this proficiency gap, researchers have introduced ACE (Agentic Context Engineering) and ALTK-Evolve. Both systems move away from the traditional approach of summarizing past experiences, which often strips away the very nuances required for successful execution. Instead, they employ a philosophy of uncompressed memory. By preserving past trajectories as individual, detailed guidelines rather than condensed summaries, these systems avoid two critical failure modes: brevity bias and context collapse. Brevity bias occurs when a model attempts to optimize instructions into a short, general form, inadvertently deleting the specific edge-case details that make the instruction work. Context collapse happens when the model is forced to rewrite its context at every step, leading to a gradual erosion of detail.

Both ACE and ALTK-Evolve transform past experiences into reusable lessons. These lessons are not treated as static text but as dynamic objects with a support count. The support count tracks how many independent episodes generated a specific guideline. For instance, a lesson discovered across five different tasks is treated as a distinct, high-confidence object compared to one found only once. This allows the system to maintain a library that balances high-frequency general rules with low-frequency, high-impact exceptions, ensuring that the agent does not forget how to handle a rare but critical error.

The construction process in ACE follows a rigorous loop: Generator $\rightarrow$ Reflector $ ightarrow$ Curator. This pipeline expands the playbook through incremental delta updates, ensuring the memory stays current without requiring a full rebuild. To manage the growth of this library, the system uses embedding techniques to identify semantically similar lessons and remove redundancies. When lessons are merged, the surviving guideline inherits the combined support counts of all merged entries, preserving the historical weight of the experience. ALTK-Evolve takes this a step further by using embedding-based clustering to consolidate similar lessons while maintaining the exact count of successful and failed cases. These guidelines are then categorized into three functional types: Strategy, Recovery, and Optimization.

Every guideline in these systems is tagged with causal attribution—a clear record of which action led to which result—and provenance, which links the lesson back to the original execution path. By storing these experiences at the subtask level, the systems enable cross-application transfer. An agent that learns how to recover from a specific API timeout in one application can apply that same recovery logic to a similar subtask in an entirely different app.

The Delivery Dial and the Cost of Context

While ACE and ALTK-Evolve share a similar memory storage philosophy, they diverge sharply in how they deliver that memory to the LLM during inference. ACE utilizes a fixed delivery method, injecting the comprehensive playbook into the context at every single step regardless of the model size or task complexity. While this simplifies the memory construction process, it creates a massive token overhead, as the model must process the entire library for every turn of the conversation.

ALTK-Evolve introduces what can be described as a delivery dial. Instead of a fixed injection, it treats context delivery as a tunable parameter. The system combines a set of fixed core guidelines—those validated across numerous episodes—with a small selection of task-specific guidelines chosen via cosine similarity or LLM-guided priority weighting. This ensures the model is not overwhelmed by irrelevant information and only references the lessons most applicable to the current state of the task.

This selective delivery is critical because of the concept of model headroom. High-capacity models can handle larger contexts without losing focus, but smaller models often suffer from information interference when the context becomes too bloated. ALTK-Evolve adjusts the volume of injected memory based on the model's capacity. When the model has sufficient headroom, it can receive a broader set of instructions; when it is constrained, the system tightens the filter to prevent the model from becoming confused by contradictory or irrelevant guidelines. The result is that while the underlying memory store remains the same, the efficiency of the inference process changes radically.

Benchmarking Performance Across Model Tiers

To validate these strategies, the systems were tested using a ReAct code agent in the AppWorld `test_normal` environment, consisting of 168 tasks. The results revealed a striking correlation between model size and the effectiveness of selective delivery. When using a high-performance model like DeepSeek-V3.2, ALTK-Evolve outperformed ACE across all metrics, including Easy, Hard, and Overall categories. More importantly, the inference cost for ALTK-Evolve was only about 40% of the tokens used by ACE. This proves that for powerful models, selective delivery does not just save money—it actually improves accuracy by reducing noise.

The disparity was even more pronounced with the smaller gpt-oss-120b model. In terms of raw accuracy, the two systems were nearly identical, with ALTK-Evolve scoring 56.0 and ACE scoring 54.8, a difference that falls within the margin of noise for the benchmark. However, the cost difference was staggering: ALTK-Evolve used approximately one-seventh of the tokens required by ACE. For smaller models, removing unnecessary context is not just an optimization; it is the only viable way to maintain performance while controlling costs.

An analysis of task difficulty further highlighted this trend. For the gpt-oss-120b model, the full injection method used by ACE was slightly more effective for easy tasks. However, for hard tasks, the curated retrieval method of ALTK-Evolve was significantly superior. This suggests that while a small model can skim a large list of simple instructions, it requires a precision-engineered set of lessons to solve complex, multi-step problems. DeepSeek-V3.2 showed a similar pattern, where ACE held a slight edge in medium-difficulty tasks due to its massive context window, but ALTK-Evolve remained the superior choice for overall efficiency and peak performance.

Designing agent memory is no longer just about how much the agent can remember, but how precisely that memory is delivered. For developers deploying high-capacity models like DeepSeek-V3.2, the strategy should be to maximize the model's headroom by providing a comprehensive yet curated set of instructions. For those utilizing smaller, more efficient models like gpt-oss-120b, a strict combination of core guidelines and selective retrieval is mandatory to avoid context interference and astronomical token bills. By calibrating the delivery mechanism to the model's specific capacity, developers can achieve a state where performance is maximized and costs are minimized, turning the agent's memory from a token liability into a strategic asset.