Coordinating intent

“Multi-worker fleets polling with --claim currently double-fill.”

“These “megafiles” choke everything. They’re expensive to transport, diff, and merge, and become the site of constant collisions.”

“I noticed that when we have multiple agents or multiple Claude Code instances running, that it happens that they work on the same files sometimes resulting in overriding each other's work before changes are saved or committed.”

“some agents were a bit too “ambitious”, trying to solve problems that weren’t strictly in their prompt, like refactoring code or disabling flaky tests.”

“Two workers polling within the same window can both observe the same ready bead, both claim it, and both begin work. Result: duplicated work, near-identical PRs, wasted compute.”

“bd list over the molecule's 50 step beads reported open=50, in_progress=0, closed=0 — zero progress reflected in the cached read.”

“Agents spawned via MCP tools (agent_spawn, mcp__claude-flow__agent_spawn) cannot communicate with each other using daa_communication.”

“Both sessions execute the same step. The losing session does not detect that it lost the claim — it had already started before the winning session's claim was persisted.”

“Every agent would hit the same bug, fix that bug, and then overwrite each other's changes. Having 16 agents running didn't help because each was stuck solving the same task.”

“the agents need to understand where everything lives and what depends on what. So, we built a company world modeled based on the entirety of our 25,000 repo code base”

“with the pull request it’s even worse now because they come in so quickly, that many of them cannot be merged anyways without manual resolution of the conflict. And there’s a there’s a lack of back pressure mechanism.”

“So basically what we need are bottlenecks. I’m not necessarily I don’t necessarily need human verification or verification that you’re human. I just need a bottleneck that allows me to process the amount of incoming things as a human”

“we were blocked on merging the PR we needed someone else to um to review it for us and maybe they were in a different time zone perhaps. So what we started doing was building this agentic code owner thing”

“Under the repo's own "worktree-per-writer" rule, each worktree (and each Claude Code session with a different cwd) reads and writes a different claims.json, so claims_claim / claims_board / claims_steal do not coordinate the sessions they are meant to coordinate.”

“It has rules in its shared memory, and I keep asking it specifically to check the Claude.md file for the rules before it executes, but it just doesn't.”

“And also coordination debts. This is when you get really hairy merge conflicts because agents will touch in the same files or developers even doing duplicated work because they both picked up a thing and tried to finish it in one day.”

“Workers can't see each other's beads. A bead created by agent A is invisible to agent B until A's branch merges to main.”

“There's a JSON file, one line per issue, and it has merge conflicts all the time, and it gets xlerped into the database, and there's a daemon, and it gets stale.”

“It's had stalled workers, runaway workers. I had to kill 320 Claude Code instances on my machine the other day.”

“Then one day a swarm took off and fixed all my bugs. I had like 30 Beads all like lined up to knock out. And I couldn't find them, and I panicked.”

“There were the serial killer sprees, viciously taking out random workers mid-job. (It's always the Deacon, the modern-day Butler in the Gas Town murder mysteries.)”

“It turned out I had 141 orphaned claude code processes. The polecats were not being nuked correctly, so I needed to manually clean them up.”

“I experienced this first hand when an agent overwrote a config file entirely. Thankfully it was recoverable via git.”

“The mail system (polecat → Mayor status) needed patching when I first used it, and seemed to break down mysteriously.”

“Real risk of a contributor believing a fix is committed/shipped when their working tree has silently been reverted underneath them, especially if they don't diff before committing.”

“during incidents, many responders would concurrently send off their own agents. That had a cost: tokens, yes, but more importantly the responders’ attention.”

“For example, 10 agents making 3 attempts each results in 30 executions, even before considering tool-call fan-out. If each attempt triggers multiple APIs or CI jobs, downstream work increases faster than the number of agent runs.”

“A durable work record is not the same thing as a durable procedure.”

“Because every dispatch reparsed the entire file under a lock, order firing froze. One wedged session claimed the same bead ten times over 5.6 hours.”

“It can launch another agent and leave two processes editing the same worktree.”

“Ruflo is the coordination ledger and policy decision point. Claude Code executes code, tests, commands, and file changes. A Ruflo coordination call records work; it does not perform the implementation.”

“Never allow two writers in one worktree. Give every writing agent an isolated worktree and explicit file ownership.”

“Agents would hold locks for too long, or forget to release them entirely. Even when locking worked correctly, it became a bottleneck.”

“calculateRequiredVotes() derives the quorum threshold from state.workers.length, so a single caller could cross any strategy's threshold (raft/bft/quorum alike) by voting under fabricated identities — a Sybil attack on consensus.”

“2 of 7 agents aborted before doing any work; 5 completed only because they ignored the brief and worked in "degraded mode" — reading source docs directly and using the shared memory namespace as a bus.”

“nextTask() would therefore hand a finished task to Claude again, which is a new billed turn.”

“When 10 of them finished simultaneously, I had 10 results to evaluate without enough context to know which ones I could trust. AI agents don’t have a speed limit, but the person managing them still does.”

“GitHub is not a coordination layer for agents. It gets incredibly overwhelming.”

“agents conflict. They step on each other’s changes. They duplicate work. They make inconsistent architectural decisions. And so the coordination overhead ends up eating up the speed gains all the while you’re burning tokens.”

“Each change can be reasonable in isolation but since it’s frictionless, none of us necessarily has to talk to the others or familiarize ourselves with the code we are changing.”

“we put a lot of work into the to smart assignments with code inbox so that we try to find the most relevant person to review the code both from a ownership and compliance perspective, but also the history of how that person was working, uh their time zone availability, their calendar availability”

“Some bugs get fixed 2 or 3 times, and someone has to pick the winner. Other fixes get lost. Designs go missing and need to be redone.”

“Sometimes you will need to go hustle the polecats to get their MRs submitted, and then hustle the Refinery to deal with them.”

“So partition by ownership before you start any agents. If you can write down who owns what up front, the branches will probably merge cleanly.”