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

Luke Alvoeiro, who leads the core agent harness at Factory and previously created the Goose coding agent at Block (now donated to the AI Agentic AI Foundation), presents a production-tested multi-agent architecture called Missions designed to solve the core bottleneck in modern software engineering: human attention, not model intelligence. He argues that today's models are already capable of completing entire backlogs of 50+ features, but there is insufficient human bandwidth to supervise their execution.

Alvoeiro opens with a taxonomy of five frontier multi-agent strategies: delegation (parent spawns child agent), creator-verifier (separate agents for building and checking), direct communication (peer-to-peer without a coordinator, which fragments state), negotiation (agents coordinating over shared resources in potentially positive-sum ways), and broadcast (one agent sends updates to many, preserving coherence in long-running tasks). Missions combines four of these — delegation, creator-verifier, broadcast, and negotiation — into a single cohesive workflow.

The Missions architecture uses three distinct roles: the Orchestrator handles planning, strategic scoping, and generates a validation contract before any code is written. Workers handle implementation with clean context per feature — each worker reads its spec, implements, and commits via Git so the next worker inherits a clean slate. Validators handle adversarial verification through two modes: a Scrutiny Validator (tests, type checks, lint, dedicated per-feature code review agents) and a User Testing Validator that spawns the live application and interacts with it via computer use, filling forms and checking flows end-to-end. Critically, neither validator has seen the code before, making verification genuinely adversarial.

A central innovation is the validation contract, written during planning before any implementation begins. It defines correctness independently of the code, preventing the common failure mode where tests confirm implementation decisions rather than catching bugs. For complex projects, the contract can contain hundreds of assertions. After each milestone, both validator types run, and the User Testing Validator accounts for the majority of wall-clock time since it waits on real-world execution rather than token generation.

Alvoeiro makes a strong case for serial over parallel execution in software development contexts. Attempts at parallelizing multiple agents caused conflicts over code changes, duplicated work, inconsistent architectural decisions, and coordination overhead that cancelled out speed gains while burning tokens. Missions runs one worker or validator at a time, with targeted read-only parallelization within features (e.g., codebase search, API research) and within validators (e.g., per-feature code review). He reports that this approach dramatically reduces error rates and that correctness compounds over long runs — the longest mission ran 16 days, with a target of 30.

The architecture is designed to be model-agnostic, assigning the best model to each role — slow, careful reasoning models for planning; fast, creative models for implementation; precise instruction-following models for validation. Alvoeiro calls this skill 'droid whispering.' Using different model providers for validation deliberately avoids shared training data bias. The orchestration logic itself is defined in approximately 700 lines of prompts and skills rather than a hard-coded state machine, making the system improve automatically with each model generation rather than becoming obsolete.

Production data from building a Slack clone shows: 60% of time and tokens spent on implementation; validation almost never passes on the first attempt, demonstrating the QA loop's real value; final codebases end up with 50% of lines as tests and 90% test coverage; and prompt caching is used heavily to offset the cost of long-running tasks. Factory reports enterprise customers using Missions to prototype overnight, build internal tools rapidly, execute large-scale refactors and migrations, support ML research, and modernize codebases for greater agent productivity. Alvoeiro concludes that teams currently handling 10 workstreams with five engineers could scale to 30 with Missions, shifting human focus to architecture and product decisions.