One file per client: how to design the memory your agents share

The problemYour agents forget what each client asked for, ruled out or learned with you, and your team has to repeat it over and over.

Tuesday, 4:50 p.m. At a creative agency, Sofía, the account director, reviews a campaign proposal for a beverage brand the agency has worked with for three years. The copy is good. The problem is the headline: it uses the word "natural," which the client's legal team banned a year ago over a regulatory issue. That restriction lived in an email that only the executive who used to run the account remembers. The copywriting agent had no way of knowing. What was missing was per-client memory: a file where that kind of thing never gets lost.

This article explains how to design that file, which sections it should have and why each agent should read only the part that applies to it.

Why your agents forget what matters about each client

In a services business, what makes the work great for a client is rarely in the contract. It is in the details: what tone they like, which words they hate, which campaign worked, who really approves things on their side, which topics are sensitive.

That knowledge usually lives in three places: email, the memory of whoever runs the account and old slide decks. A new agent, like a new hire, starts from scratch. And if each agent consults a different document, each one will have a different version of the client.

The broader solution is a company brain, the shared memory of the business, which we explain in your company brain. The client file is its most concrete piece and, for many companies, the one with the biggest payoff.

The seven sections of a client file

A good file is a single document per client, with fixed sections. The structure matters as much as the content: if every file has the same sections, any agent knows where to look.

1. Brand: voice, tone, approved and banned words, color palette, examples of approved work.
2. Business: what they sell, how they make money, their competitors, their peak season, their goals for the year.
3. Audiences: whom the client speaks to, with what messages and on which channels.
4. Campaigns: what has been done, with what qualitative result and what is in progress.
5. Lessons learned: what was discovered by working together: "prefers two options, not five," "short videos get approved faster."
6. Stakeholders: who is who on the client side, who approves what, how they like to be presented to.
7. Restrictions: what must never be done: legal issues, banned mentions, unauthorized claims, competitors that are never named.

The restrictions section deserves special attention. It is short, but it is the one that prevents expensive mistakes, like Sofía's.

Each agent reads only its own sections

Here is the most important design decision. The file is shared, but not every agent reads all of it. Each agent receives only the sections it needs for its task.

This has a technical name, context engineering, and we explain it in detail in context engineering for companies. Put simply, giving each agent only what is relevant has three advantages:

• Fewer errors: the agent is not distracted by information that does not apply to its task.
• Lower cost: it processes less text on every model call.
• More security: an agent cannot leak data it never received.

Notice that the restrictions section shows up for both the agent that writes and the agent that reviews. That is intentional: the rule is applied during creation and verified before delivery.

How the file stays alive

A file nobody updates becomes dangerous: agents trust it and repeat outdated information. That is why every section needs two things.

A human owner. The account manager owns stakeholders and lessons learned. The creative lead owns the brand section. Legal, or the person the client designates, owns restrictions.

A proposal mechanism. A learning agent reviews what happens in day-to-day work and proposes changes: "the client rejected work with dark backgrounds for the second time; should we add this to brand?" The proposal goes to the owner, who approves, adjusts or discards it. Nothing is saved without sign-off.

With this setup, the file improves with every project but never fills up with assumptions.

Illustrative example: the beverage account, before and after

Illustrative example. Before, client information at Sofía's agency was spread across a shared folder, the previous account executive's inbox and a two-year-old brand guide. Each agent received a different document depending on who had set up the workflow.

After:

• There is a single client file with all seven sections.
• The ban on "natural" sits under restrictions, with the date and the name of the person who communicated it.
• The copywriting agent reads it before writing; the compliance agent verifies it before the work reaches Sofía.
• When the client gets a new CMO, the account manager updates stakeholders and every agent knows from that moment on.
• After each campaign, the learning agent proposes what is worth remembering. Sofía approves what is worth keeping.

This is the kind of structure behind Agency OS, the system Addabra built for a creative agency with 27 agents and the director's sign-off at every key step. We tell that story in Agency OS.

Common mistakes when designing per-client memory

• A different file for each department. If sales, operations and creative each have their own version, you are back to the original problem.
• Free-form sections for each client. Without a fixed structure, agents don't know where to look.
• Giving every agent the full file. More context is not better context.
• Forgetting the restrictions. It is the shortest section and the one that saves the most money.
• Not recording who changed what. Without a history, nobody trusts the file.

What to do on Monday

Pick your most important client and build their file in a document with the seven sections. Ask each person who works on the account to fill in the part they know best. Then ask yourself, for each section, which agent or which person really needs it. That map is the design of your per-client memory.

At Addabra, we design these files with your team as part of each system's brain: fixed sections, an owner for each section, access by agent and a learning agent that proposes improvements for human approval. That way every client gets work that remembers everything you have already learned together.

business memoryclientsAI agents