Your coding agents forget why you built it that way.

Cursor knows your files. It does not know the incident that shaped the retry logic, the RFC you rejected in March, or which service the on-call rota actually pages. That context lives in GitHub, Jira, Linear, Confluence and Slack — and every AI tool you use starts from zero without it.

The context is written down. It is just unreachable.

Engineering organisations are unusually good at writing things down and unusually bad at retrieving them. The reasoning behind a design exists — in a pull request description, a Jira ticket comment, a Confluence RFC, a Slack thread from a Tuesday afternoon eighteen months ago. None of that is where the work happens, and none of it is where your AI tools look.

So the same questions get asked every quarter, and the answers get reconstructed from memory by whoever has been there longest. When that person leaves, the reasoning leaves with them. Meanwhile the coding agents your team now runs all day operate on the narrowest possible context: the files currently open.

• +A new engineer asks why a service retries three times, and nobody can find the incident that set the number.
• +An agent confidently proposes an approach the team rejected, with reasons, in a design review last year.
• +The same architectural debate reruns because the previous decision was never linked to the code it governs.
• +Every AI tool keeps its own private context, so a fact explained to Cursor is unknown to Claude Code.

One graph, read by every tool in the loop

The Brain syncs your engineering surfaces into a single typed graph and keeps it current: issues and pull requests from GitHub, tickets and epics from Jira and Linear, RFCs and runbooks from Confluence and Notion, and the Slack threads where the real decisions get made. Each item becomes a Markdown note with frontmatter and wikilinks, indexed locally in SQLite.

Then it exposes that graph over MCP. Claude Code, Cursor, Cline and Zed query the same memory, so a decision recorded once is available to all of them — with provenance, so the answer cites the pull request or the RFC rather than inventing something plausible. Because the vault is plain files on your own disk, none of your source knowledge is parked in a vendor's cloud, which is usually the sticking point when this idea reaches a security review.

The connectors engineering actually uses

Each is one sign-in from the desktop app, and each has a page describing exactly what it syncs and how often.

What teams weigh this against

Engineering shortlists usually come down to two questions: can we keep it in files we control, and can every AI tool read it?

Worth reading first

The pieces engineering leads tend to send round before an evaluation.

How an engineering team starts

1. 01

   Sync the decision surfaces, not everything

   Start with GitHub and whichever tracker you actually use, plus the Confluence or Notion space where RFCs live. Volume is not the goal — the goal is that reasoning and code end up in the same graph.

2. 02

   Point your coding tools at it over MCP

   Connect Claude Code, Cursor or Cline to the Brain's MCP server. From that moment the tools answer from your decisions and cite them, instead of guessing from file contents alone.

3. 03

   Write decisions where the agents will find them

   Record architecture decisions as nodes in the vault and link them to the services they govern. A decision linked to code is a decision that survives the next reorg.

4. 04

   Let the graph absorb the day-to-day

   Incidents, retros and design reviews flow in through the connectors, so the memory compounds as a by-product of working rather than as a documentation ritual nobody has time for.

Engineering questions

Other teams

• Sales
• Customer support
• Operations & IT