TL;DR: Connect a team memory to Claude Code over MCP once, and every engineer and coding agent on the project can pull the customer's commitments, decisions, and risks mid-session instead of pinging the FDE. Context is the working lever on quality too, since 30% of developers report little or no trust in AI-generated code. At Aircall, engineers query rollout context through Claude via MCP and run 3x rollouts per engineer (5 → 15). This guide walks the setup, the queries worth running, and the sync back at session end.
An engineer building an integration for a customer they've never met is working blind in one specific way. The code context is all there, in the repo and in CLAUDE.md. The account context isn't: which endpoints the customer's IT team refused, what the FDE promised on the kickoff call, which date is frozen. So the engineer interrupts the forward deployed engineer, or guesses, and their coding agent guesses with them.
An FDE at a vertical AI startup described the state he's trying to reach: "engineers […] using the claude code, and they feel like […] this product is helping them to get up to speed on the context." That's the job this article does. It's a how-to for wiring account context into Claude Code through Tandem MCP, so the question "what did we promise this customer" gets answered in the session, from sources, without the FDE in the loop.
Why your coding agent needs the customer's context
A coding agent's output quality tracks its input context, and the input that's usually missing isn't technical. Sourcegraph defines context engineering as "deliberately designing what a large language model sees on every inference call," and for client work the thing the model needs to see is the account's reality: constraints, commitments, and history. Feed it none of that and you get plausible code aimed at the wrong target, which is one reason 30% of developers still report little or no trust in AI-generated code.
The deeper cost is organizational. When account context lives in the FDE's head, engineers and their agents can't build without routing every question through one person, and the FDE becomes a courier between the customer and the codebase. That's the shared context problem at its most expensive, because it throttles exactly the people hired to scale delivery. The feedback loop between deployment and product breaks the same way.
Why not just paste the context in?
You can copy a status doc into every session, and plenty of teams do. The problem is that pasting is per-session, per-person work, and the pasted snapshot is stale the moment the account moves. The Model Context Protocol exists to replace that ritual. MCP is an open-source standard for connecting AI applications to external systems, described in its own docs as being "like a USB-C port for AI applications," and it's supported by Claude, ChatGPT, VS Code, and Cursor. One connection, registered once, and every session on every configured machine can query the live source. Users pushing for a shared layer across Claude surfaces are asking for exactly this property: set up once, available everywhere.
Here's how the options for getting account context into a session compare.
- Spreadsheets + Slack (copy-paste in). Freshness: Stale at paste time, varies by team. Effort per session: High, repeated by every person. Sources attached: No. Works for the agent unprompted: No.
- Account notes in CLAUDE.md. Freshness: Stale until someone edits the repo. Effort per session: Low after setup. Sources attached: No. Works for the agent unprompted: Partially, it loads at start.
- Uploading docs or transcripts to the session. Freshness: Snapshot only. Effort per session: Medium, every session. Sources attached: Raw, unreconciled. Works for the agent unprompted: No.
- Team memory over MCP (Tandem MCP). Freshness: Live at query time. Effort per session: Near zero after setup. Sources attached: Yes, quotes linked to each fact. Works for the agent unprompted: Yes, the agent can query mid-task.
Why CLAUDE.md can't hold account state
It's tempting to treat CLAUDE.md as the account file, since it's already shared through git. The memory docs point the other way: project memory is for conventions and instructions, auto memory is machine-local, and the loaded budget is small, with only the first 200 lines or 25KB of MEMORY.md reaching context. Account state also changes at call speed while the repo changes at PR speed, and the colleagues who most need commitments never clone repos. We took that apart in detail in Claude Code memory for teams. Keep CLAUDE.md for code context, and give account context a home built for it, a project brain with sources and reconciliation.
How to connect Tandem MCP in Claude Code
Tandem, the AI workspace for implementation and deployment teams, exposes the account brain through an MCP server called Tandem MCP, reachable from Claude, Claude Code, or ChatGPT. Setup is a one-time job.
- Add Tandem MCP as a server in Claude Code. Register it the way you register any MCP server, with claude mcp add or an entry in your project's .mcp.json. No pipeline to build, the server is the product's front door.
- Authenticate with your Tandem workspace. Sign in so the connection knows which team's brain, and which customer accounts, it can read.
- Verify the connection in a session. Ask Claude Code what tools Tandem MCP exposes, or skip straight to a plain question about a live account and check the answer comes back with sources.
- Commit the project-scoped config so the team inherits it. Checked into the repo, the connection travels to every engineer who clones, the same distribution trick that makes a shared CLAUDE.md work.
- Make the first query part of starting work. Pull the account brief before writing code, the same way you'd pull the branch. A founding FDE at a pre-seed startup reacted to the workflow in one line: "I extensively use Claude Code. This is something that I would be very happy to use."
What to query mid-session
Three queries do most of the work once the connection is live.
The brief
Ask for the current state of the account before you touch anything. The brief is generated on demand (or scheduled, delivered anywhere including Slack), and it answers the four questions that define shared context: what was promised, what was decided, what's at risk, what's next. Five minutes of reading replaces the thirty-minute walkthrough call with the FDE.
The risk check
Before committing to an approach, ask the brain what's at risk on this account. The risk check returns a list of risks, each with an explanation, the reason, and the sources and quotes behind it. If the approach you're about to take collides with something the customer was told in March, this is where it surfaces, while it's still cheap to change course.
Commitments and decisions
Mid-task, the agent can query point facts without you prompting it: which porting date was agreed, why polling was chosen, what the customer's security team ruled out. This is the query pattern Aircall runs in production. Engineers query rollout context (commitments, porting dates, integration decisions) through Claude via MCP, and Paul Yi, a senior software engineer there, described the result: "Same question, same answer, whoever asks."
Syncing the session back
The connection runs both ways. When a session produces a decision the team should keep, you push it to the brain through the same MCP connection, choosing exactly what goes. The full loop, including what makes a synced decision useful months later, is covered in getting product decisions out of Claude Code sessions. The short version: query on the way in, sync what you choose on the way out, and the brain stays live for the next engineer's step one. Several people can push to one brain, with alert recipients configurable, so the FDE sees what engineering learned without a status meeting.
What stays manual
The sync is yours to trigger. Nothing flows from a session into team memory unless a person chooses it, and every agent action against the brain happens with a human approving it. That's deliberate, and it means the capture habit is still a habit.
Checkpoint resync isn't shipped. An FDE at an industrial-AI company asked whether the session could, "on every checkpoint termination, you know, resync itself back to your brain." Not today. You sync at moments you pick.
Judgment doesn't transfer over MCP. The brain tells an engineer what was promised and why a decision was made. Whether to push back on the customer's frozen date is still a call a person makes, usually the FDE, and no query replaces that.
Give every session the same memory
Wired up, the pattern changes who can do the work. Engineers run accounts they've never been on a call for, agents write code aimed at the customer's actual constraints, and the FDE stops being a lookup service. Aircall's version of that outcome: 3x rollouts per engineer (5 → 15), with time from contract to cutover cut 30%. See Tandem answer "what's blocking the cutover" on one of your own live implementations, in a demo.
FAQs
Does this only work in Claude Code?
No. Tandem MCP is reachable from Claude, Claude Code, or ChatGPT, so the same brain answers the engineer in a terminal, the manager in Claude chat, and briefs land in Slack. MCP is the connector standard, not a Claude Code feature.
Can engineers really query account context without the FDE in the loop?
Yes, and that's the operating change that pays. At Aircall, engineers pull commitments, porting dates, and integration decisions through Claude via MCP and get the same sourced answer the FDE would give. The FDE curates the memory instead of answering the same question forty times.
What does the risk check actually return?
A list of risks, each with an explanation, the reason it's flagged, and the sources and quotes behind it. It's an answer you can verify, not a score, which is what makes it usable in front of a skeptical engineer or a customer.
Will my coding agent modify the brain on its own?
No. Agents query freely, but pushing anything into team memory is a human-triggered, human-approved action, and you choose what syncs. Automatic resync at checkpoints is a user request, not a shipped behavior.
Do we still need CLAUDE.md if we have Tandem MCP?
Yes. CLAUDE.md remains the right home for code conventions, commands, and repo know-how, shared through git. Tandem MCP adds the layer CLAUDE.md was never meant to hold, the customer's live account state. The two together cover both halves of the context an agent needs.
Key terms
Shared context: the account's memory made queryable by the whole team and its agents, answering what was promised, decided, at risk, and next, with sources.
Account brain: Tandem's product part. A per-customer, source-linked memory with risk detection, Tandem agents, and a customer workspace.
Brief: a generated summary of an account's current state, on demand or scheduled, delivered anywhere including Slack.
Risk check: a query returning a list of risks, each with an explanation, the reason, and sources and quotes. The brain reading itself for trouble.
MCP (Model Context Protocol): the open standard for connecting AI applications to external systems, supported by Claude, ChatGPT, VS Code, and Cursor.
Tandem MCP: Tandem's MCP server. The connection through which Claude, Claude Code, or ChatGPT query the account brain and push chosen updates back.
Context engineering: designing what a model sees on each inference call. For client work, that means account reality, not just repo contents.