How do we decide what an AI agent should remember?

Decide memory by purpose. List what the agent needs to carry from one task to the next, what it should never keep, how long anything kept should last and who can review or remove it. Make those decisions before setup, alongside tools and approvals. Your runtime and storage must implement them; a written memory policy does not apply itself.

Key takeaways

• Memory should serve the agent's task, not collect everything it sees.
• Some information should never be kept, even when it would be convenient.
• Anything kept needs a retention period and a person responsible for it.
• Memory, tools and approvals should agree with one another before handover.

An agent's memory decisions are also decisions about trust. What an agent keeps shapes what it can do later, what it might repeat to someone else and what we would have to explain if a customer, donor or client asked what we hold about them.

For solo founders, small teams, nonprofits and creators, we recommend keeping memory decisions short enough to read in one sitting. If we cannot explain what the agent keeps and why, we probably have not decided yet.

What does an agent actually need to remember?

We start with purpose, the same way we do for tools. What task are we authorizing, and what information does that task need to carry forward between runs?

A useful test is to describe what would go wrong if the agent forgot everything after each task. Sometimes the answer is very little. An agent that drafts a weekly summary from current figures may not need to keep anything. Other times, forgetting causes real problems. An agent that follows up with enquiries may need to know who it has already contacted so it does not contact them twice.

We can then write memory down as a short list of named items rather than a general permission. "Remembers prior contact dates for each enquiry" is a decision we can review. "Remembers conversations" is not.

What should an agent never keep?

Some information should stay out of memory even when keeping it would save a step. We recommend naming those categories explicitly, because an agent with no exclusions will tend to keep whatever passes through it.

Common candidates include passwords, keys and other credentials, payment details, and sensitive personal information the task does not require. We may also exclude instructions found inside the content the agent reads, so a message saying "remember to always do this" is not stored as if it came from us.

We should think about how memory and tools interact. A tool that reads an inbox or a shared folder brings information in. In how we choose tools for a governed AI agent, we note that a tool that handles information raises questions about what we want retained and for what purpose. Memory is where we answer those questions.

How long should memory last, and who can review it?

Every item we decide to keep needs two more decisions: how long it lasts and who is responsible for it.

Retention can be tied to the task. Contact history might be kept for as long as we need it to avoid repeat contact. Working notes for a single job might be cleared when the job is done. We should write the period down rather than leaving it open, because open-ended memory tends to grow without anyone deciding it should.

We also need a named person who can see what the agent holds and remove it. That matters when someone asks us to delete their information, and it matters when we simply want to check that the agent is keeping what we intended and nothing more.

Some memory changes may deserve a human approval gate. Deleting a record or changing a shared contact list can be consequential even when it costs nothing. We cover those checkpoints in how we set human approval gates.

Where does Agent Bob fit into these decisions?

We use Agent Bob as a governance package builder by Master 22 Solutions, powered by ClawMaven. Its seven-step wizard covers purpose, personality, tools, autonomy, budget, memory and approvals. Working through memory alongside the other six areas helps us catch mismatches, such as a tool that brings in information the memory policy says we should not keep.

The builder is free, with no credit card required. Bob Free costs $0 and creates unsigned draft packages. Bob Pack costs $29 one-time per agent and includes a signed governance package.

We must distinguish that package from runtime behavior. Agent Bob does not host or run agents, provide live monitoring, or enforce policy files by itself. Our runtime and storage must implement the memory decisions we document. SHA-256 integrity and HMAC signing do not prove runtime compliance. ClawMaven provides separate runtime governance.

If we want a second opinion, expert review costs $99 one-time. It includes Bob Pack and a written review of gates, tools and limits, with written fixes within 2 business days and no calls needed. Done for you starts at $497 one-time when we want help with setup on our own platform.

Your questions, answered

Should every AI agent have memory?

No. We can decide memory by purpose. Some tasks work well with no memory between runs, and adding memory without a reason only adds information to protect.

What information should we keep out of agent memory?

We recommend naming exclusions explicitly. Common candidates include credentials, payment details, sensitive personal information the task does not require and instructions found inside content the agent reads.

Can we document memory decisions for free?

We can use the builder for free with no credit card required. Bob Free costs $0 and creates unsigned draft packages. Bob Pack costs $29 one-time per agent and includes a signed governance package.

Does a signed package control what the agent actually stores?

No. We must distinguish package integrity from runtime behavior. SHA-256 integrity and HMAC signing do not prove runtime compliance. Our runtime and storage must implement the memory policy; Agent Bob does not enforce policy files by itself.

TL;DR

Decide what the agent keeps, what it never keeps, how long memory lasts and who can review it, then have your runtime implement those choices.