How Much Memory Does a Company Superintelligence Need to Start?
A first company AI agent needs a small, owned memory set: one role, approved sources, entity records and clear write rules. Here is what to leave out.

A company AI agent does not need a large memory to start. The first setup should be sized by the work it must do, not by storage or context length: a standing role profile, the few approved sources it may read in their current versions, the entity records that identify the customers or jobs involved, and a written rule for who may change each item. Everything beyond that waits until the first workflow has been tested against real questions.
Key takeaways
- Start with one role and one workflow, and size the memory to that workflow only.
- Give the agent a short set of approved sources and entity records, each with a named owner, before importing any archive.
- Keep the context loaded per task small, and store everything else as retrievable, owned records.
- Decide who may write to memory and what a person must review before a fact is saved.
- Leave out mailboxes, old file shares and cross-department knowledge until the first workflow passes its test.
Why the first question should not be about size
Most requests about agent memory begin with capacity, as if a bigger store would make an agent more reliable. In practice, the failures a business notices are rarely caused by running out of room. They come from the wrong document being read, an outdated policy being treated as current, or a note written by a colleague being presented as a confirmed fact.
That is why the useful unit of planning is the task. Ask what the agent must know to finish one specific job correctly, which source proves each answer, and what it should do when the answer is missing. The size of the memory follows from those answers. The difference between a long prompt and stored, owned records is covered in Context window vs persistent memory, and it is worth reading before you decide what to load.
The four kinds of memory a first agent needs
A first agent usually needs four kinds of memory. Each has a different owner, a different lifetime and a different way of being checked.
- Role profile: who the agent is, what it may and may not do, the tone it uses, and when it hands a case to a person. It changes rarely and is approved by whoever is accountable for the role.
- Approved sources: the policies, procedures and reference documents the role must read, each in one current version with a named owner and a last review date.
- Entity records: the customers, orders, jobs or assets the role refers to, stored with stable identifiers so two accounts with similar names are never merged.
- Working context: what the agent loads for the current task only, such as the open case and the two or three records it needs. It is discarded or summarized when the task closes.
Chat history is deliberately absent from this list. It is raw material, not memory, and turning it into facts requires a decision about what is true. The distinction between conversation context and long-term company memory is explained in Session memory vs long-term company memory.
Each kind also needs an access rule. The OWASP authorization guidance is a practical reference for deciding which roles can read or write each store, and the NIST AI Risk Management Framework gives a vocabulary for recording the risks and the owners behind each decision.
A step-by-step plan for the first memory set
Work through these steps in order. Each one is small enough to finish in a working session with the people who own the information.
- Step 1: Write the single task the agent will handle, in one sentence, and name the person who receives its output.
- Step 2: Collect the questions staff actually ask about that task, from recent emails, tickets or meeting notes, and keep a short list of realistic ones.
- Step 3: For each question, name the document or record that answers it and the person who owns that source.
- Step 4: Remove duplicates and superseded versions so that each rule exists in one current form.
- Step 5: Write the role profile and the access rule: what the agent may read, what it may write, and what always goes to a person.
- Step 6: Load the approved sources in one small batch, then run the question list before adding anything else.
Keep the question list. It becomes the test that tells you whether each later addition helped or only made the store larger.
What to leave out until the first workflow works
The most common mistake is loading everything that might someday be useful. A full mailbox, years of closed tickets and every shared drive folder make the agent slower to test and harder to correct, because nobody can say which source produced a wrong answer.
For a first set, leave out the following until a failing question shows that one of them is needed:
- Full mailboxes and chat exports, which mix facts, opinions and personal messages.
- Old document versions and spreadsheets that have no named owner.
- Knowledge from other departments that the first role does not use.
- Sensitive personal data that the role has no reason to hold.
- Automatic summaries that nobody has reviewed.
- Tools that can change systems of record, such as billing or inventory.
Leaving these out is not permanent. Each item can enter later, one source at a time, with its own owner and its own test. Who may save a new fact is a separate question, covered in Memory write gates for superintelligent agents.
Illustrative scenario: a support agent for one product line
The following scenario is illustrative and does not describe a specific company. A support lead wants an agent to answer order status questions and explain the return policy for one product line.
The first memory set is small. It contains a role profile stating that the agent may explain the policy and look up orders, but may not approve refunds. It contains the current return policy, with one named owner in operations and a note that it replaces the previous version. It contains order records keyed by order identifier and customer account identifier, so two customers with the same name are not confused. The working context holds the open case and the matching order, and nothing else.
Left out at the start are several years of closed tickets, the full product catalog, sales call notes and the policies for other product lines. When the agent is later asked about exchanges, the failing test shows that exchange rules live in a separate document. That document is added with its own owner, and the memory grows by one justified source rather than by an archive.
How Be Human approaches the first memory set
In Be Human's managed model, the first engagement defines one useful role, the memory and tools that role needs, the approval boundaries that separate what the agent may do from what a person must decide, and one observable success criterion. The memory is built from sources the client names and owns, and the write rules are set before anything is loaded. Ongoing operations can then include permission review, recurring evaluations against the agreed questions, and controlled changes whenever a source is added or retired. The aim is simple: every item in memory has a known origin and a known owner, so a wrong answer can be traced to a source instead of to a guess.
How to know the first set is enough
A first memory set is ready when the agent answers the agreed questions correctly using only what it is allowed to see. Every wrong answer should be sorted into one of three causes: the source was missing, the source was wrong or outdated, or retrieval picked the wrong item. Each cause has a different fix. A missing source needs an owner and a document. An outdated source needs a correction at the owner's desk. A retrieval miss usually needs clearer labels or a smaller, more specific source.
Running the same question list after every change keeps the comparison honest. The OpenAI evals guide describes writing test cases before changing a system, and Anthropic's guidance on effective context engineering makes the related point that the smallest set of high-signal context usually performs better than an exhaustive one. If you are not sure which of your workflows should receive the first memory set, the free Be Human AI diagnostic can help you find the first task worth handing to an agent.
Frequently asked questions
How much memory does an AI agent need to start? It needs only what its first task requires: a role profile, a few approved sources in their current versions, the entity records that identify the people or jobs involved, and a small working context for each task. Size matters less than ownership, because a short store with clear owners is easier to correct than a large one that nobody reviews.
Does a company agent need a vector database on the first day? Not necessarily. For a small set of approved documents, simple retrieval may be enough, and the right choice depends on how many sources the role reads and how often they change. The decision can be revisited once the question list shows where retrieval actually fails.
Should the agent remember every conversation? No. Chat history is raw material, and turning it into facts requires a review step that decides what is true and who owns it. Only reviewed facts should enter long-term memory, while conversation context stays in the session.
When should we expand the memory? Expand it when a question on the agreed list fails for a reason that a new, owned source would fix, and after the current workflow passes its tests consistently. Each addition should have its own owner, its own test and a note about what it replaces.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


