A cross-section of a forest floor: four trees above the ground, and below it their roots, joined by fine fungal threads.

An institutional brain lets a team share context.

You built the whole system for yourself: a folder that holds your context, a brain with rules, a living state, and a history, and an always-on agent you can text. Now scale it from one brain to a network: individual brains overlaid on one shared institutional brain, routed by whoever is calling.

Under a forest, threads of fungus join the roots of one tree to the next.

Tanush Jagdish · Part 6 of 6 · 12 min read

Most firms ask the same question about thirty minutes into a demo: I do not work alone, so how does this work for my team?

Technology is the easy half. Agreeing to operate around a shared folder and a shared system is the hard half: who remembers what, for whom, and what may cross between people. In my experience bringing this to firms, reaching that agreement is harder than building the agent. This part covers both halves, starting from the single brain you already have. We think of the network it grows into as a mycelium.

#1A brain is the fundamental unit

Start with the unit you are about to multiply. You already know its shape from Part 4: a brain is three layers inside one boundary.

  • Rules: who you are and how you operate. SOUL.md (voice, scope, hard rules), AGENTS.md (boot order and update rules), and MEMORY.md (the map of where everything lives).
  • Living state: current-state.md, which records what is true now. It is the single source of truth for today, rewritten in place.
  • History: the diary folder, where every session and decision is dated and appended, never rewritten.
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 fundamental unit: rules (SOUL, AGENTS, MEMORY), living state (current-state), and history (diary), with a synthesis step that distills history into living state.

Continuous distillation connects the layers: 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. You can reduce the whole thing to two primitives: a diary that collects everything and a current-state that distills it. This structure is deliberately minimal, and it evolves as needs become clear.

Choosing a schema is a matter of style. I like calling my memory a diary. One of my co-founders keeps a knowledge graph instead: a folder of short markdown files, one per person, that keep getting updated. Another does it his own way. That choice will matter in the long run, but not much yet. What matters is the unit: a self-contained, three-layer object. Hold onto it, because next we fork it.

#2From personal to institutional: the knowledge flow

Here is the first multiplayer move, in one sentence: each person’s work distills into a shared institutional brain that everyone reads.

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: three founder brains, each private and each with its own scope, send institutional facts into a shared brain marked “everyone reads this.”

Take our own team: three founders, three brains. Each brain is private and covers its owner’s area. One of us runs the company, one runs infrastructure, and one runs go-to-market, and each of us does our own work in our own brain. Institutional facts (decisions, customer meetings, equity choices) flow into a shared brain whose current-state and diary are marked, in capital letters, EVERYONE READS THIS. One simple rule decides what flows and what stays put: private reflections stay in personal brains, while institutional decisions, customer meetings, and equity choices go to the shared brain.

When I explain this to a firm, I add a middle tier, because most firms are not flat. Each person has a brain, and the company also has one: an institution-wide knowledge base, covering investors and other shared subjects, that anyone can draw on. At a venture firm, for example, each person has an individual brain, the partners share their own institutional memory, the analysts have something more specific, and everyone shares company-wide memory. In our own system, we named the two main layers by what they hold. Our shared brain holds domains, initiatives, and organizations: the market, the competitive landscape, finance and runway, the product. Personal brains hold people, topics, and ideas.

A second channel carries knowledge across the team, and you already know it: skills. Once a method is encoded as a skill, it becomes the way the whole organization does that task. If you run due diligence a certain way, give the skill to your team; they use it, improve it, and share the improvements. That is the institutional brain in miniature: standardize a method as a skill, distribute it, and let people build on it. One person’s edge becomes everyone’s baseline.

#3L1, L2, L3: institutional first, you second, live context on demand

This is the core architecture of the part, so first the wrong way, then the right way. Almost everyone does it the wrong way first, including us: one brain, all of it loaded into context, with the model deciding what to read. There is no read-path policy, so the agent reaches into whatever it wants, turn by turn, whether current-state, the diary, or any other file. It works until it does not. The brain grows, the context gets noisy, the model spends budget re-reading things it does not need, and nobody has a principled answer to what is shared and what is private.

Doing it right means layering the context and giving it a read-path policy. Your institutional brain is the shared foundation, individual brains overlay it, and each turn is routed by caller. Within each turn there are three zones:

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.

