I often run many Claude Code sessions on one server at once. What they say to each other, the coordinator habit that helps most, and what I want to automate next.
I run a lot of Claude Code sessions side by side on the same server: one fixes a bug, one works through a data queue, one drafts replies. The sessions can send each other messages, and I use that every day. I went through two months of my own session logs to see what they actually say to each other. This post is what I found, and what I plan to change.
How the sessions find each other
Claude Code can list the other sessions running on the same machine and send one of them a message. The message arrives in the other session as a new turn, so it can act on it or answer. I give each session a short name after its task when I start it, so a message reads like "from the deploy session: the test environment is free". An unnamed session gets a technical address instead. That works, but it makes the logs hard to read afterwards.
What they actually talk about
Between mid-September and mid-November 2026, 140 of my sessions sent each other about 1,750 messages. I sorted them with simple keyword rules, so treat the split as rough:
- Shared test environment and releases, about 43%. "I am taking the test environment, hold your builds until I say it is free." Two sessions building into the same tree at once is the most common collision.
- Who owns which change, about 14%. Before a session commits, it asks the others whether an uncommitted file is theirs, so it never ships someone else's half-finished work.
- Conflict warnings, about 14%. "Do not run the import until I report done."
- Status requests, about 7%. One session asks the others for a short report, so I answer one combined list of questions instead of visiting every window.
- Handing over work, a small share. One session briefs another with context and a next task.
Only 9 of the roughly 1,330 sends I could check failed, all for the same reason: the other session had already closed.
One session as coordinator
My most useful habit is to let one session act as coordinator for the day. It knows the plan, briefs the others and collects their answers. A good briefing has four parts:
- Context: what was already shipped today, and why.
- Scope: what this session may touch, and what it must leave alone.
- The ask: one task, plus the point where it must stop and ask me.
- Report format: for example "answer in one message: what is still running, what is uncommitted, what you need me to decide".
The report format matters most. Without it, answers come back as long stories that I end up reading in full anyway.
What a message cannot replace
Messages are a polite agreement between agents, not a guarantee.
- A lock that lives in a chat message disappears when the session closes. If the session that took the test environment stops halfway, the others wait for a "free" that never comes.
- Ownership answers depend on memory. A session usually knows what it edited, but after a long day with summarised context it can get it wrong.
- Nothing stops a session that never asks. The agreement only protects the work of sessions that follow it.
What I am changing next
None of this is built yet. The plan:
- A real lock for shared environments. A small command claims the lock with the session name, the purpose and the time, and the release script refuses to run while another session holds it. A lock left behind by a closed session is easy to detect and clear. This should remove most of the 43%.
- An edit log per session. A hook records every file a session edits, so the commit step knows which files are its own without asking around.
- A name for every session. Readable names make the logs and the coordinator's job easier.
- A check before sending. List the running sessions first, because every failed send went to a session that had already closed.
- A fixed briefing template for the coordinator, with the four parts above.
What I do not know yet
The percentages come from keyword matching, not from reading every message, so the categories overlap at the edges. I have not measured how much time the coordination costs or saves. And because the lock and the edit log do not exist yet, I do not know how many messages they will really remove.
Frequently asked questions
Do the sessions share memory?
No. Each session has its own context. They share only the files on disk, the project instructions and whatever they tell each other in a message.
Is one big session with subagents not simpler?
For one task, yes. Subagents report only to the session that started them, and they finish when the task is done. Separate sessions suit separate pieces of work that I want to follow and steer on their own, which is how most of my days look.
What goes wrong most often?
Two sessions changing the same shared environment at the same time. That is why a real lock is first on my list.
What to do first
- Give every session a short name after its task when you start it.
- Pick one session as the coordinator for the day, and send all briefings from it.
- Ask for answers in a fixed format: still running, uncommitted, decisions needed.
- Before a commit, ask the other sessions which uncommitted files are theirs.
- Replace any lock that only lives in a message with a lock that your release step checks.
More on how I work with Claude Code and automation is on the blog.