Everything found so far.
As it comes in.

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

“Every one of the 50 writes returned success: true, and the DB stays integrity_check: ok. One process's entire batch was obliterated.”

“The step-based approach also made it simple to run migrations on hundreds of files concurrently”

“The cost of leaving duplicated logic is that agents will find it as prior art and replicate it further.”

“Throughput has scaled exponentially. Human review capacity hasn’t. The gap is widening.”

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

“To fix this, we created a system where a neutral third-party agent intervenes on merge conflicts and resolves them on behalf of all parties. Its only goal is to be impartial and efficient, similar to the way merge queues work in engineering teams.”

“The old run accumulated more than 70,000 conflicts before we paused it, accelerating rather than stabilizing, while the new run logged fewer than a thousand over its full four hours.”

“Two planners, unaware of each other, implement the same concept in different ways in different parts of the codebase.”

“If your engineer is able to manage five simple tasks, two manageable tasks, and one complex task at a time, your two engineer code review system now requires them to review ten simple tasks (theirs and others), four manageable tasks, and two complex tasks.”

“This is a data-durability bug in the AgentDB persistence layer: a long-running store should not be one interrupted/concurrent flush away from total loss.”

“Each PR is evaluated for its rollout risk: low, medium, high. 33% of our PRs are low-risk and are auto-approved by the bot. The author of the PR can thus choose to merge the PR, which in our case reduced PR lead time by 20-40% (when compared with all PRs).”

“when we automatically create all of the tickets, we structure it in a manner so that the tickets are made so none of them are blocking each other and if there are ones that are blocking each other, that information is flagged up and highlighted.”

“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.”

“Two agents working on two unrelated screens will still collide on the last line of that file.”

“This year, an automated dependency upgrade passed our checks, but still failed in production, impacting end users. We are responding by strengthening safeguards, expanding rollback capacity, and scheduling automated changes during owning teams’ working hours.”

“the volume of change increased faster than some of our verification controls could adapt.”

“Among some teams at OpenAI, we saw the number of landed PRs increase by 500% in the first three weeks.”

“Agents only start working on tasks that aren’t blocked, so execution unfolds naturally and optimally in parallel for this DAG (a sequence of execution steps).”

“In practice, most people could comfortably manage three to five sessions at a time before context switching became painful. Beyond that, productivity dropped.”

“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.”

“The background agent produces a PR that passes CI but is functionally incorrect. This is the most serious error, as it erodes trust in our automation. When performing changes over thousands of components, these changes are hard to spot in reviews.”

“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.”

“Another issue, specifically when running multiple agents in parallel, was that the agents were bumping into each other as they were trying to work. And more importantly, our machines couldn’t handle the load anymore.”

“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”

“Engineers are now tripling, quadrupling the number of PRs that they’re producing, but the PRs are stuck waiting for code reviews, right?”

“We don’t want thousands of loops being set up across the company without any bounds. You have a managed surface that you go to to set up the loop. So it runs on Sunday when we know we have better uh CI capacity available.”

“it’s going to stop at just creating a draft PR and it’s not going to push it to CI yet.”

“So every pull request at Anthropic is code reviewed by [Claude] code. And that actually catches maybe like 80% of bugs, something like this. And it’s the first round of kind of code review.”

“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”

“now you have your backlog in your pull requests. And that’s the bottleneck now because you can’t review all of that. And then there are going to be agents that review all that code and auto merge and auto deploy it, and what you get is the Homer Simpson car.”

“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”

“you can reuse services but you’re still going to have to branch every like database or cache or user management to have like reproducible and separate environment”

“if you have two different tasks working on the same part of the codebase, you’re going to get merge conflicts. So you need to still like plan out scope and paralyze uh the work. Um and one like one unit of work can always be one agent.”

“the act of merging um is starting to look a lot like um high-performance uh database problems where you have serialization and you have a single ledger where every single change needs to go in and you to lock the the database in order to be able to commit.”

“any sort of scenario where you want that AI agent to kind of validate what it’s done, you’re essentially talking about ephemeral environments, even if it’s not exposed to people”

“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.”

“Agents self-report "success" without mandatory verification”