AI Agent Memory: How Agents Remember Your Preferences

You told your agent never to chase a certain client on Fridays, to sign off as “The team” rather than with your first name, and to show amounts excluding tax in reports. Three weeks later, you'd rather not have to say it again. That's what memory is for.

Memory is one of the most tangible differences between a one-off assistant and a real working agent. This article explains, without jargon, why an AI model has no memory by nature, how you give it one, and how it works on Future Agent.

Why AI forgets by default#

A language model keeps nothing from one use to the next. Each time it works, it receives a set of texts (the instruction, the data, the conversation history) and produces a response. Once the response is produced, it retains nothing. If you talk to it again tomorrow, it no longer knows what you told it yesterday, unless that information is put back in front of it.

On top of that, the amount of text it can read at once is limited. So you can't simply hand it the entire history every time: you have to choose what's useful.

An agent's memory is therefore a system that stores information between runs and selects the most relevant pieces when the agent is working.

The different kinds of memories#

Not everything is remembered the same way. There are generally several categories:

Some memories matter more than others. An explicit preference you gave should outweigh a detail noted in passing. That's why memory systems assign importance to items and let you pin some so they're always taken into account.

Individual memory and shared memory#

An agent's own memory#

Each agent has its own memory. Your quote follow-up agent remembers past follow-ups, replies received and your tone corrections. Your weekly report agent remembers previous weeks' figures, which lets it make comparisons. These memories only serve the agent in question.

Your account's shared memory#

Some information applies to all your agents: your company name, how you sign off, your opening hours, your list of sensitive clients, your closure days. Repeating it in every agent would be tedious and a source of inconsistencies.

On Future Agent, your account's shared memory is consulted by all your agents. You manage it from a dedicated page in the dashboard. It stays strictly private to your account: no other account can access it.

How memory is used during a run#

On Future Agent, every run follows the same cycle.

Before working: “What you already know”#

At the start of each run, the agent receives a section gathering what it needs to know, selected in order of priority:

1. pinned items;
2. preferences and facts;
3. the account's shared memory;
4. the latest run summaries;
5. the results of a search across the rest of the memory and your documents, based on the agent's goal and the day's data.

This selection fits within a limited budget: the agent only sees what's useful, not the entire history. The run log shows how many memory items were consulted, so you know what the agent relied on.

While working: save and search#

During a run, the agent can save information it will need later (“this client prefers to be contacted by phone”) and search its memory when it's unsure (“have I already followed up with this person?”).

After working: remember or forget#

When a run succeeds, a summary is kept, which builds up the history. When it fails, memories created during that run are removed: this prevents the agent from retaining information from unfinished or faulty work.

Context files#

Part of what the agent needs to know already exists as documents. Rather than copying them into the instruction, you can add them as context files:

• PDF, Word, Excel, CSV, text, Markdown, JSON and images, up to 25 MB per file;
• the document is split into passages and indexed;
• during a run, only the relevant passages are offered to the agent.

In the dashboard, just drop a file on an agent's card, or use the “Context” button. The “Memory & files” tab in the agent's details lists what it has remembered and the documents it can consult.

Example uses:

• your price list for an agent that prepares quotes;
• your terms and conditions for an agent that answers customer questions;
• a job description for an agent that screens applications, like the Application screening template;
• your internal handbook for an agent that answers the team's questions, like the Internal Q&A template.

Memory guardrails#

Poorly kept memory quickly becomes a problem: outdated information, duplicates, data that shouldn't be there. Future Agent applies several rules:

• secrets are rejected: a password or access key cannot be saved as a memory;
• near-duplicates are merged, so the same preference doesn't pile up ten times;
• old, low-importance items are pruned beyond a certain volume, while pinned items and your notes never are;
• memory is isolated per account;
• memory text counts toward your storage, visible in the dashboard gauge (1, 25 or 200 GB depending on your plan).

Staying in control of what the agent remembers#

Memory is only useful if you can review and correct it. A few good practices:

Say explicitly what to remember#

“Remember that we don't work with the public sector” is more reliable than a remark slipped into a correction. Phrase your preferences as rules.

Pin the essentials#

Rules that must apply to every run deserve a pin: exclusions, tone, format. They take priority, however many other memories there are.

Tidy up now and then#

Once a quarter, open the “Memory & files” tab of your most-used agents. Delete what's no longer true (a client no longer in dispute, an old price). Replace outdated documents.

Share what applies to everyone#

If you keep repeating the same information to several agents, move it to shared memory. It will be consistent everywhere and you'll have only one place to update.

Memory in agent chains#

When several agents work together, memory also acts as a relay. A downstream agent can find, in its searches, relevant memories left by the agents before it in the chain. For example, in the Monitoring, writing and publishing chain, the agent that writes the article builds on what the monitoring agent found. We explain how this works in our article on multi-agent workflows.

A concrete example over several weeks#

Take an agent that drafts replies to a restaurant's Google reviews.

• Week 1: you correct two drafts. “Sign off as ‘The Corner Bistro team,’ never with a first name.” “Never offer a discount or freebie in a public reply.” Both rules are saved as preferences, and you pin them.
• Week 3: an unhappy customer comes back to leave a second review. The agent finds the reply already posted in its summaries and avoids repeating the same wording.
• Week 6: you add the new autumn menu as a context file. When a review mentions a dish, the agent can refer to it by its proper name.

None of this required rewriting the original instruction. Related template: Google review replies.

What memory doesn't do#

To avoid misunderstandings:

• it doesn't replace a good brief: the main rules belong in the agent's instruction; memory complements it, it doesn't form its foundation. See how to write a good brief;
• it doesn't guarantee infallibility: an agent can misread an ambiguous memory, which is why clear phrasing matters;
• it isn't a database: for structured lists (clients, orders, inventory), use a spreadsheet, a CRM or a shared table that the agent reads on every run.

In short#

• An AI model has no memory by nature: you give it one by storing and selecting useful information.
• Preferences, facts, summaries, notes and documents are kept and reused on every run.
• Each agent has its own memory; shared memory is available to the agents in your account, and only to them.
• Context files save you from copying your documents into the instruction.
• Pin the essentials, tidy up now and then, and phrase your preferences as rules.

To explore the platform's other building blocks, see the Features page or our introduction to AI agents.