The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory

Multi-agent systems structured around delegation, creator-verifier separation, broadcast communication, and negotiation can complete software engineering tas...

By Sean Weldon

Abstract

This paper examines a multi-agent system architecture that reframes the primary constraint in software engineering from model intelligence to human attention bandwidth. The Missions framework implements five coordination patterns—delegation, creator-verifier separation, broadcast communication, negotiation, and direct communication—organized into a three-role ecosystem comprising orchestrators, workers, and validators. The architecture enforces validation contract definition prior to implementation and employs serial feature execution with targeted parallelization. Production deployments demonstrate autonomous development runs extending to 16 days, with successful completion of full-stack applications containing 50% test code and 90% coverage. Enterprise implementations report productivity increases from 10 to 30 concurrent work streams, shifting engineer focus from execution to architectural decision-making. The prompt-driven design ensures continuous improvement with model advances while maintaining structural discipline through minimal hard-coded logic.

1. Introduction

Contemporary large language models possess sufficient intelligence to implement dozens of software features simultaneously, yet engineering teams remain fundamentally constrained by human attention capacity rather than model capability. While modern models can handle 50 or more features concurrently, engineers can effectively supervise only a limited number of tasks, as each commit requires human review and validation. This attention bottleneck, rather than insufficient model intelligence, represents the primary impediment to scaling software development productivity in the current technological landscape.

The Missions architecture addresses this constraint through a multi-agent system that inverts the traditional development paradigm. Instead of requiring continuous human supervision of implementation details, the system enables humans to define objectives while autonomous agents determine execution strategies. This approach shifts the bottleneck from model capability to human attention management, enabling orders of magnitude increase in task complexity compared to single-agent implementations.

This analysis synthesizes the architectural principles, coordination mechanisms, and empirical results of the Missions framework. The examination proceeds by analyzing five frontier multi-agent coordination patterns, detailing the three-role architectural design, evaluating validation strategies that ensure correctness over multi-day runs, and presenting production results from real-world deployments. The findings demonstrate how structured multi-agent systems can maintain coherence and correctness across extended autonomous development sessions while continuously improving with each model release.

2. Background and Related Work

2.1 Multi-Agent Coordination Patterns

Five distinct coordination patterns represent the current frontier in multi-agent system design. Delegation constitutes the simplest pattern wherein a primary agent spawns subordinate agents for specialized tasks, typically emerging as the first multi-agent implementation in system evolution. Creator-verifier separation employs distinct agents for implementation and verification, mitigating cost bias where a single agent defends its implementation decisions rather than objectively identifying defects. Direct communication enables peer-to-peer agent interaction without central coordination, though this approach suffers from fragmented state management and absence of a single source of truth.

Negotiation facilitates agent communication over shared resources, enabling positive-sum exchanges and win-win resource allocation scenarios. Broadcast implements one-to-many communication patterns for status updates, context distribution, and constraint propagation to maintain system coherence. The Missions architecture synthesizes delegation, creator-verifier separation, broadcast, and negotiation patterns while deliberately avoiding direct communication to preserve state consistency.

2.2 The Validation Problem in Autonomous Development

Traditional software development practices implement tests after code completion, creating a fundamental correctness problem. Tests written post-implementation confirm decisions rather than catch bugs, leading to system drift where implementations and validations evolve in tandem without independent verification. This approach proves particularly problematic for autonomous multi-day development runs where compounding errors can invalidate entire work streams. The Missions framework addresses this limitation through validation contracts—correctness definitions written during planning before any implementation begins, containing hundreds of assertions for complex projects.

3. Core Analysis

3.1 Three-Role Architectural Design

The Missions architecture implements a three-role ecosystem optimized for distinct cognitive tasks. The orchestrator role handles strategic planning, asks clarifying questions, and defines validation contracts before coding begins. This separation ensures that correctness criteria exist independently of implementation decisions. The worker role handles implementation with clean context per feature, committing changes via Git to enable clean slate inheritance for subsequent tasks. The validator role performs verification including lint checking, type checking, test execution, code review, and behavioral end-to-end testing.

Each role receives optimized model selection based on task requirements. Planning benefits from slow, careful reasoning; implementation from fast code fluency and creativity; validation from precise instruction following. Empirical evidence demonstrates that no single model nor provider excels at all three roles, necessitating deliberate model selection per role. This model-agnostic architecture enables different providers for validation to avoid training data bias, where a model might validate its own output patterns rather than assess objective correctness.

3.2 Structured Handoffs and Context Preservation

Structured handoffs between roles capture comprehensive state information including completed work, undone work, commands executed, exit codes, discovered issues, and procedure adherence. This mechanism enables context preservation across role transitions without requiring continuous state maintenance by individual agents. The orchestrator blocks progress on unresolved handoff issues through thin deterministic logic focused on bookkeeping rather than intelligence.

In production deployments, validation never succeeds on first attempt, requiring follow-up features to address discovered issues. This adversarial design proves essential for maintaining correctness over multi-day runs. The structured handoff mechanism enables the system to track which assertions remain unsatisfied and generate targeted remediation tasks rather than requiring complete reimplementation.

3.3 Serial Execution with Targeted Parallelization

Full parallelism fails for software development because agents conflict, duplicate work, and make inconsistent architectural decisions. The Missions framework implements serial feature execution with only one worker or validator active at any given time. However, read-only operations parallelize within features, including codebase search and API research during implementation, and code review during validation. The scrutiny validator spawns dedicated code review agents for each completed feature within a milestone, enabling parallel analysis without conflicting modifications.

