For engineers running three or four sessions at once
By Soumen Sarkar · October 2026
For you. If you run three or four Claude Code sessions at once, Campfyrr works in the background: each session gets a brief on what the team knows the first time it reads or edits a part of the code, and a handoff is written when a session stops, so your next session opens on it. There's nothing to fill in.
What does your day look like right now?
You have a session fixing a bug, another building a feature, a third writing tests, and maybe a fourth reading code you don't know yet. Each one is fast and good. You move between terminals, answer a question here, approve a plan there, and keep the threads in your head.
Worktrees keep the files apart. Claude Code starts a session in its own git worktree with claude --worktree <name>, a separate checkout on its own branch, so parallel edits don't collide (Claude Code docs). Use them.
What worktrees don't carry is the thinking. Your session in the billing code doesn't know a teammate's session is reshaping the same area this afternoon, or that the team decided last week how retries work there. And when a session stops halfway, because the context compacted or you closed the laptop, what it knew stays in a transcript on your machine. You can reopen your own with claude --continue or claude --resume (Claude Code docs). A teammate can't.
None of this is the agents' fault. They do exactly what they can see. What's missing is between the people running them.
What changes with Campfyrr?
Very little that you have to do. Campfyrr runs as hooks and an MCP server in Claude Code, and the help arrives on its own.
- Briefs you don't ask for. The first time a session reads or edits a part of the code, a hook adds what the team knows there: what's being changed right now, what was decided, what changed this week, what was tried and dropped, and open assumptions. Your session reads it before it writes. See area brief.
- Fewer collisions. Because the brief shows the work in progress in an area, your session builds on what a teammate is changing instead of around it. It follows the decisions listed there instead of breaking them.
- Handoffs you don't write. When a session stops unfinished, the hook writes a handoff from it: what's done, what's left, the next step, the traps and the open questions. Your next session opens with it under "Pick up where it was left". The transcript itself isn't kept.
- A feed, not a form. The project's Activity page is a read-only feed of what the team's sessions did. You read it when you want to. You don't update it.
What does this look like on a real codebase?
We build Campfyrr with Claude Code, several sessions at a time, and every session on this repository runs the hooks. The repository's own instructions to every session say:
The work hook adds what the team knows about each part of the code the first
time you touch it. Follow the decisions it lists, and build on work in
progress there rather than around it.
That one line is the whole contract with the engineer. The brief does the telling, and the session does the following.
How do you take over a teammate's work?
Paste their handoff into the first prompt of a fresh session. There's no button for this yet.
- Ask your teammate to push their branch.
- Check out the branch in its own worktree.
- Start a fresh session there.
- Paste the handoff into your first prompt.
- Tell the session to do the next step first.
The longer method is in handoffs lose context.
What doesn't Campfyrr do?
- It doesn't run, schedule or isolate your sessions. Keep your worktrees and your terminal setup.
- It doesn't merge code or move your branch. Push as usual.
- It doesn't run tests or replace CI. Your checks run where they run today.
- It doesn't replace your tracker. Issues stay where your team files them.
- It has no audit logs yet.
What are the first three things to try?
- Connect Campfyrr from /connect. The paste installs the hooks and the MCP server.
- Start two sessions in the same part of the code. Read the brief the second one gets.
- Stop a session halfway on purpose. Start a new one and read "Pick up where it was left".
If your sessions keep stepping on a teammate's, read your teammates' sessions don't know about each other and do git worktrees stop parallel agents conflicting?. To see why a shared record beats sharing whole sessions, read sharing sessions vs shared memory.
What's free for you?
Everything, right now: Campfyrr is free for everyone during early access. After that, it stays free for one person, and teams pay $9 per developer a month (pricing). The idea behind it is keep moving: your sessions don't stop to ask who else is in the code, because the answer is already in front of them.
The problem this answers: Sessions don't know about each other: "My teammates' Claude Code sessions don't know what each other are doing."
The principle behind this: Keep moving: The work never waits, and neither do we.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).