
A team brain loads in three layers: the institution, the person, then live context.
Loading one whole brain into context works for one person and fails for a team. A layered design loads institutional memory first, the caller’s personal overlay second, and live context only on demand, under a written policy for what loads when and what gets written back.
A lake, a mountain range and the sky: three layers, each resting on the one below.
Tanush Jagdish · June 2026
Once more than one person shares an agent, its memory needs a design. Our answer is three layers, loaded in order: institutional memory that everyone inherits, a middle layer for a client organization or department, and each person’s own brain on top, all governed by a written policy for what loads when. That policy is the difference between a single-player notebook and a system a team can rely on.
Part 4 of our curriculum ends with one person’s brain: a SOUL file that says who you are, a current-state file that says where things stand, a diary that records what happened, and a small loop that keeps them current. I have built that brain live with many coaching clients, and it works. Then a second person arrives, a teammate or a partner, and the design must answer a question it never faced: where does each fact live, and what loads into context when?
This design comes from two deployments: an agent we built and operated for a venture capital firm, and our own company’s system. Two cases are a narrow base, so read what follows as a worked design, not a survey. I start with the old way, because it is the natural first design and exactly what breaks.
#1First, the unit: one brain
Before layering anything, look at a single brain. It has three layers inside one boundary. (A different set of three layers comes later, across brains; keep the two apart.)
Three layers inside one boundary. The diary flows up into current-state, over and over, so the agent reads one short file to know where you are today instead of re-reading a thousand dated entries.
- Rules. SOUL.md holds your voice, scope, and hard rules: who you are. AGENTS.md holds the start-up order and update rules: how you operate. MEMORY.md maps every folder: where things live.
- Living state. A single current-state.md records what is true now, and it is rewritten in place.
- History. A diary folder records every session and decision, dated and append-only.
Compressed further, a brain is two primitives: a diary that collects everything and a current-state that distills it.
diary/
The raw memory stream. Every session, every decision, dated.
current-state.md
What’s true now. One short file the agent reads to know where you are today.
That’s the whole foundation. A stream that remembers everything, and a snapshot that stays current, each distilling into the next.
A diary is the raw memory stream; nothing is judged on the way in. Current-state is the rolling synthesis of what matters now, and the agent reads it first. A synthesis step runs between them: diary entries flow up, get distilled, and current-state is rewritten. Keep the structure minimal and let it grow as needs become clear.
Schemas vary. I keep a diary; one of my co-founders keeps a knowledge graph of people and organizations. Standards will emerge, but for now the choice matters less than having your working life in plain text where the agent can read it.
#2The old way: one whole brain in context
A natural first design for a shared agent loads one brain, all of it, into the context window and lets the model decide turn by turn what to use.
One person
active this session
No layering, no ordering, no cache discipline: the agent re-reads the whole pile each turn.
- No separation
- One brain, one person. Nothing distinguishes shared firm IP from private notes.
- No read-path policy
- Every turn, the agent reaches into whatever it wants: current-state, diary, anything.
- Model decides the sync
- What gets written back is left to the model’s judgment, turn by turn.
It works for exactly one person. Then the brain grows, the context gets noisy, re-reading burns the budget, and nothing defines what is shared and what is private.
It works for exactly one person; I ran my own agent this way for months. Its flaw fits in one line: there is no read-path policy, no rule for what the agent reads and when. It reaches into whatever it wants (current-state, the diary, any file) on every turn. Two failures follow quickly.
First, growth breaks it mechanically. In the venture firm’s deployment, the memory file grew to 29,021 characters while the runtime read only the first 20,000. About a third of the rules, those at the bottom, were silently dropped every time the agent started, until an audit caught it. Nothing flagged the loss; the agent simply stopped following a third of its instructions. Bigger context windows are not the fix. Chroma’s July 2025 study of 18 models found that performance becomes less reliable as input length grows.
Second, one brain cannot separate private notes from shared facts, or pull in one colleague’s context without everyone’s. With eight people on one brain, identity rests on convention: telling people apart by Slack ID, email domain, and channel, and hoping the convention holds. In that deployment it did not: messages one partner sent from an address outside the allowlist were silently dropped.
None of this makes the old way wrong. It is a single-player design being run as multiplayer.
#3The new way: load in layers
Same brain, but loaded in a deliberate order under a deliberate policy.
Email · text message · Slack
caller id → active principal
You
active this session
A partner
not this turn
An analyst
not this turn
private runtime · your brain folder loads this turn
Institutional Memory
the shared brain
AGENTS.md also carries the read-path policy: smallest context, institutional first, CRM for facts, code & logs for infra.
Active Principal Overlay
your brain folder
Institutional memory is the foundation every session sees. The principal who is actually on the line overlays on top. Everything else is fetched only when the work needs it, and the work flows back when it’s done.
Inside each person’s runtime, context resolves into three zones:
- Zone 1, the cached prompt prefix, which the model always sees. Institutional memory loads first; the active person’s overlay (voice, preferences, feedback on drafts, private notes) loads second. Whoever is calling this turn fills the overlay slot.
- Zone 2, live context read on demand and kept out of the prompt: current-state, the diary, code repositories, the CRM, Slack, and email. An agent fetches these only when it needs them.
- Zone 3, write-back. When a session ends, an automatic hook synthesizes what happened and writes it to the person’s overlay and, if the fact is shared, to institutional memory.
A written read-path policy, kept in AGENTS.md, turns the layers into a discipline: load the smallest context that works, institutional before personal, the CRM for operational facts rather than the brain’s prose, and code and logs for infrastructure questions. Anthropic’s September 2025 guidance on context engineering makes the same argument in general form: aim for “the smallest possible set of high-signal tokens,” and load other material just in time through tools.
#4L1, L2, L3: three layers across brains
Now the second set of three, which runs across brains rather than inside one.
- L1, institutional memory: the shared foundation every agent inherits, such as firm rules, the deal pipeline, and the company snapshot. Everyone reads it.
- L2, the organization or department overlay: a scoped layer between the institution and the person. For a client organization, it is the overlay all of that client’s agents inherit. Inside a firm, it can be a department layer, with one for partners and another for analysts.
- L3, the personal overlay: your own brain, with your voice, preferences, and private notes. L3 is the personal brain from Part 4 of the curriculum; this note covers what happens when there are many of them.
At Olito, each of us keeps a personal brain in the format we prefer, and the company keeps an institutional one, covering investors, customers, and decisions, that any of us can draw on. One of my co-founders describes the institutional layer as a set of shared domains (the market, the competitive landscape, finance and runway, the product) that sit above the personal brains. At the venture firm, each person had an individual brain, a department layer separated partners from analysts, and everyone shared firm-wide memory.
One engineering note, so the design is not overstated. When we built this, our runtime assembled the cached prefix literally as layer 1 (institutional), layer 2 (organization overlay), and layer 3 (user), and the organization overlay lagged the other two. Until it existed, we copied its content into each person’s L3 as a stopgap.
#5What lives where: the overlay test
Every team asks how to decide which layer a fact belongs in. One rule settles it: a fact is institutional by default, and it moves into a personal overlay only if it concerns that person’s voice, access, or private context.
Default: a rule is institutional. It moves into a personal overlay only if it reflects that person’s voice, access, or private context.
| Category | Institutional · shared | Personal overlay |
|---|---|---|
| Firm rules | Deal-filing workflow · enrichment · intake QC | · |
| Voice | Hard rule: no em dashes | intro-email formatreply tone, peer-to-peer |
| Client context | Field enums · directory governance | · |
| Email drafting | Allowlist · HTML-only body | intro patternsevent P.S. + LP docs |
| LP signals | Health check · scorecard framework | nightly signal + response tracking |
| Founder network | Network-creation rules | nightly email · untouched-founders report |
| Personal notes | · | private annotationsprivate annotationsprivate annotations |
One rule decides what lives where: institutional by default; personal only if it’s about your voice, your access, or your private context. (Worked through with a VC firm; client details anonymized.)
Some examples. Firm rules are institutional; how you like your own emails to read belongs in your overlay. A client’s deal context is institutional; your private read on a colleague belongs in your overlay. An investor pipeline is institutional; your personal network belongs in your overlay. Applied consistently, the test settles most cases without debate.
#6Writing back: distillation
Reading goes institutional first. Writing mirrors it: private by default, with shared facts promoted.
Founder A ’s brain
PrivateCEO lane
- A pricing decision
- An investor call
- An equity choice
- A private reflection
Founder B ’s brain
PrivateInfra lane
- An architecture decision
- A customer migration
- A reliability review
- A private reflection
Founder C ’s brain
PrivateGTM lane
- A customer meeting
- An advisor conversation
- A draft of the mission
- A private reflection
Private reflections stay in each founder’s brain. Institutional decisions, customer meetings, and equity choices distill down into the shared brain, and the shared brain reads back up into everyone’s next session.
Each person works in their own brain. At the end of substantive work, material facts distill into the shared brain, the one marked “everyone reads this.” One rule keeps this safe: private reflections stay in personal brains, while institutional decisions, customer meetings, and equity choices go to the shared brain. A half-formed worry about a deal stays yours; the firm’s decision about that deal becomes everyone’s. Read institutional first; write private by default, then promote.
#7Lock the layering, not the format
Storage formats will keep changing. Rules may stay flat markdown, living state may become a wiki or a database, and history may become an interlinked knowledge graph.
- 01
Rules
Who you are and how you operate
Today: Three short markdown files, edited by hand
Might become: Still markdown. Rules need nothing more.
- 02
Living state
What is true now
Today: One markdown file, rewritten in place
Might become: Perhaps a wiki or a database, perhaps still one file
- 03
History
What happened, dated
Today: A folder of dated diary entries, append-only
Might become: A linked knowledge graph you can navigate
Storage can change underneath. What stays fixed is the layering: institutional memory below, personal overlays above, a read path, and a write path.
Do not wait for a perfect format. What deserves commitment is the layering: institutional memory below, overlays above, a read-path policy that loads the smallest context that works, and a write path that keeps private things private and promotes shared facts. Get those right and the storage underneath can change at any time.
#8Where this connects
In our curriculum, this builds on Part 4 (the personal brain), whose diary, current-state, and self-improving loop are the foundation here. It runs inside Part 5 (managed architecture): the layers live in durable storage outside the runtime, and the read-path policy decides what the dispatcher loads when it starts a runtime. And it is the backbone of Part 6 (the institutional brain), which teaches the overlay test and distillation step by step.
In the research track, Multiplexing: Running Many Agents covers the routing that decides which overlay loads for each request, and The Messaging Layer covers why the same layered brain answers whichever channel a message arrives on. Olito’s own agents, including OliMed for independent physician practices, run on this design.
Loading a whole brain and hoping works for one person. For a team, load institutional memory first, the caller’s overlay second, and live context on demand, and write down the policy for what loads when.
More from our research.
Working on the same question?
We look for people to interview, data to compare against, and teams willing to test what we find. Leave a note and we will write back.