Does splitting AI agents into three roles — like planner, builder, checker — actually mirror how real software teams work?
Does this three-agent structure map onto software development workflows the same way?
This explores whether splitting multi-agent work into three separate parts maps cleanly onto how software teams already work. The question doesn't name which three parts it means, so this reads it as two likely candidates: role-based splits (such as planner, builder and checker), and the three-layer frameworks the corpus describes.
This explores whether a three-part multi-agent design maps cleanly onto how software teams already work. The question doesn't say which three parts it means, so this answer covers the two most likely readings: a split by role (planner, builder, checker) and a split into separate layers. The short answer is that software is the domain where the mapping works best. The reason is less about the number of roles and more about what software teams already have: written procedures, standard documents, and code that can be run and checked.
The clearest example is MetaGPT, which gave agents the jobs of a software company (product manager, architect, engineer). Its main finding was not the role split itself. Agents did better when they passed standardized engineering documents to each other than when they coordinated by chatting. Each agent pulled the documents it needed from a shared workspace instead of reading a stream of messages Does structured artifact sharing outperform conversational coordination?. Software development suits this approach because its handoffs (specs, designs, code, tests) are already written down. Code also helps in a second way: it can be run, inspected, and it holds state, so an agent's output doubles as something another agent can test Can code serve as the operational substrate for agent reasoning?. Most other fields have no equivalent of a test suite that a reviewer agent can run.
Role labels on their own are weaker than they look. Experiments that tagged agents as "accountable" for a deliverable found the tag made a difference only when the workflow actually sent the work through that agent. The best placement of accountability also varied by model family Does accountability placement actually shape multi-agent outcomes?. So copying a dev team's org chart does little unless the work really moves through those roles. Older and newer organization research points to a different kind of three-part split: who holds which role, how the work is coordinated, and which rules or algorithms combine the results. Each of these can be changed without rewriting the others Can multi-agent teams swap roles, coordination, and algorithms independently? Can separating structure and function improve multiagent organization design?. A related idea splits agent code itself into three layers: what the model can do on its own, the surrounding infrastructure that turns its outputs into actions (often called the harness), and the code the agent writes while it works. Each layer fails in its own way What are the three distinct layers of agent code?.
There are also reasons to doubt that the structure itself is doing the work. One analysis found that about 80% of the difference in multi-agent performance comes from how many tokens the system spends, not how cleverly the agents coordinate How does test-time scaling work at the agent level?. Teams running agents in production tend to choose single-tool agents and direct function calls because they behave predictably, and 85% build custom systems instead of using frameworks Why do protocol-based tool integrations fail in production workflows?. Anthropic's advice is to start with the simplest LLM call and use agents only when the path through a task can't be planned ahead When should teams choose workflows over agents?. Much of routine software work can be planned ahead.
The surprising part is that the best software-agent results may come from changing the human workflow rather than copying it. Agents that shared code patches and execution traces across a whole group beat agents that evolved separately by 14–20 points Does sharing experience across agents beat isolated evolution?. Human dev teams rarely share work that freely. This matches the argument that agentic AI succeeds when processes are redesigned from start to finish, not when agents are added on top of existing workflows Does agentic AI succeed through process redesign or workflow layering?.
Sources 11 notes
MetaGPT demonstrates that agents producing standardized engineering documents achieve superior coordination compared to conversational exchange. Active information pulling from shared environments eliminates noise and mirrors efficient human workplace infrastructure.
Research shows code uniquely enables agent reasoning, action, and verification by being simultaneously executable, inspectable, and stateful. This unified code-centered loop improves reasoning and verification together compared to natural-language or prose-based approaches.
Ablation studies show RACI accountability tags change outcomes only when the collaboration protocol's control flow passes the deliverable through the accountable agent. The best placement varies by model family, requiring per-model validation rather than universal design.
IMACS demonstrates that team structure (Belbin roles), coordination mechanism (Mintzberg framework), and fusion algorithm can be architecturally separated into independent components. This decoupling lets teams and protocols swap without rewriting each other, unlike existing frameworks that fuse these concerns together.
Hübner, Sichman, and Boissier's 2002 model splits organizational specification into structural (roles and groups), functional (global plans), and deontic (permissions and obligations) dimensions. This separation avoids failures where agents lack guidance or lose validated plans.
Show all 11 sources
Long-running agentic systems decompose into model-internal capabilities (trained reasoning), system-provided harness (infrastructure connecting outputs to actions), and agent-initiated artifacts (code created during execution). Each layer fails and improves differently, and this separation clarifies where to intervene.
Research shows 80% of multi-agent performance variance comes from token budget, not coordination intelligence. LatentMAS and shared-KV-cache approaches offer ways to decouple performance gains from token costs.
MCP integration caused non-deterministic failures through ambiguous tool selection and parameter inference. Replacing it with explicit direct function calls and single-tool-per-agent design restored determinism. A 306-practitioner survey confirms 85% of production teams build custom agents, forgoing frameworks.
Anthropic recommends a simplicity-first discipline: optimize single LLM calls and workflows for decomposable tasks before adopting agents, since agents trade latency and cost for flexibility only when task paths cannot be predetermined.
Group-Evolving Agents outperformed isolated tree-based self-evolution by 14–20 percentage points by explicitly pooling code patches and execution traces within each generation. Analysis showed five of eight key tool improvements came from different parent agents, proving the sharing mechanism itself—not just more search—drove the gains.
Deloitte argues many agentic AI implementations fail because organizations layer agents onto old workflows rather than redesigning operations. Success requires agent-compatible data architectures, robust orchestration, and new management models; HPE and Toyota illustrate this approach.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Worse Together: How Performance Breaks Down in Multi-User Multi-Agent Teams
- Towards a Science of Scaling Agent Systems
- Toward an Organizational Science of Multi-Agent LLM Systems: Decoupling Who, How, and Which Algorithm
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Embodied LLM Agents Learn to Cooperate in Organized Teams
- Why Do Multi-agent LLM Systems Fail?
- Code as Agent Harness
- A Practical Guide for Designing, Developing, and Deploying Production-Grade Agentic AI Workflows