最新资讯
dev.to 如何在专用 GPU 服务器上用 OpenAI 兼容 API 部署 LLM dev.to 审计 153 份 Claude Code 与 Codex 会话记录:User-Agent 与 URL 中的邮箱泄露 dev.to 你的 Agent Harness 应具备的 17 项能力 dev.to 离线 AI 记忆中 0.8 余弦阈值为何失效 dev.to Kimi K3.1 Pro 开放权重:自托管 2.8T 模型前的开发者清单 dev.to 如何通过工具调用引导模型以提升 Harness 质量 dev.to AI Agent 审计轨迹不等于对话记录 dev.to 精简 MCP server 工具数量:更少工具、更小影响面,双重收益 dev.to 为什么 git checkout 无法撤销 AI 编码 agent 的改动? wechat AI短剧门槛降降降!实测即梦短剧工作室:剧本分镜预演一条龙,伙伴计划长期护航 dev.to 让模型改写文档前,先量化事实保真度 dev.to 回放 153 个 Claude Code 与 Codex 会话,审计 Agent 的生产影响范围
多元动态
登录 注册
智能体 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.

来源报道 · 1 篇 · 以下链接均前往原始媒体

← 返回精选动态 原文

更多内容