This serial execution with targeted internal parallelization dramatically reduces error rates and compounds correctness over multi-day runs. Production deployments demonstrate successful missions extending to 16 days, with theoretical capacity for 30-day runs. The longest production missions maintain coherence through this execution model, avoiding the state fragmentation that plagues fully parallel approaches.

3.4 Validation Strategy and Adversarial Testing

The Missions framework implements two validator types optimized for different verification objectives. The scrutiny validator performs traditional testing including type checking, linting, and spawning code review agents for each feature. The user testing validator assumes a QA engineer role, using computer use capabilities to interact with live applications—filling forms, clicking buttons, and validating holistic functional behavior. Critically, neither validator sees code before validation, ensuring adversarial design by default.

The user testing validator consumes the majority of wall clock time due to real-world execution rather than token generation. In a production Slack clone implementation, 60% of time and tokens were spent on implementation, while validation required multiple iterations. The final codebase contained 50% test code with 90% coverage, demonstrating the system's emphasis on verification over rapid implementation.

4. Technical Insights

4.1 Prompt-Driven Architecture and Future-Proofing

Almost all orchestration logic resides in prompts and skills—approximately 700 lines of text—rather than hard-coded state machines. This design enables dramatic execution strategy changes through minimal prompt modifications. Four sentences of prompt changes can alter system behavior fundamentally, enabling rapid adaptation to new model capabilities or domain requirements. Worker behavior is driven by skills defined per mission, enabling customized behavior without architectural modifications.

The architecture improves with every model release rather than becoming obsolete. Models provide intelligence while the system handles discipline through structural constraints. This separation ensures that capability improvements translate directly to system performance without requiring architectural redesign. The framework demonstrates successful mission completion using non-frontier open-weight models when provided with sufficient structural support through validation contracts and milestone checkpoints.

4.2 Cost Management and Operational Efficiency

Prompt caching is leveraged extensively to offset costs of multi-day mission execution. The system maintains context through structured handoffs rather than unbounded context windows, enabling efficient cache utilization across role transitions. The mission control interface displays active worker status, handoff summaries, validator discoveries, project completion percentage, and budget burn-through, enabling asynchronous human supervision without continuous attention.

Enterprise deployments report productivity increases from 10 concurrent work streams to 30 with Missions, enabling engineers to focus on architecture and product decisions rather than execution details. Use cases include overnight prototyping, rapid internal tool building, large refactors and migrations, ML research experimentation, and codebase modernization. The system handles implementation bandwidth while humans provide strategic direction and final review.

4.3 Droid Whispering and Multi-Model Composition

Effective multi-agent system design requires droid whispering—mentally modeling how different LLMs interact, where they fail, and how failures compound over multi-day runs. This skill proves essential for selecting appropriate models per role and anticipating failure modes before they manifest in production. Different providers exhibit distinct strengths: some excel at careful reasoning for planning, others at code fluency for implementation, still others at precise instruction following for validation.

The model-agnostic architecture enables mixing providers to leverage complementary strengths while mitigating individual weaknesses. Using different providers for validation than implementation reduces training data bias, where models might validate patterns they were trained to produce rather than assessing objective correctness. This heterogeneous model composition proves essential for maintaining correctness over extended autonomous runs.

5. Discussion

The Missions architecture demonstrates that structural discipline can compensate for individual model limitations, enabling successful autonomous development with non-frontier models when provided with appropriate scaffolding. This finding has significant implications for democratizing access to autonomous development capabilities, as organizations need not wait for frontier model access to achieve productivity gains. The validation contract mechanism proves particularly valuable, as it enforces independent correctness definitions that prevent implementation and validation from drifting in tandem.

The emphasis on serial execution with targeted parallelization contradicts intuitions from traditional parallel computing, where maximizing concurrency typically improves performance. However, software development exhibits unique characteristics where architectural consistency and state coherence outweigh raw throughput. The dramatic error rate reduction from serial execution enables multi-day runs that would be impossible with fully parallel approaches, suggesting that cognitive task orchestration requires different optimization strategies than computational workloads.

The system's prompt-driven architecture raises important questions about the appropriate division between structural constraints and model intelligence. While the current implementation maintains minimal hard-coded logic, future research should investigate which architectural decisions benefit from deterministic enforcement versus flexible model-driven adaptation. The finding that four sentences of prompt changes can dramatically alter execution strategy suggests that prompt engineering for multi-agent systems represents a distinct discipline requiring systematic investigation.

6. Conclusion

This analysis demonstrates that multi-agent systems structured around delegation, creator-verifier separation, broadcast communication, and negotiation can complete software engineering tasks orders of magnitude more complex than single-agent implementations. The Missions architecture shifts the bottleneck from model intelligence to human attention management through validation contracts written before implementation, serial feature execution with targeted parallelization, and role-specific model optimization. Production deployments demonstrate successful 16-day autonomous development runs with theoretical capacity for 30-day missions, while enterprise implementations report tripling concurrent work stream capacity from 10 to 30.

The practical implications extend beyond software engineering to any domain requiring extended autonomous task completion with correctness guarantees. The architectural principles—independent validation definitions, structured handoffs, adversarial verification, and prompt-driven orchestration—provide a template for designing multi-agent systems that improve continuously with model advances while maintaining structural discipline. Future work should investigate optimal validation contract granularity, quantify the productivity-correctness tradeoffs in serial versus parallel execution strategies, and develop systematic methodologies for droid whispering across heterogeneous model compositions.

Sources

About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub