Shared Agent Memory for Teams: GBrain, the Memory-Standards Debate, and What's Missing
GBrain made shared agent memory a team project, and Hacker News spent a weekend arguing about a memory standard. The harder questions are who writes team memory, how it stays current, and who is allowed to read it.

In brief:
• Shared agent memory is moving from a per-developer feature to team infrastructure.
• A common file format, the subject of the Hacker News debate, would help portability. It does not decide who writes memory or whether it is still true.
• Memory that agents or people write by hand drifts as the code and decisions change. Memory derived from PRs, tickets and threads can be rebuilt when those sources change.
• Permissions are the part most setups skip. MCP authorization is optional and covers the connection. It says nothing about which records each person may see.
Shared agent memory works for a team when three things are settled: who writes it, how it stays current, and who may read each part. Most tools answer the first with "the agent" or "whoever updates the file," and that is where team memory goes stale. Unblocked takes a different route. It is a context engine that builds its answers from the pull requests, Jira tickets, Slack threads and docs your team already produces. It serves them to Claude Code, Cursor, Codex, Windsurf and GitHub Copilot in VS Code or JetBrains through one MCP server.
Garry Tan's GBrain, pitched as "one brain for you and your company, read by every agent you use," passed 33,000 GitHub stars. On November 8, a post titled Agent memory needs its OpenTelemetry moment drew 191 points and 110 comments on Hacker News. Two days earlier, Anthropic published research on how agent memory is built, which we covered in what memory from sessions can't see. This post covers what changes when memory belongs to a team.
What is shared agent memory, and why is everyone building it now?#
Shared agent memory is a store of facts, decisions and lessons that every agent on a team can read before it acts, instead of each session starting from nothing. Unblocked is one worked example: an agent in Cursor and another in Claude Code ask the same question and get the same answer, with links to the PR or thread it came from.
Teams want it because single-agent memory stops at the edge of one tool. Claude Code's docs say each session "begins with a fresh context window," and its auto memory "is machine-local," so notes one engineer's agent saves never reach a teammate. GitHub's Copilot memory shares repository facts "with your collaborators," but only "in operations on the same repository."
What does GBrain do, and who is it for?#
GBrain is an MIT-licensed, self-hostable memory server that Claude Code, Codex, Cursor and other MCP clients check before they answer. Its README says setup writes a "brain-first" instruction into the agent's config, because "agents seldom call an MCP server nobody told them about."
The core content is Markdown you point it at. That means your notes plus a company folder with a facts.md, a decisions.md that records "each decision with its date, its reason and who made it," and call transcripts. It can also sync Slack channels, meeting notes, Gmail and Calendar. For teams, the company-brain tutorial adds per-user OAuth credentials that decide which sources each person can read and write for a 10 to 50 person company.
GBrain is careful about its limits. It reads only committed files in a git folder, and its gbrain think command notes when a page is stale. The README also warns that its authorization tests "exercise specific access paths, not a universal no-leak guarantee." What it holds is still what someone wrote down.
How do shared agent memory options differ on who writes, reads and updates them?#
Six options exist today, and they differ most on who writes the memory and how it stays true. Methodology: each row comes from the vendor's own docs, read on 2026-11-15, not from hands-on testing.
| Option | Who writes it | Shared with | How it stays current | Permissions |
|---|---|---|---|---|
| CLAUDE.md / AGENTS.md | Engineers, by hand | Anyone who pulls the repo | Pull requests to the file | Repo access |
| Claude Code auto memory | Claude, from your corrections | Only your machine | Claude edits its own notes | Local files |
| Cursor team rules | Admins, in the dashboard | All team members | Admins edit them | Team admins |
| Copilot memory | Copilot, from its work | Collaborators on one repo | Citation checks, 90-day default expiry | Repo read access |
| GBrain | People and agents, plus synced Slack, meeting and email pages | Clients granted a source | Sync after commits, stale flags | Per-client source grants |
| Mem0 | An LLM extracting facts from chats | Your Mem0 account and API key | New memories accumulate | Scoped by user, agent, app, run IDs |
Cursor team rules "automatically apply to all team members." In Mem0, an LLM "pulls out key facts, decisions, or preferences," and memories are "ADD-only."
Why does agent memory need an "OpenTelemetry moment"?#
Memory formats are too fragmented for teams to share, the argument goes. In the post behind the Hacker News thread, published November 7, Mads Thines points out that instruction files, Anthropic's memory tool, Copilot's repository memory and MCP knowledge-graph servers each store memory their own way. "The problem isn't a missing tool. It's a missing agreement," he writes. Thines builds LoreKit, an open-source memory tool.
His example record, which he says illustrates the data model rather than proposing field names, carries written_by, version, supersedes and an expires_at date. Those map onto the team questions: who wrote this, what replaced it, and when it stops being true. He also notes that existing proposals focus on export between vendors, while live sharing, where a CI job, an editor agent and a review bot use one store at once, stays open.
The comments pushed back hard. One reader said "it's too early to advocate for standardization." A few had switched memory off over drift, in favor of hand-kept docs in the repo. A shared format would make memory portable and leave the truth of each note to whatever checks it.
Who writes team memory?#
People, models or extraction services. Thines calls this the "one real fork" in memory design and suggests recording which one wrote each memory. Memory provenance is that record: who or what wrote a memory, when, and from which source, so a reader can judge how much to trust it.
Each writer fails in its own way. People forget to update decisions.md after the meeting where the decision changed. Models save what looked important in the moment. One commenter wrote that "Claude Code often tries to write one-off decisions and transient problems into memory." Extraction services such as Mem0 turn chat turns into facts, which suits preferences more than decisions argued out in a PR review the agent never saw.
There is a fourth option: nobody writes memory as a separate act. The pull request, the Jira ticket and the Slack thread already record who decided what and when. A context engine answers from that record, so the author of each claim is whoever wrote the source.
How does shared memory stay current?#
Only if something checks it. Anthropic's components of agent memory research warns that "memory can also drift and become irrelevant as the environment changes". It adds that Claude can "write rules to memory that are wrong from the start". In its own tests, agents writing to a shared table at the same time "had overwritten one another's work."
For example, say that in March a team sets a payment client's retry count to three and an agent saves that as a memory. In June, an incident review lowers it to one, shipped in a PR that links the review. The saved note still says three, and a shared store spreads that error to every agent on the team. Agents also tend to obey the note. An August 2026 study of coherence debt in coding agents looked at what happens when a written standard and the code disagree. Agents "follow the standard even when it prescribes the worse code, so a stale convention file costs more than no file."
Copilot checks each fact's citations "against the current branch" and by default drops memories after 90 days without reinforcement. GBrain flags stale pages. Mem0 adds new memories alongside old ones. What ages best is a claim tied to a source record, so it changes when the source does.
Who is allowed to read shared agent memory?#
Deciding who may read each memory is the hard part, and the protocol leaves it to you. The MCP authorization spec says authorization is "OPTIONAL," and where it is used, it lets a client call a server on a user's behalf. It does not say which records inside the server that user may see.
So each tool answers on its own. GBrain's company brain gives each teammate an OAuth client scoped to the sources they can read and write. Mem0 scopes memories by user_id, agent_id, app_id and run_id. Those IDs separate contexts, and the page does not describe access control between teammates. Its MCP server keeps memories "in your Mem0 account."
Copied knowledge is the tricky case. A note summarizing a private channel or a security incident is readable by anyone the memory store allows, whatever the original channel's rules were. A team memory server should check the source's permissions at read time or hold nothing its least-privileged reader can't see.
Which layer should hold which kind of team knowledge?#
Teams that make this work use three layers, one per kind of knowledge.
- Repo files for conventions. CLAUDE.md or AGENTS.md holds build commands, test setup and style rules. Claude Code's docs describe project instructions as shared with "team members via source control," so changes go through review like code.
- Personal memory for personal habits. Auto memory, Copilot user preferences or a personal GBrain hold how one engineer likes to work.
- A shared context layer for the why. Decisions, ownership, past incidents and cross-repo contracts live in PRs, tickets and threads across many repos. A context engine is a service that reads those systems, resolves conflicts between them, and gives every agent the same cited answer. Unblocked is built for this layer.
The mistake is stretching layer 1 or 2 to cover layer 3, a trap we described in team memory hubs for AI agents. Our comparison of memory tools for coding agents goes deeper on Mem0, Letta, Zep and Cognee, and context engineering across hundreds of repos covers the multi-repo case.
How does Unblocked derive memory from where the work happens?#
Unblocked skips the separate memory-writing step. It connects to code hosts, issue trackers, docs and Slack or Teams, and answers from those records with links back to each source. Agents reach it through the Unblocked MCP server; people ask in Slack or the web app.
On permissions, Data Shield is set per data source. It is off by default for every source except Slack, where it is always on. With Data Shield on, answers include only source material the person asking is allowed to see in that source system.
At Codat, every engineer uses Unblocked, and agents in Claude Code pull context through its MCP server, per the Codat customer story. Matt Thompson described a day it went missing:
I came back from a week off and my Unblocked session had expired. I didn't notice before I started working. Very quickly, Claude was doing web searches for Codat, trying to figure out what our products were. I cancelled it, re-authenticated Unblocked, and told Claude to try again. One question, got the answer, carried on.
Matt Thompson — Staff Software Engineer, Codat
Without the shared layer, the agent fell back to guessing from the public web. See also agent memory vs context.
Frequently asked questions#
Is GBrain a good fit for an engineering team?#
It fits teams that want a self-hosted brain built from Markdown they curate, plus synced Slack and meeting notes. The company-brain tutorial targets 10 to 50 people. Its README does not list pull requests or issue trackers as native sources, so decisions made in PR reviews and tickets need someone to write them into pages.
Will a memory standard fix stale memory?#
Partly. Fields like supersedes and expires_at let tools mark a note as replaced or expired. A standard cannot notice that yesterday's PR made the note wrong.
Can Claude Code and Cursor share one memory today?#
Yes, through any MCP server both can call, such as GBrain, Mem0 or Unblocked. Their built-in memories stay separate.
Where this leaves your team#
Shared agent memory is turning into team infrastructure. Before you pick a tool, answer three questions. Who writes each memory, and is that recorded? What makes a memory update when the code or the decision changes? Which teammates may read a memory copied from a restricted source?
If the honest answers are "whoever remembers," "nothing," and "everyone," start smaller. Keep conventions in reviewed repo files and personal habits in personal memory. For decisions, ownership and incident history, point agents at a layer that reads the PRs, tickets and threads where that work already happened. That is the job Unblocked does as the context engine for engineering, and our explainer on what a context engine is shows how it fits next to the memory you already run.


