Shared Brain First, Boundaries Second

What it is

A design principle for multi-agent systems: before adding agents, build the shared memory layer first. The shared brain is not a giant bucket of merged memories, but a curated layer of team-level facts that persist across agents. Individual agents keep private notebooks for personal habits and temporary context.

Why it matters

When multiple agent platforms run in parallel, each agent remembers decisions independently but remains unaware of the other's memory. This leads to repeated questions, duplicated decisions, and fragmented context. The shared brain prevents agents from "acting like strangers sharing a house."

Key points

• Shared study vs private notebook: The shared study stands on its own. It holds long-term decisions, stable facts, important relationships, and context that agents repeatedly reach for. Private notebooks contain personal habits, temporary context, and role-specific experience.
• The human remains the main brain: The shared study is not a coordinator or main brain. It is a shared context layer. The real main brain is still the human, plus a clear set of boundaries.
• Boundaries matter more than connections: Without rules, a shared brain becomes a trash bin. The shared study should only accept team facts and long-term decisions. No customer-sensitive data, no raw chat transcripts, no passwords or credentials. Write access goes to only a few agents; the rest stay read-only.
• Control plane separated from knowledge: The control plane tracks health and resource usage. The knowledge layer stores actual facts. When the shared study goes down, agents keep working; they lose team memory but do not die with it. The shared brain is a capability, not oxygen.

The four questions

Before adding agents, answer these:

1. What belongs to a single agent and should never leave its room?
2. What counts as a team fact every agent should be able to look up?
3. Who has the right to write into the shared study?
4. What can never enter the shared study, ever?

Seven-step implementation order

1. Clean one agent's local memory. Trim its private notebook to what it actually uses.
2. Build a shared team brain next to it. gbrain works well here.
3. Wire the agent into the shared brain through MCP. Open search and read first. No write access yet.
4. Let one or two clearly-owner agents write durable decisions into the shared brain.
5. Add automated sync sources, but only sync curated content. Do not pipe in the whole inbox or Slack.
6. Expand access by role. New agents default to read-only.
7. Keep the control plane separate from the knowledge itself.

Open questions

• How does the shared brain pattern interact with the Memory Backend vs Context Substrate distinction? A shared brain could be implemented as either.
• What happens when two agents disagree on a team fact? Is there a conflict resolution mechanism?
• How does this scale beyond two agent platforms to tens or hundreds of agents?

Prompts for witness

• In your current setup, which decisions are worth writing into a shared brain, and which are just noise?
• If you had to draw a hard boundary between what stays in a single skill/agent and what becomes team knowledge, where would you draw it?

Related

• harness-engineering/multi-agent-coordination-patterns — Pattern 5: Shared State
• harness-engineering/agent-memory-vs-context-substrate — Memory Backend vs Context Substrate
• ai-tools/openclaw-initialization — OpenClaw initialization and memory model
• ai-ecosystem/hermes-agent — Hermes Agent memory system