Campfyrr vs Kawa Code: agents editing the same lines, or following different decisions
By Soumen Sarkar · October 2026
Comparison. If your agents keep editing the same lines as a teammate's, use Kawa Code: it flags overlapping uncommitted edits at the end of each turn. If your agents write different lines from different decisions, use Campfyrr: it briefs each session on what the team decided before it works. Many teams have both problems.
What are you trying to fix?
If two people's agents keep editing the same lines, use Kawa Code. If two agents keep following different decisions, use Campfyrr. Many teams have both problems, and the two tools don't get in each other's way.
- "My agent and my teammate's agent both rewrote the same function, and we found out at merge." Kawa Code. At the end of every turn, its Stop hook tells the agent when a teammate's uncommitted edits overlap the lines it just touched (Kawa Code MCP).
- "Two agents built two halves of a feature on two different ideas of what we agreed." Campfyrr. It tells each session what was decided in an area before it works there, and shows when a new decision replaces an older one.
- "An agent made a guess nobody checked." Campfyrr. The assumption goes to the person best placed to confirm it, and the answer reaches the agent at its next turn.
The same day, with each
Here's a scene, not a customer story. Three developers and a PM. On Monday the PM decides EU customers see prices with tax included, everywhere.
Collision one: the same lines. Ana's agent is reworking the invoice total. Ben's agent, fixing a rounding bug, edits the same function. Neither has committed.
With Kawa Code, Ben's agent hears at the end of its turn that Ana has uncommitted edits on those lines. They sort it out in two messages. If Ben's agent runs in its own worktree, Kawa can judge the overlap and write the safe part of the merge itself; on a person's checkout it only suggests. With Campfyrr, nothing compares lines. Ben's agent is told Ana has work in progress in that area, with her plan, but the overlap itself surfaces as a merge conflict. That's half an hour, maybe more.
Collision two: the same decision. Ben's agent moves on to the invoice email. The template shows prices before tax, from an older note. It builds on that. Not one line overlaps Ana's, so a line check stays quiet.
With Kawa Code, the agent gets the decision if it calls get_relevant_context at the start of the request, as Kawa's workflow asks, and if the PM's call was recorded. Kawa retired its before-edit check on 14 August 2026, because it read only the 100 most recent decisions per repository and long-lived ones aged out (commit). If the call is skipped, customers get an email with one total and an invoice with another. With Campfyrr, the first time Ben's session opens the email template, its brief lists the PM's decision, with the reason and who made it. The email shows the tax-included total. If someone does change the rule later, the newer decision replaces the old one and the clash is shown. See what to do when agents decide opposite things.
At the end of the day, Kawa saved the team a merge fight. Campfyrr saved them a mismatched invoice.
When Kawa Code is the better choice
- Your pain is edit collisions. Several agents or people in the same files, colliding before commit. Campfyrr has nothing that compares lines.
- You run agents in their own worktrees and want merges done for you. Kawa's
arbiter_apply writes the safe tier of a merge there (README). - You want a decision history on day one.
infer_history mines your past commits into intents and decisions, using your own Anthropic API key, with a cost estimate first. - Your team is all engineers who live in the agent and don't need updates for product or support.
What it costs
Kawa Code: we couldn't find published pricing; its README doesn't mention a price. Ask Kawa before you budget, and count the Anthropic API spend of infer_history. Campfyrr: Team is $9 per developer a month, minimum 3, or $7 billed yearly; business teammates are free (Pricing). For 5 developers and 3 business teammates, that's five times $9, so $45 a month, or five times $7, so $35 a month billed yearly. Everything is free during early access.
The daily cost matters more. Kawa needs its desktop app running, and its decision recall depends on the agent following the workflow in CLAUDE.md: recall, open an intent, record decisions. Its overlap check runs on its own. It captures code blocks from commits, encrypted before sync, by its own account. Campfyrr's hooks do the briefing, so nobody runs a command; people act only to answer assumptions from a link. It never takes your code or diffs (Trust).
Verdict
Choose Kawa Code if agents and teammates keep editing the same lines before commit, and you want to hear about it at the end of the turn, with safe merges in agent worktrees.
Choose Campfyrr if agents act on decisions that changed or never reached them, or sessions don't know about each other. To see what a session gets, see the demo.
Use both if you collide at both levels. Run one worktree per agent, which Kawa needs for its merges anyway. Every product in this space is in our research.
The problem this answers: Agents ignore team decisions: "Agents break team decisions, and CLAUDE.md doesn't help."
The principle behind this: Build on what's coming: Unfinished work is a promise, and a promise can be built on.
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).