How does an agent decide what information to remember?

An AI agent should decide what to remember by asking a simple question:

Will this information likely help in a future interaction, task, or decision?

Good memory systems are selective. They do not store every message, tool result, or temporary detail.

1. Remember information with future value

Useful memories are often information that may matter again.

Examples include:

• stable user preferences
• important project facts
• recurring constraints
• decisions that affect future work
• reusable procedures
• lessons from successful or failed tasks

For example:

Useful to remember: The user prefers CSV exports.

Usually not useful to remember: A temporary API latency value from one completed request.

2. Prefer stable information

Information is a better memory candidate when it is unlikely to change frequently.

For example:

• preferred programming language
• project architecture
• team conventions
• recurring output preferences

Highly temporary information may belong in workflow state or short-term memory instead.

3. Consider how important the information is

Some information may be worth remembering because forgetting it would cause repeated work or poor decisions.

For example:

Important: Production deployments require human approval.

Remembering this constraint can affect many future workflows.

A minor intermediate calculation from one task usually has much less future value.

4. Remember repeated patterns

If the same fact or preference appears repeatedly, that is a strong signal that it may deserve memory.

For example:

The user repeatedly asks for:

• concise answers
• Python examples
• CSV exports

Instead of rediscovering these preferences every time, the system may store them as reusable memory.

5. Learn from outcomes

Agents can also remember useful lessons from previous tasks.

For example:

Past experience: A certain API often times out when called with very large batches.

Useful memory: Use smaller batches for that API.

This kind of memory can help future execution without requiring the agent to repeat the same failed approach.

6. Avoid remembering temporary execution details

Many values are useful only while a workflow is running.

Examples include:

• current retry count
• current workflow node
• temporary tool output
• intermediate calculations
• transient error messages

These usually belong in agent state or short-term memory rather than long-term memory.

7. Avoid storing duplicate information

If the same fact is already stored, the system should usually update or reinforce the existing memory instead of creating many copies.

For example:

Instead of storing:

• User prefers Python.
• User likes Python examples.
• Use Python when giving code.

the system may maintain one clear memory:

Preferred code language: Python

This makes retrieval cleaner.

8. Consider whether the information is sensitive

Not every useful piece of information should automatically be stored.

Before creating memory, the system should consider:

• whether retention is necessary
• whether the information is sensitive
• whether the user or organization allows it to be stored
• how long it should be retained
• who is allowed to retrieve it

Memory usefulness does not override privacy or security requirements.

9. Store the right level of abstraction

The system should remember the useful meaning, not necessarily every raw detail.

For example, instead of preserving a long conversation about report formatting, it may store:

Preference: Reports should be concise and begin with an executive summary.

This produces a smaller and more reusable memory.

10. Give memories a clear scope

A memory should be attached to the correct scope.

For example:

• user-level preference
• project-level fact
• tenant-level policy
• task-specific memory
• organization-level procedure

A preference for one project should not automatically affect another unrelated project.

11. Consider confidence and source

Some memories are more reliable than others.

For example:

High confidence: The user explicitly said, “Always export this project as CSV.”

Lower confidence: The agent inferred a preference because CSV was chosen once.

A memory system may store confidence, source, or timestamp information so later retrieval can judge how much to trust it.

12. Check whether newer information replaces older memory

Memories should not accumulate conflicting versions forever.

For example:

Old memory: Project database is PostgreSQL 14.

New information: Project upgraded to PostgreSQL 16.

The system should update or invalidate the old memory.

A practical memory decision

Before storing something, an agent system can evaluate:

• Is it likely to be useful again?
• Is it stable enough to retain?
• Is it important enough to matter?
• Is it already stored?
• Is it safe and appropriate to retain?
• What user, project, or tenant does it belong to?
• Should it expire?
• Should an existing memory be updated instead?

Only information that passes these checks should become durable memory.

In short

An agent should remember information that has clear future value, is sufficiently important or reusable, and is appropriate to retain.

Good memory systems are selective: they preserve useful preferences, facts, lessons, and procedures while leaving temporary execution details in state or short-term memory.