智能体
dev.to ·
@James
并行运行 4 个编码 Agent:合并阶段才是崩溃点
作者描述并行运行 4 个编码 Agent 的实践:每个 Agent 都报告任务成功,但合并时冲突集中爆发。文章归纳三类失效模式:一是分支问题,Agent A 重构接口后 Agent B 仍按旧接口开发,各自分支干净且测试通过,合并时才暴露不兼容;二是决策问题,给某个 Agent 的决策只存在于该会话中,其他 Agent 继续按旧方案开发数小时;三是作者本人成为在程序之间传递消息的中间人。作者认为问题不在 Agent 本身,而在它们之间的协作空间。
AI推荐理由 作者基于并行运行 4 个编码 Agent 的实践,指出问题不在单个 Agent 而在它们之间的协作空间,归纳出分支冲突、决策未同步、合并时才发现集成失败三类失效模式。对多 Agent 并行开发流程有实际参考价值,但为个人经验总结,缺少量化数据。
68
正文
Each of my agents finishes its task. Every single one reports success. Then I open the merge and it is a crime scene.
One agent changed an API. Another built a whole feature against the old version. A decision I made with the third never reached the first two. And I am sitting in the middle, carrying messages between programs that were supposed to save me time.
If you run more than one coding agent at a time, you know this feeling. The agents are not the problem. The space between them is.
The three ways it breaks
The first is the branch problem. Agent A refactors an endpoint on Monday. Agent B writes a new integration against the old shape of that endpoint on Tuesday. Both branches are clean. Both pass their own tests. Together they are broken, and nobody finds out until merge day.
The second is the decision problem. I tell one agent to switch the auth approach. That decision lives in one session. The other three agents keep building on the old approach for two more hours because nobody told them. Context does not travel between sessions on its own.
The third is the handoff problem. Agent A finishes the plan and hands it to agent B for implementation, but the context that crosses the boundary is wrong or thin. Agent B starts from a slightly false picture and builds confidently in the wrong direction. I become the messenger, reading one agent's output and pasting the important parts into another agent's input. At that point I am the integration layer, which is the job I was trying to automate.
What I tried first
Worktrees, one per agent, each on its own branch. That solved the file collision part. It did not solve the coordination part. Five clean isolated sessions and one messy merge.
Naming conventions for sessions. Prefixes per worktree, per role. It helped me tell 40 sessions apart. It did not tell the agents about each other.
A shared doc with the plan that every agent was told to read. It went stale within an hour because no agent updated it when things changed. The gap between what was discussed and what was actually done just kept growing.
The pattern in all of these: isolation is a solved problem. Coordination is not.
What we are building
I run Jindo AI, and we are building Pawsly to own the space between agents. One shared plan that every agent sees. Explicit roles so the planner plans and the implementer implements. Real time context sharing so a decision made with one agent reaches the others while they are still working. A live exchange of commits between sessions so nobody builds on stale assumptions. Tracked handoffs where every handoff carries a receipt: what was handed over, what changed since, what it was based on. And a comparison layer that flags the gap between what was reported done and what actually landed.
None of this makes any single agent smarter. That was never the bottleneck. The bottleneck is that four smart agents with four private pictures of the world will confidently build four incompatible things.
We measured it
Claims are cheap, so we ran the coordination layer against real multi agent benchmarks and published everything, including the parts that do not flatter us. The full writeup is at jindoai.net/engineering.
The short version: on ten two agent coding tasks, plain shared Git produced identical work from both agents in 7 out of 10 cases. With Pawsly coordinating, it was 10 out of 10. With four agents, shared Git fell to 3 out of 10 while Pawsly held at 9 out of 10. On held decisions that an agent should respect, the unguided agent respected 0 out of 12. Guided, it respected 12 out of 12.
The honest caveats, because they matter: coordination is not correctness. Both setups passed the same 6 out of 10 tasks, so Pawsly made the agents agree, it did not make them right. It also cost about 1.5 times the agent steps. These are small internal runs, not a production guarantee. We published the limits alongside the wins because anyone building in this space should be suspicious of a benchmark chart with no caveats.
Want in early?
We are opening a small design partner program. You get early access and a direct line to me. I get your honest feedback on where it breaks, especially the ugly real world cases I have not thought of yet. That is the whole deal, no sales call, no pitch deck.
If you run two or more agents in parallel and spend part of your day keeping them in sync, I would love to talk. The site is jindoai.net, and you can reply right here in the comments and I will reach out.
What is your worst parallel agent horror story? I want to know if we have seen the same crime scenes.