There's a public feature request on the Claude Code repo, issue 38536, asking for shared team memory. The first pain point is a sprint handoff.
An engineer starts a task, builds deep context with their agent, then hits a blocker. A different engineer picks it up. Today, that second person either rebuilds the context from scratch, asks the first engineer to export it and attach it to the ticket, or gets a verbal recap. The issue calls those last two options "friction-heavy, rarely done well" and "a verbal summary that loses nuance and technical detail."
What the issue says should happen: the second engineer's agent already knows what was tried, what failed, what the blockers were, and what approach was in progress.
I wanted to run that handoff, on this same ticket, with two coding agents that share one memory. Full disclosure: I build Palace, so this is me showing my own work.
Two developers. One ticket. Here's what happens when their coding agents share one memory.
That's about 90 seconds. Below is the same walkthrough, slower, with the sources.
The setup
Palace Server is the self-hosted team edition. It runs on your own infrastructure as Docker Compose or a single binary, with Postgres and pgvector, and embeddings computed there. The open source solo engine, palace-rs, stays free if you're working alone. This walkthrough is the team path.
I pointed two isolated environments at one Palace Server, each with its own API token, the way two developers' laptops would be set up. Nothing was copied from A to B. Both talk to the same server over MCP.
On each machine, after you have a token:
palace remote set --endpoint https://palace.yourco.com
palace remote on
palace install
palace remote test
palace remote set prompts for the API key and stores it (mode 0600) in ~/.palace/config.json. palace remote test runs the MCP handshake and reports the tool count. Client registrations do not change. Cursor, Claude Code, and Codex keep using the same MCP setup. They just point at the shared server.
Issue one token per developer. Do not share a single key across the team. How to mint the second token is in the connect docs. The install and remote commands are in the palace-rs README.
What Dev A saved
Dev A worked through issue 38536, "Shared Team Memory for Claude Code," and saved three things the thread already rules out, each with a why and a source.
1. Exporting agent context and attaching it to the ticket by hand.
The issue describes this as friction-heavy and rarely done well. A verbal summary loses nuance and technical detail. Source: the sprint handoffs section of the issue itself.
2. A project CLAUDE.md as the team memory.
The issue calls project-level CLAUDE.md "static sharing." That is a real use, and I still use one for conventions that rarely change. It is a poor fit for an investigation in progress, because updates only reach a teammate after commit, push, and pull. A comment on the thread asks for decisions and context updates to be "visible immediately, not after commit-push-pull."
3. One shared API secret for the whole team.
A later comment from someone running shared memory in production puts this plainly. The "engineer leaves the team" case is the headline scenario, and rotating one shared secret (which kills everyone's tokens) is painful enough that, in practice, nobody does it, so departed members keep access. The fix they argue for is per-member credentials that you can revoke one at a time.
That is also why A and B did not share a key.
What Dev B got back
Dev B opened a fresh session on the other machine. Nothing was copied over. They asked:
What did we already rule out on this ticket, and where's the evidence?
Palace returned all three findings, ranked, each with a source link. B checked when each one was filed and where the evidence lives, then opened the source. It is the original issue on GitHub, and the comments above.
Nobody had to redo the investigation. Nobody had to paste a recap into the ticket.
The recording shows those MCP calls (save, search, and open the source) against a live self-hosted server. That is the same path your agents use once palace install has registered them.
When a markdown file is enough
I don't think CLAUDE.md, a decisions/ folder, or good commit messages are a waste. For one person, on a small repo, with decisions that rarely change, they work. Keep them.
They recall what someone wrote down, when they remembered to write it. They do not, by themselves, carry a live investigation from one teammate's agent to another's: what was tried, why it failed, and the source, available in a fresh session on another machine, without a git pull.
If you are solo, the open source engine is enough. The palace-rs README has the install. This post is about the handoff you cannot do with a file in the repo.
Try it on one of your tickets
Pick a real issue on your team. Deploy Palace Server on your own infrastructure (the starter kit is in the docs). Connect two developers, each with their own API token. Dev A saves what they tried, why it failed, and the source. Dev B, in a fresh session, asks the same question: "What did we already rule out on this ticket, and where's the evidence?" If the answer cites its source, the handoff is doing its job.
If you need a security review, there is an IT brief you can forward.
Try this with one teammate and one ticket. Give both agents access to the same investigation on your own infrastructure. The team trial includes 10 seats for 60 days, with no credit card.
If this helped your teammate continue the investigation, keep the shared server on Team for €149/month for up to 10 developers. Get Team.
How do you pass an investigation to a teammate's agent today? A ticket comment, a Slack recap, a CLAUDE.md, or do they start over? I read every comment.



Top comments (0)