The layered read path: institutional memory loaded first and the caller’s overlay second (Zone 1, the cached prefix), live context read on demand (Zone 2), and write-back to both brains when the session ends (Zone 3).
  • Zone 1 is the cached prompt prefix, which the model always sees. Institutional memory loads first: the shared brain’s SOUL, AGENTS, and MEMORY files, holding firm knowledge, the deal pipeline, and the protocols everyone follows. Next comes the active person’s overlay: their voice, preferences, feedback on drafts, and private notes.
  • Zone 2 is live context, read on demand rather than placed in the prompt: current-state, the diary, and connected tools such as the CRM, Slack, Granola, and Gmail. Your agent pulls these only when the turn needs them.
  • Zone 3 runs when the session ends. A stop hook fires, and the brain summarizes and saves the session, but only if something material happened. It writes back to the person’s overlay (voice and private context) and to the institutional brain (shared facts).

One line in AGENTS.md makes this real, the read-path policy: smallest context first, institutional before personal, the CRM for facts, and code and logs for infrastructure. That is the difference between a model grabbing whatever it likes and a policy: the shared foundation first, the person’s voice on top, facts from the source of truth, and infrastructure from the logs.

In a client’s terms, the firm gets one institutional brain (its knowledge, its deal pipeline, and the way it runs its process), and each partner gets a personal overlay on top. When a partner calls, the caller’s identity selects their brain for that turn. Everyone reads the firm’s brain; only you read yours.

Underneath the three zones is a version-control mechanism worth understanding, because it lets an institutional change reach everyone without any copying. L1 is a generic brain template, rarely touched. L2 is the organization’s brain, a fork of L1 that holds the shared truth: domains, initiatives, and organizations. L3 is each person’s brain, a fork of L2 that holds personal content (people, topics, and ideas), which never flows back up to L2. Because L3 forks L2 and L2 forks L1, a fact written to the organization’s brain flows down to every personal brain through the fork chain, while anything private written to your L3 stays there. That fork chain is the propagation policy.

#4Routing through AGENTS.md: the nervous system

How does the right brain reach the right person on the right turn? Through AGENTS.md and an isolated runtime for each person, which together give the agent the right repositories, tools, and skills for whoever is calling.

Routing through AGENTS.mdThe nervous system
Message in

Slack DM

@mention · email · SMS

Dispatcher

sender → brain repo

maps user_id, then routes

runs in

private runtime

per agent · isolated · always on

Inside the runtime · AGENTS.md is the routing table
AGENTS.mdpoints the agent at the body it needs
/workspace
Your brain, loaded for you. The harness reads AGENTS.md first.
/repos (shared)
The shared brain, a deep archive, skill plugins.
External services
CRM, email and Slack, reached only when the turn needs them.
Durable state
Session state that persists between turns.

The brain tells Oli where the body lives. The brain doesn’t hold it.

Routing through AGENTS.md: a Slack message reaches the dispatcher, the sender’s user ID maps to a brain repository, and the turn runs in that person’s isolated runtime, with their brain, the shared brain, and the skills available.

The flow: you message Oli, and the dispatcher reads your user ID, maps it to your brain repository, and runs your turn in a runtime set up for you. Your brain sits at the top of the workspace, with AGENTS.md as the first file the harness reads, and the shared brain and the skills sit alongside it. One line makes it click: the brain tells Oli where the body lives, but it does not hold the body. This is the Part 4 idea, that your folder is your context, upgraded for a team: the routing file hands each caller the right mix of shared and personal context, inside their own isolated compute.

Once several people share channels, a subtle bug appears: a shared company thread can switch to the latest sender’s personal agent in the middle of a conversation. We designed that out. A mention inside an existing channel thread stays with the agent the thread is bound to: one thread, one brain, one default mailbox. When one partner joins another partner’s thread, only the caller identity changes; the cached brain and the default mailbox remain the thread owner’s. That is a property of the design, not a heuristic patch. Scoping is real, too. Your Oli is yours alone, scoped to your inbox and your material, not a firm-wide Oli. It can read shared notes and transcripts, but it is not given access to another partner’s Granola notes or email, because only that partner should see them.

#5Skills overlay: same code, different reach

That leads to the most important privacy idea in the architecture. Everyone runs the same skills: the Gmail skill is one folder, and the CRM skill is one folder. What changes per person is the credential supplied when the agent starts. Privacy is enforced at the credential, not in the code.

Privacy lives in the credential, not the codeSame skill, different reach
Caller

