The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Memory layers prevent prompt bloat by keeping an agent’s history outside the prompt, distilling part of it into compact records, retrieving what matches the current task, and assembling a budgeted working context for each model call. The full store never has to travel with every request. Consolidation and forgetting are the processes that stop the store itself from growing without limit, and they carry a cost. Each one decides what the agent can no longer see, and a faulty summary or a deleted episode can change later behavior as much as a missing fact would.
Separate the store from the prompt
Most confusion about agent memory comes from treating “memory” as one bucket. The useful split is between what is stored and what is sent. Four parts do the work.
As an Amazon Associate I earn from qualifying purchases.
Raw record
Episodes, conversation logs, or notes extracted from them. This layer lives outside the prompt and is not sent with a request by default. Once summaries exist, it is the only place the original detail survives, which is why it matters for everything below.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Durable memory
Compact summaries, user preferences, and recurring patterns distilled from the raw record. This is the layer that consolidation rewrites, and it is normally much smaller than the record it came from.
#1 Best Overall
Retrieval
The step that selects candidate memories for the current task. Systems rank on different signals: recency, relevance to the request, entity relations, or a learned or designed policy for when to retrieve and how much to inject.
Working context
What actually enters the model call: instructions, relevant session state, and the selected long-term facts, fitted to a token budget. Microsoft’s multi-agent reference architecture describes working memory in these terms, as a composition of the system prompt, relevant short-term memory, and retrieved long-term facts. The same architecture places an existing runbook or documented workflow in a knowledge source or tool rather than in memory, so procedures are not paraphrased into a memory store where steps can be lost.
How a request stays small
A typical assembly for one model call follows this order:
- Fixed instructions load first.
- A short durable summary is injected, so the model knows what prior material exists.
- Retrieval selects records relevant to the current request.
- Session state and the selected facts are added.
- The result is trimmed to the token budget.
The budget is what forces selection, but it does not prove the selection was right. If retrieval misses a record, nothing in the call signals that the record existed.
The OpenAI Agents SDK documentation, under “Agent memory,” describes this pattern concretely. It states: “At the start of a run, the SDK injects a small summary (memory_summary.md) of generally useful tips, user preferences, and available memories into the agent’s developer prompt.” The documentation also describes progressive disclosure, so the summary is a starting point rather than the entire store. This is one product’s documented design, not a standard every memory layer follows.
What consolidation does
Consolidation reduces duplication and turns episode-level material into compact, reusable forms. It is what lets a store stay useful as it grows. The sources describe three different approaches, which differ mainly in when consolidation runs and what it is for.
A separate post-run phase
In the OpenAI Agents SDK design, processing happens in stages after a run. One phase extracts conversation summaries and raw memories. A consolidation phase then reads the raw memories, consults the summaries when it needs them, and writes recurring patterns into MEMORY.md and memory_summary.md. Consolidation is therefore a distinct pass that writes to the summary layer, not a rewrite that happens at every message.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Context-dependent decisions
The MemCon preprint (Jiang et al., 2026, arXiv) treats memory operations as decisions made in context: whether to retrieve, whether to inject a distilled plan, whether to consolidate, and whether to forget. In its own evaluation, the authors report a maximum improvement of 15.2 percentage points in task success and 5–20% lower token consumption. These are the authors’ results on their stated benchmarks, not expected gains for a typical deployment.
Deduplication and sleep-phase proposals
A May 2026 Microsoft Research publication page describes a proposed architecture with sleep-phase consolidation, interference-based forgetting, engram maturation, reconsolidation on retrieval, entity knowledge graphs, and hybrid multi-cue retrieval. Its most concrete consolidation result is narrower. Deduplication-based consolidation on a VSCode issue-tracking dataset reported 97.2% retention precision alongside a 58% store reduction. On LongMemEval, the page reports 70.1% and 71.2% raw-retrieval accuracy at a 200K-token context budget, and notes that the 95% confidence intervals overlap, so the gap should not be read as a clear win. These are paper-specific results for a proposal, and they do not show that deployed agents already have these mechanisms.
How forgetting is implemented
In practice, forgetting takes two forms: deletion under a rule, and selective retention, where a memory is kept but made less likely to surface. Designs also differ on whether the original record survives.
Capacity and recency deletion
The OpenAI Agents SDK documentation gives the clearest rule in the sources. When recent raw memories exceed the configured consolidation limit, the system keeps memories from the newest conversations and removes older ones, using each conversation’s last update time as the recency signal. Age, not importance, decides removal. A standing preference stated once in a conversation that is never updated again is among the first candidates to go once the limit is reached.
Free tools Windows power users keep installed
One-click scans. No signup required.
Selective retention
Some designs never delete a memory outright. The Microsoft Research proposal lists interference-based forgetting, a mechanism tied to how memories compete with one another rather than to age alone. Demotion of this kind keeps a record in storage while making it less likely to be retrieved. The sources do not establish that the OpenAI SDK or MemCon work this way, so treat it as a property of that proposal only.
Best Value
What “automatic” means
Here, “automatic” means a configured policy runs without a user request. It does not mean the system understands what a person will value later. The SDK’s rule is a limit and a timestamp. The decision rules in the MemCon and proposal papers are described in their own evaluations, and their behavior on other tasks is not established. Treat automatic forgetting as a policy you can read and test, not as judgment.
Why this cuts bloat, and where it breaks
The store can keep growing without the prompt growing, because only the assembled slice enters the call. Pruning then keeps the store manageable. The trade-off is that every omission is silent: the agent is not told that a relevant record was left out. The common failure modes are these:
- Retrieval miss. The relevant record exists but ranks below the budget cut, so the agent acts as if it never happened.
- Merged distinctions. A summary folds two cases together and drops the one detail that separated them.
- Lost originals. Once an episode is deleted and only a summary remains, a bad summary cannot be checked against its source.
- Recency mistakes. A rule that favors newer conversations removes older material that is still correct.
Stale and faulty memories shape later behavior
Retrieved memory is not passive context. A 2026 ACL Anthology paper by Xiong et al. reports what it calls an experience-following property: when a task’s input is highly similar to the input of a retrieved memory record, the agent’s output often becomes highly similar too. A wrong memory that surfaces for a similar task can therefore steer the agent toward the same wrong output. The claim is limited to that paper’s findings, but it is enough to treat retrieval quality as an output-quality problem.
Recommended Free Tools
A May 2026 preprint, Useful Memories Become Faulty When Continuously Updated by LLMs, tests the cost of consolidating too eagerly. In its controlled ARC-AGI Stream environment, agents that preserved raw episodes by default reported double the accuracy of counterparts forced to consolidate after every interaction. Agents with consolidation disabled entirely matched the automatic-consolidation regime. The finding comes from one controlled setting and should not be generalized into a claim that consolidation is harmful. It does show that how often consolidation runs has measurable consequences.
How the approaches compare
The table places the systems discussed above on the same axes. “Not stated” marks a detail the cited source does not give.
| System or source | Retained material | Selection and retrieval | When consolidation runs | Forgetting rule |
|---|---|---|---|---|
| OpenAI Agents SDK, documented design | Raw memories, conversation summaries, MEMORY.md, memory_summary.md |
Small summary injected at run start; progressive disclosure for further detail | Separate post-run extraction and consolidation phases | When raw memories exceed the configured limit, keep newest conversations and remove older ones, by last update time |
| MemCon (Jiang et al., 2026, arXiv preprint) | Distilled plans and consolidated memories; detailed retention format not stated | Context-dependent decision on whether to retrieve and inject a distilled plan | Context-dependent decision; fixed schedule not stated | Context-dependent decision to forget; specific rule not stated |
| Human-inspired memory architecture (Microsoft Research publication page, May 2026; proposal) | Engrams and entity knowledge graph | Hybrid multi-cue retrieval | Sleep-phase consolidation; reconsolidation on retrieval | Interference-based forgetting |
| Continuously updated memory study (Useful Memories Become Faulty When Continuously Updated by LLMs, May 2026 preprint) | Raw episodes preserved by default in the better-performing arm | Not stated | Forced after every interaction, automatic, or disabled | Not stated |
| Microsoft multi-agent reference architecture | Short-term memory and retrieved long-term facts; runbooks kept in knowledge sources or tools | Retrieved long-term facts composed into working memory | Not stated | Not stated |
Designing for safe pruning
The practices below follow from the evidence above. They are design recommendations, not results reported by any one system.
Quick Recap
- Keep the raw record, or an archive of it, for a defined period so every distilled memory can be traced to its source conversation.
- Store provenance with each consolidated item: the source identifier, a timestamp, and the rule that produced it.
- Trigger consolidation on a condition such as a size limit rather than after every interaction, and compare results against a run with consolidation disabled on your own task set.
- Separate demotion from deletion. Move a memory to an archive it can be restored from before removing it from the store.
- Protect durable preferences and rules from a recency cap, and check that newer records actually replace the ones they contradict.
- Fix a token budget for injected memory and log what was injected on each call, so a missed record can be diagnosed.
- Re-test retrieval after every change to a pruning rule, since a rule that looks harmless can remove the one record a task needs.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
