Looking for 5 teams to test TeamBrain, PR governed shared memory for your coding agents

Donatien Migue — Thu, 30 Jul 2026 11:52:19 +0000

This is not a documentation tool, and you will not write anything by hand.

The problem is straightforward. Your agents (Claude Code, Cursor, Codex) are stateless and single player. Every session starts cold, every developer re-explains the same architecture, and what one agent figures out on Monday never reaches a teammate's agent. Hand-maintained CLAUDE.md and .cursorrules files drift apart across tools and capture nothing agents learn while working.

How it actually works

A CI job watches real sessions, distills what agents struggled with, and opens a pull request with proposed memories. You review them the way you review code. What gets approved becomes markdown in .teambrain/, served to every agent on the team over MCP.

session → capture (redacted, metadata only) → CI distiller
→ PR → human approval → every agent, every tool

The key property: the write loop is automatic, the gate is human. You are never authoring docs.

What it is not

Not a wiki, not a Notion or Outline replacement. The primary consumer is the agent, not the human. Keeping both is fine.
Not a new repository to create. It is a directory inside a repo you already have.
Not reading through Git. Agents read a local index (SQLite, FTS5, local embeddings), no network calls, works offline. Git is the storage format and the governance mechanism, not the read path.

Why a PR instead of a database

This is the one bet the project makes. Most memory tools write silently into a proprietary store. Nobody can then say who approved what, diff how shared knowledge changed, or leave with their data. More importantly, a wrong or poisoned memory silently becomes an instruction to every agent on the team. PR review is the mechanism your team already uses to stop exactly that class of problem.

The bet has a clear falsification condition. If reviewing memories is painful, teams will disable the gate and my differentiation is worth nothing. I am targeting median review under 10 minutes, with PRs readable in under a minute. That is the number I want to measure with you.

Privacy

Metadata level capture by default: files touched, exit codes, retries, outcomes. Never raw prompts, file contents, or diff bodies. Redaction (secrets, PII, entropy scan) runs on device before anything is written. tb audit shows exactly what a session recorded. No servers on my side, no individual metrics.

Known limits, stated upfront

Multi repo. If your product spans N independent repositories, the topology is not cleanly solved yet. Two candidate designs: one brain per repo with read time aggregation at the MCP layer, or a designated brain the others attach to. If this is you, I am especially interested.
Approval latency. There is a gap between a session learning something and the team having it. That is the deliberate price of trust, and I want to know whether it is acceptable in practice.
No real-time human editing surface. Explicit non-goal.

What I am looking for

Five teams of 3 or more developers sharing a repo and using at least two different AI tools. I want the full loop: install, distiller in CI, and at least a few memories genuinely approved through PR. Expect roughly 15 minutes to install and two or three 30-minute conversations over a few weeks.

What you get: hands-on help installing, my read on what your sessions reveal, and real influence on the roadmap. Apache-2.0, npm i -g teambrain, source on GitHub.

What I get: the answer to the only question that matters, which is whether governed memory is usable day to day or merely appealing on paper.

Comment or DM if your setup looks like this. Tell me where it breaks; hard objections help more than encouragement.

donatienmigue / TeamBrain

The brain is a git repo. Memories are markdown files with YAML front-matter, committed like any other file. Git history is the audit trail; pull requests are the approval gate — nothing is written to the shared brain without human review.

TeamBrain

One shared brain for your team's AI coding agents.

Git-native memory that Claude Code, Cursor, and any MCP-capable agent read from — and that your team writes to the same way it writes code: as a pull request someone approves.

The problem

Your team's AI agents start every session knowing nothing. The migration gotcha someone hit on Tuesday is re-discovered on Thursday by a different developer in a different tool. Every session re-reads the same files, re-asks the same questions, and re-derives the same conclusions.

Teams patch this with CLAUDE.md and .cursorrules — hand-maintained files that drift, live in one tool, and only contain what someone remembered to write down. Nobody updates them after the session where they learned the thing.

TeamBrain keeps that knowledge in your repo, serves it to every agent, and proposes new entries from what your sessions actually did — with a human approving each…

View on GitHub

DEV Community: Donatien Migue

Looking for 5 teams to test TeamBrain, PR governed shared memory for your coding agents

donatienmigue / TeamBrain

The brain is a git repo. Memories are markdown files with YAML front-matter, committed like any other file. Git history is the audit trail; pull requests are the approval gate — nothing is written to the shared brain without human review.

TeamBrain

The problem