How does an agent decide what information to forget?

An AI agent should forget information when keeping it no longer provides enough future value to justify the cost, risk, or confusion of retaining it.

Good memory systems do not only decide what to remember. They also remove, expire, replace, or deprioritize memories that are no longer useful.

1. Forget information that is no longer relevant

Some information matters only for a temporary task.

For example:

• a one-time search result
• an intermediate calculation
• a temporary error message
• a completed task's retry count

Once the task ends, these details may have little future value.

They can usually be removed instead of becoming durable memory.

2. Forget stale information

Memories can become outdated.

For example:

Old memory: Project uses PostgreSQL 14.

Later:

New information: Project upgraded to PostgreSQL 16.

The old memory should be replaced or invalidated so it does not continue influencing future decisions.

3. Remove duplicate memories

Keeping many versions of the same fact can make retrieval noisy.

Instead of storing:

• User prefers Python.
• User likes Python examples.
• Use Python for code examples.

the system can preserve one clear memory:

Preferred code language: Python

Deduplication keeps memory smaller and easier to retrieve.

4. Expire time-sensitive memories

Some information is useful only for a limited period.

Examples include:

• temporary availability
• short-lived preferences
• expiring credentials metadata
• temporary project assignments
• session-specific constraints

These memories can be given an expiration time.

After that point, they should either be removed or treated as needing fresh verification.

5. Forget memories that are rarely useful

A memory that is repeatedly stored but almost never retrieved may not justify permanent retention.

A system may track signals such as:

• last time the memory was used
• how often it is retrieved
• whether it improved decisions
• whether newer information has replaced it

Low-value memories can then be removed or archived.

6. Remove memories that are incorrect

An agent may sometimes store a wrong inference.

For example:

Stored memory: User always wants PDF output.

Later the user says:

Correction: Use CSV unless I specifically ask for PDF.

The incorrect memory should not remain active.

Memory should be correctable.

7. Prefer replacement over keeping conflicting versions

When a newer authoritative fact supersedes an older one, keeping both can create confusion.

For example:

Old: Deployment region = us-east-1 New: Deployment region = ap-south-1

If the new value is confirmed, the old one should normally be replaced rather than retrieved alongside it.

In some systems, the old version may remain in an audit history while no longer being treated as active memory.

8. Forget information that creates unnecessary privacy risk

Some information may be technically useful but inappropriate to retain.

A memory system should consider:

• whether the information is sensitive
• whether retention is necessary
• whether the user or organization permits storage
• how long it should be retained
• who is allowed to access it

Data minimization is an important part of memory design.

9. Forget information outside its valid scope

A memory may become invalid when its scope ends.

For example:

A temporary project preference should not remain active after the project is finished.

Similarly, information belonging to one user, tenant, or project should not be reused outside that scope.

10. Summarize instead of keeping every detail

For long histories, forgetting does not always mean deleting everything.

Several detailed memories can sometimes be compressed into one useful summary.

For example, instead of storing ten separate troubleshooting episodes, the system might retain:

Summary: Most failures were caused by expired credentials; credential validation should happen early.

This preserves the useful lesson while removing unnecessary detail.

11. Use importance and confidence

Important, high-confidence memories may deserve longer retention.

Low-confidence or weakly inferred memories may expire sooner.

For example:

High confidence: The user explicitly stated a permanent preference.

Low confidence: The agent inferred a preference from one interaction.

Retention policy can reflect this difference.

12. Forgetting may mean deletion, expiration, or lower retrieval priority

Not every memory system uses literal deletion.

A memory may be:

• permanently deleted
• marked expired
• replaced by a newer version
• archived
• assigned lower retrieval priority
• kept only for audit history

The important point is that outdated or low-value information should stop influencing normal agent decisions.

A practical forgetting decision

A memory system can periodically ask:

• Is this information still relevant?
• Is it still correct?
• Has newer information replaced it?
• Has it expired?
• Is it duplicated elsewhere?
• Is it sensitive and no longer necessary?
• Has it been useful recently?
• Does retaining it improve future decisions?

If the answer is mostly no, the memory is a candidate for removal or deactivation.

In short

An agent should forget information when it becomes stale, irrelevant, duplicated, incorrect, expired, unnecessarily sensitive, or no longer useful enough to influence future tasks.

Effective forgetting keeps memory accurate, compact, safe, and relevant instead of allowing old information to accumulate forever.