Multi-Agent Patterns: Role-Based Teams

Introduction

In unstructured multi-agent setups, open chat transcripts grow exponentially, causing conversational drift and token waste. Additionally, without structured coordination, agents frequently rewrite code fragments out of order, overriding valid logic. The Role-Based Teams pattern addresses these limitations by mapping human organizational workflows directly to agent collectives. By dividing complex software engineering and content-creation tasks into distinct personas, and structuring communication via intermediate documents (artifacts), this pattern introduces strict process discipline to multi-agent environments.

Standard Operating Procedures and Artifacts

Unlike conversational multi-agent systems, Role-Based Teams rely on two core design components:

• Distinct Personas: Spawning agents with restricted role prompts (e.g., Product Manager, Architect, Coder, Reviewer). Persona scoping keeps each instance's system prompt small and focused.
• Artifact-Mediated Communication: Instead of raw, open-ended chat transcripts, agents exchange structured, read/write files (e.g., Product Requirement Documents - PRDs, System Designs, Source Files, Test Reports). The medium of coordination is also the final deliverable.
• Standard Operating Procedures (SOPs): Predefined execution pipelines (graphs or state machines) that determine which role is allowed to edit or review an artifact and at what time.

Reducing Error Propagation

In classical conversational multi-agent systems, if one agent introduces an error, other agents chat about it and copy the erroneous output into their own prompts, reinforcing the failure. In Role-Based Teams, communication is mediated by artifacts. Personas read from a common workspace directory or document set. The Coder agent reads the API specifications and the PM's PRD, writes code, and outputs a code file. The Tester agent executes unit tests against the code and outputs a test report. The Coder only looks at the test report to make edits, preventing conversational drift from inflating context windows.

Trade-offs

Mirroring human teams brings standard discipline, but carries specific engineering trade-offs:

Known Uses

This pattern is widely used in code-generation and organizational simulations:

• MetaGPT: Spawns distinct agents mapped to product managers, architects, code developers, and QA engineers, communicating via software-design documents [1].
• ChatDev: An interactive virtual software developer company model where multiple role-playing agents collaborate in a sequential pipeline to develop apps [2].
• CAMEL Framework: Explores communicative agent societies using role-playing prompts to solve specific tasks through structured consensus [3].

References

• [1]
  Hong, S., Zheng, M., Chen, J., Wang, Y., Wang, C., Zhao, C., ... & Zhou, H. (2024). MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework. International Conference on Learning Representations (ICLR).
  https://arxiv.org/abs/2308.08155
• [2]
  Qian, C., Cong, X., Yang, C., Chen, W., Su, Y., Xu, J., ... & Sun, M. (2024). ChatDev: Communicative Agents for Software Development. Proc. 62nd Annu. Meeting Assoc. Comput. Linguistics (ACL).
  https://arxiv.org/abs/2307.07924
• [3]
  Li, G., Hammoud, H. I., Itani, D., Khizbullin, D., & Ghanem, B. (2023). CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society. Advances in Neural Information Processing Systems (NeurIPS).
  https://arxiv.org/abs/2303.17760