
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.
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.
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.
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.
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:
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.
- 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.
Slack DM
@mention · email · SMS
sender → brain repo
maps user_id, then routes
private runtime
per agent · isolated · always on
- /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.
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.
Partner A
Partner B
Partner A’s email token
Partner B’s email token
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.
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.
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.)
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.
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.
- 1Identity
Who qualifies as a principal who gets their own brain, and who is just a routing rule?
who is a principal
- 2Cross-partner visibility
Should one person’s draft history be visible to another, or stay private?
firm-wide vs. personal
- 3Write-back policy
When someone teaches a new rule, does it propagate to everyone or stay in one layer?
how learning propagates
- 4Escalation default
When the agent is unsure whom to consult, who does it go to?
CEO vs. workflow owner
- 5Observability
Daily summaries per-person, or one single pane of glass for the lead?
partnership transparency
- 6Privacy boundary
What never crosses? Equity, candidate evaluations, unshared soft signals.
what never moves
- 7Governance
Who can add a “from now on” rule that binds the others: alone, or with sign-off?
who holds rule rights
- 8Accountability
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.)
- 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.
3
people
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.
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.
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.