Partner A

Caller

Partner B

dispatcher fetches from the secret store
dispatcher fetches from the secret store
Loaded at start

Partner A’s email token

Loaded at start

Partner B’s email token

Email skill

identical code for every caller

Reads and drafts in Partner A’s inbox only

Reads and drafts in Partner B’s inbox only

Code is shared; credentials are not. Neither partner’s agent can reach the other’s inbox.

Privacy lives in the credential, not the code: two partners run the same email skill, and the dispatcher loads each caller’s own token before the agent starts, so each reaches only their own inbox.

When you call, the dispatcher reads your identity, fetches your tokens from the secret manager, and sets them as environment variables before the agent starts. Firm credentials (the shared CRM token, the Slack bot token) are available to everyone. Personal credentials (your Gmail token, your calendar token) are scoped to you. One partner drafts as partner A, another as partner B, and neither can draft as the other. Both partners run identical code; only the token changes.

This is the clearest answer to the question of whether a shared agent is a privacy risk. It need not be, because the boundary is not a prompt instruction that an agent might wander past. It is enforced at the credential: without the token, the skill cannot reach the data. Per-runtime environment variables are the simple version of this boundary, and access-control lists are the stronger one.

#6One brain, or many? The split decision

Every team eventually reaches a fork in the road: keep one shared brain for everyone, or split into an institutional brain with personal overlays? I help a firm decide by first showing the cost of one brain for everyone. One live audit surfaced three problems. First, truncation without warning: the shared MEMORY.md had grown to 29,021 characters, the runtime silently cut off anything past 20,000, and about a third of the rules at the bottom were dropped every time the agent started, until the audit caught it. One brain for eight people did not fit. Second, lost context between partners: a single brain had no structured way to pull in another person’s context, so the agent evaluated a potential limited partner using only the requester’s notes and missed what a colleague already knew. Third, identity by convention rather than by design: telling people apart by Slack ID, email domain, and channel was brittle, and one partner had no Slack ID mapped at all, so his email fell outside the allowlist and was silently dropped.

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

What lives where: a grid assigning each rule to the institutional brain or a personal overlay, decided by the overlay test.

Once a team sees these failures, the case for splitting is clear. One reusable heuristic, the overlay test, decides what goes where: by default a rule is institutional, and it goes into a personal overlay only if it reflects that person’s voice, access, or private context. Everything else lives in the institutional brain. This is your L2-versus-L3 decision rule: institutional by default, and personal only for voice, access, or private context.

#7Who gets a private brain? Governance is the real bottleneck

Now the hard part, which is not architecture but politics and permissions. Before you split a brain, you need answers to eight questions.

Who gets a private brain?Before we split

Before you split one brain into many, there are eight questions you have to answer. They aren’t architecture questions. They’re governance questions to the core.

  1. 1
    Identity

    Who qualifies as a principal who gets their own brain, and who is just a routing rule?

    who is a principal

  2. 2
    Cross-partner visibility

    Should one person’s draft history be visible to another, or stay private?

    firm-wide vs. personal

  3. 3
    Write-back policy

    When someone teaches a new rule, does it propagate to everyone or stay in one layer?

    how learning propagates

  4. 4
    Escalation default

    When the agent is unsure whom to consult, who does it go to?

    CEO vs. workflow owner

  5. 5
    Observability

    Daily summaries per-person, or one single pane of glass for the lead?

    partnership transparency

  6. 6
    Privacy boundary

    What never crosses? Equity, candidate evaluations, unshared soft signals.

    what never moves

  7. 7
    Governance

    Who can add a “from now on” rule that binds the others: alone, or with sign-off?

    who holds rule rights

  8. 8
    Accountability

    Audit every rule-change and cross-brain read, or trust-with-audit-on-anomaly?

    trust vs. audit

The institutional brain is the governance layer. The hard part of going from one brain to many is never the architecture. It’s the politics and permissions. (Worked through with a VC firm; client details anonymized.)

