5 Agent Coordination Failures and How to Fix Them
You hand Claude Code a task, walk away, and come back to a second date parser sitting next to the one you already had. Nobody asked for it. The agent simply did not know the first one existed. Cursor hit that same problem with a swarm of a thousand agents building a database in Rust, and their write-up reads like a catalog of agent coordination failures. Every one of them shows up in a single session on your laptop.
What Cursor’s swarm actually tested
The headline oversells this. It is not a story about Rust, and it is not really about SQLite. A modern Rust reimplementation already exists — Turso — and that is the one you would reach for in production. Cursor’s version, minisqlite, is not production ready, and nobody suggests you run it.
Treat it as a stress test of coordination instead. The team flattened the SQLite documentation into a spec of roughly 835 pages. Planner, worker, and reviewer agents built an implementation from that spec, and SQLite’s public query test suite graded the result. Cursor states the caveat up front: the suite checks query behavior only. It skips performance and concurrency, which is most of what a database really is.
Agent coordination failures are not intelligence problems
Hold one mental model for all of this. Almost nothing Cursor fixed came from reaching for a smarter model. They fixed things with prompting, with fresh context, with a neutral reference agent, and with shared documentation that agents read before acting. Structural fixes, not IQ fixes.
One cost comparison in the write-up makes that concrete. One configuration ran a frontier model for planners and workers alike, and a single build cost around $10,000. Another used the strong model only for planning and a cheap, fast model for the workers writing code. Same tests passed. That run cost about $1,300, roughly an eighth as much. Writing good code does not require frontier intelligence once the task is sharp. The intelligence belongs in the planning.
Two planners, one design decision
The first failure is split brain. Two planners, unaware of each other, implement the same concept two different ways in two parts of the codebase. Prompting fixed it. Cursor forced planner agents to make decisions themselves instead of delegating them downward, and forbade two delegated subtrees from deciding the same question.
The second failure is nastier. Now the planners know about each other and fight over the same files, each holding a different picture of reality. Merge tooling cannot settle that. Git merges text; it cannot pick which of two intentions was right. Their fix records decisions in a shared design doc, and a reconciler surfaces contradictions.
Your version of both fixes lives in CLAUDE.md. Keep a short map of where shared logic lives. Add one line to your planning pass: list existing modules you will reuse before proposing new ones. Then have Claude write a short design note before it writes code, and keep that note in the repo.
Commits, mega files, and permission to delete
The last three agent coordination failures cost you the most day to day. Third, workers collide on the same files, and Cursor says plainly that worker agents handle this badly. You have felt this one: you make a small manual edit, and Claude steamrolls it. An uncommitted change is nearly invisible to the agent’s intent. These models respect commits, though, and they hesitate to undo committed work. So commit before you hand off.
Fourth, certain files become popular. Cursor calls these mega files: expensive to diff, expensive to merge, and constant collision sites. Test files are the clearest case, because appending feels safe and refactoring feels scary. Put a hard line in CLAUDE.md. If a file passes 300 lines, propose a split before adding to it, and run that refactor as its own session with one job.
Fifth, agents avoid touching core code even when it should change. They add ten fallbacks rather than delete anything. That caution protects production code and stalls a greenfield project. Grant permission explicitly: nothing is in production, no external consumers exist, prefer deleting and rewriting over compatibility layers. Take that permission back the day you have real traffic.
Key Takeaways
- Cursor’s minisqlite experiment tests agent coordination, not database engineering, and its test suite ignores performance and concurrency entirely.
- Put frontier intelligence in the planner and cheap, fast models in the workers, because the same result cost roughly an eighth as much that way.
- Force the design decision to happen once, in CLAUDE.md or a design note, before any agent starts writing code.
- Commit your own edits before handing a file to Claude, because these models bulldoze uncommitted work and respect committed work.
- Cap file size and grant explicit permission to delete, since agents append forever unless you tell them not to.
Conclusion
A thousand agents and one Claude Code session break in the same places, and none of those breaks come from a model being too dumb. These agent coordination failures all yield to structure: a shared map, a decision note, a checkpoint commit, a size limit, and explicit permission. Pick the one you hit most this week and install its fix in the project you already have open.
