A still lake, a mountain range above it, and the open sky above the mountains, in morning mist.

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.)

The fundamental unitOne boundary · three layers
Brain
LAYER 01Rules
SOUL.md
voice, lane, hard rules
AGENTS.md
boot order, update rules
MEMORY.md
map of every folder
who you are
how you operate
where things live
LAYER 02Living state
current-state.md
what’s true now: the one source of truth for today
the canonical snapshot
of where things stand
rewritten in place
synthesiscontinuous distillation
LAYER 03History
diary/
deal-filing.mdlp-signal-digest.mdenrichment-ask.md…
every session,
every decision, dated
append-only

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.

A brain is the basic unit: a rules layer (SOUL, AGENTS, and MEMORY files), a living-state layer rewritten in place, and an append-only history layer, with continuous distillation from history into living state.
  • 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.

The simplest brainTwo primitives
Collects everything

diary/

The raw memory stream. Every session, every decision, dated.

2026-06-28.md
2026-06-27.md
2026-06-26.md
append-only
continuous distillation
Distills it

current-state.md

What’s true now. One short file the agent reads to know where you are today.

Now
A single canonical snapshot, not a thousand dated entries.
rewritten in place

That’s the whole foundation. A stream that remembers everything, and a snapshot that stays current, each distilling into the next.

A brain at its simplest: a diary that collects everything, and a current-state that distills it.

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.

The old wayOne brain · no separation

One person

active this session

whole brain →
The context window · everything, every turn
SOUL.mdAGENTS.mdMEMORY.mdcurrent-state.mddiary/every other file

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.

In the old way, one person’s whole brain is the context, and the model decides what to read and what to write back, with no read-path policy.

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.

The new wayInstitutional first · overlay second

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

Zone 1cached prompt prefix · always seen by the model
loaded first · foundation

Institutional Memory

the shared brain

AGENTS.md also carries the read-path policy: smallest context, institutional first, CRM for facts, code & logs for infra.

loaded second

Active Principal Overlay

your brain folder

Zone 2live context · read on demand · not in the prompt
current-state.md
diary/
repos · CRM · Slack · code
Zone 3session ends · stop hook fires · the brain summarizes & saves (if material)
→ your brain folderpersonal writeback
→ the shared braininstitutional writeback

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.

In the new way, institutional memory is the shared foundation and each person’s overlay sits on top, selected by who is calling. Zone 1 is the cached prompt prefix, Zone 2 is live context read on demand, and Zone 3 is write-back.

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.

The overlay testWhat lives where

Default: a rule is institutional. It moves into a personal overlay only if it reflects that person’s voice, access, or private context.

Per-person overlaysPartner APartner BPartner C
CategoryInstitutional · sharedPersonal overlay
Firm rulesDeal-filing workflow · enrichment · intake QC·
VoiceHard rule: no em dashes
intro-email formatreply tone, peer-to-peer
Client contextField enums · directory governance·
Email draftingAllowlist · HTML-only body
intro patternsevent P.S. + LP docs
LP signalsHealth check · scorecard framework
nightly signal + response tracking
Founder networkNetwork-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.)

Mapping facts to layers: institutional by default, personal only for a person’s voice, access, or private context.

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.

Personal to institutionalEach founder → one shared brain

Founder A ’s brain

Private

CEO lane

  • A pricing decision
  • An investor call
  • An equity choice
  • A private reflection

Founder B ’s brain

Private

Infra lane

  • An architecture decision
  • A customer migration
  • A reliability review
  • A private reflection

Founder C ’s brain

Private

GTM lane

  • A customer meeting
  • An advisor conversation
  • A draft of the mission
  • A private reflection
institutional factsShared brainShared institutional memorycurrent-state.mddiary/Everyone reads this

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.

Personal to institutional distillation: each person’s work distills into a shared brain that everyone reads.

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.

Formats will change; the layering staysHow a brain might evolve
  1. 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.

  2. 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

  3. 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.

How a brain might evolve: rules stay flat markdown, living state may move to a wiki or a database, and history may become a linked knowledge graph.

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.