Who gets a private brain? Eight governance questions, each with its guiding principle.
  • 1.Identity: who counts as a principal? Who gets a private brain, and who is handled by a routing rule?
  • 2.Cross-partner visibility: should one person’s draft history be visible to another, or stay private?
  • 3.Write-back policy: when someone teaches the agent a new rule, does it go to the institutional brain, where everyone inherits it, or to a personal layer?
  • 4.Escalation default: when the agent is unsure whom to consult, does it go to the CEO or to the owner of the workflow?
  • 5.Observability: daily summaries for each person, or one combined view for the team lead?
  • 6.Privacy boundary: what never crosses between brains? Equity conversations, candidate evaluations, unshared impressions?
  • 7.Governance: who may add a “from now on” rule? Anyone, on their own, or only with sign-off when the rule is institutional?
  • 8.Accountability: audit every rule change and every cross-brain read, or trust by default and audit anomalies?

Be skeptical of anyone who claims this is solved, because it is not. Should teams be able to create their own skills, or use only what is mandated from the top? Organizations everywhere are working out these questions as they go, and your company should form its own view.

For write-back and skill conflicts, the best mechanism I have found is the one engineers already use: pull requests. Several people work on the same repository and submit changes; someone compares two submissions, takes one, and borrows from the other. Skills now have a built-in version of this review: as of September 2026, the Team and Enterprise plans of Claude let you share a skill with colleagues, and an owner can require review before a skill reaches the whole organization. Someone in your organization should own reviewing those submissions and deciding what to adopt, and that governance should fit how your company operates.

Two more points on adoption, because the architecture is worthless if the organization will not operate it. First, adoption has to come from the top. A single agent-native person at the bottom of the org chart rarely changes how a whole organization works, even with an impressive demo, so find someone with decision-making power. Here is the tension: leaders often want AI, while hands-on skill with it tends to sit further down the organization.

Second, much of this is a data-infrastructure problem in disguise. Firms hit blockers such as retention concerns, which systems the agent may touch, and who controls the Slack app. These are not IT tickets; they are decisions about where your data lives. Your biggest lever is to rethink where your data lives, then change it so agents can reach it as well as people can. That is no longer only an IT question; it involves the whole company. Where an agent lives breaks down into two questions: where the data lives, and where the compute runs.

Compliance has two layers. First comes the contractual layer, which is solvable today: zero-data-retention terms and, for health data, a business associate agreement with the model provider. Second comes the organizational layer, which is much harder. Your data is scattered across SharePoint, email, Confluence, and shared drives, and few organizations have organized it so an agent can reach what it needs with the right permissions. If you do not solve this officially, you get shadow AI: people use AI anyway, outside your control, and your data goes with them.

#8The simplicity is the scalability

One capability shows up only in the team setting. Independence is the longest-running thread in this curriculum: it starts when you stop waiting to be told and try things yourself, and it peaks when you can teach someone else. Working alone, the top of that ladder is building and debugging without a coach. On a team, it goes further: you become the person who onboards the next hire, writes the shared skills, and reviews the pull requests. An institutional brain is what makes that onboarding fast, because a new person inherits L1 and L2 on day one and only has to build their own L3. People need different on-ramps (a junior colleague gets a short introduction and then room to explore; an executive may take five sessions and then ask you to run it for them), but all of them fork from the same shared method. That is the real payoff of working as a team: your edge becomes the company’s baseline, and the next person starts from there.

Step back and look at the whole design: one repository per person, one routing file, a shared brain everyone reads, and credentials that enforce privacy.

The simplicity is the scalabilityLooking ahead

3

people

same architecture

50+

users & beyond

One repo per user
A brain repo is the whole unit of a person: files, nothing more.
One routing file
AGENTS.md maps sender to context. Adding a user is one entry.
Inherited shared repos
Institutional brain and skills ship in the template, not per user.
No new database.No graph database.No coordination layer to break.

And it compounds. Every diary entry, every current-state rewrite, every institutional fact adds to the record the agent learns from. The brain gets better the more it’s used.

One repo per user, one routing file.

The simplicity is the scalability: one repository per person and one routing file, from a three-person team to fifty or more on the same architecture, with value that compounds as the brain is used.

This architecture serves three founders and is designed to serve fifty people unchanged; it also improves with use, because every diary entry adds to the record the agent learns from. Here the curriculum hands off to the research. One dispatcher serving many per-person agents is multiplexing. Enforcing permissions at the credential is governance as data infrastructure. And the path from markdown files in git to a brain that learns is the brain-design roadmap. You started with a folder that held your context, and you finish with an institution whose knowledge works as a network.

The research behind this part.

You have reached the end of the curriculum.

Want to go faster on your real work?

Coaching is the same method with someone beside you. It is by referral or invitation, and we are at capacity. We write back as capacity opens.