One brain your agents share
Your assistants each start from zero, every session, forever. The shared brain is where what one of them learns becomes something the others can find — over MCP, on your own infrastructure, with a human deciding what gets in.
The problem is not memory. It is that memory does not travel.
Per-project isolation is the right default — memory that quietly follows you between contexts is a leak with a friendly name. But permanent isolation has a cost people feel every week: the same gotcha gets rediscovered, the same decision gets re-litigated, and the reasoning behind last month's choice is gone.
What is missing is not a hole in the wall. It is a door with a lock, a key someone holds, and a log.
What it is
team-brain is a built-in MCP server. Any MCP client — Claude Code, Claude Desktop, or anything else that speaks the protocol — connects to it and gets four tools:
search_team_knowledge
Find what the team already established, before re-deriving it.
save_to_team_brain
Propose a durable lesson. Lands pending, not shared.
list_my_pending
See what is waiting on your decision.
recall_episodes
Your own past exchanges, owner-scoped.
Saving is not sharing
This is the part that makes a shared brain safe to actually use. Nothing an assistant saves is visible to teammates until a person approves it. Entries land pending, attributed to their owner, and wait.
Memory amplifies: one write becomes many reads. A brain that stores everything an assistant proposes is not a knowledge base — it is a search problem with worse recall and a confident tone.
The honest failure mode, from running this ourselves: a review queue nobody opens looks like a safety control and is a graveyard. So the ceremony has to be small and frequent, and rejecting freely has to feel normal. One of the skills below exists purely to make that happen.
Connect it
-
Run the gateway
Self-hosted, Docker Compose, your infrastructure.
curl -fsSL https://membrn.ai/install.sh | bash -
Point your client at the brain
claude mcp add --transport http team-brain \ "http://<gateway-host>:8001/mcp/v1/team-brain" \ --header "x-membrain-api-key: <your key>" -
Install the skills
A server nothing calls is just plumbing. The skills are what make an assistant reach for it at the right moment.
git clone https://github.com/mrpintcom/membrain-engine.git /tmp/membrain-engine mkdir -p ~/.claude/skills cp -r /tmp/membrain-engine/skills/membrain-* ~/.claude/skills/
| Skill | Fires when |
|---|---|
membrain-recall | before non-trivial work in code the team knows |
membrain-remember | a durable lesson emerges worth keeping |
membrain-review-queue | knowledge is waiting on a human decision |
membrain-mcp-audit | “what can my MCP servers actually see?” |
What is free, and what is not
Stated plainly here rather than discovered after you install:
| Capability | Community build |
|---|---|
The team-brain server and all four tools | Free |
| Pending-by-default review gate, owner attribution | Free |
| Semantic search, episodic capture, the skills | Free |
| Governing third-party MCP servers — audit, allowlists, egress scanning | Licensed |
That second row is the one worth understanding before you need it. We wired a logging MCP server into Claude Code and measured what a third-party server receives: across six trials no credential was transmitted — not even when we asked directly. What did travel was a precise description of how to forge a session token for the service.
The credential did not leak. The vulnerability did. And every good outcome there was a model disposition, not a control — nothing logged it, enforced it, or could prove afterwards that it held.
Where it runs
On your infrastructure. The gateway is self-hosted, the Postgres is yours, and the brain never leaves it. There is no MemBrain-hosted tier to opt out of, because there is no MemBrain-hosted tier.
Start with the free build
The shared brain, the review gate and the skills need no licence and no conversation with us. If you get to the point of governing third-party MCP servers, then we should talk.