Missions: AI Agents That Ship for Days

Luke Alvoeiro, from Factory, presented a compelling vision for the future of software engineering, arguing that human attention, not intelligence, is the primary bottleneck. His talk, "Missions: Multi-Agent Systems That Ship for Days," outlined a novel approach to leveraging AI agents for complex, long-duration tasks, fundamentally changing how software is developed.

The Bottleneck: Human Attention, Not Intelligence

Alvoeiro posited that while AI models are increasingly capable of handling complex tasks, human engineers are limited by their capacity to oversee and manage these processes. He highlighted that even the most skilled engineers can only focus on a few tasks at a time, leading to a backlog of features that cannot be progressed efficiently. This limitation, he argued, is where multi-agent systems can provide a solution.

A Taxonomy of Multi-Agent Strategies

To navigate the complex landscape of multi-agent systems, Alvoeiro introduced a five-part taxonomy:

• Delegation: One agent delegates a subtask to another, akin to a parent assigning a task. This is the simplest form, often seen in coding tools where one agent might be tasked with database schema generation.
• Creator-Verifier: One agent creates and another verifies the output. This separation of concerns is crucial, as the verifier can identify issues that the creator might overlook due to inherent biases.
• Direct Communication: Agents communicate peer-to-peer without a central coordinator. While efficient for simple interactions, it can lead to fragmented state and a lack of a single source of truth.
• Negotiation: Agents coordinate over shared resources, aiming for a win-win scenario. This is best suited for situations where agents might compete for or collaborate on shared assets.
• Broadcast: One agent shares status updates or context with many others, critical for maintaining alignment and coherence across a team of agents.

Introducing Missions: Orchestrating Agent Workflows

Alvoeiro then introduced "Missions," a system that integrates four of these strategies, delegation, creator-verifier, broadcast, and negotiation, into a single, cohesive workflow. The process involves describing a goal, scoping it through conversation, approving a plan, and then letting the system handle the execution, freeing up human engineers to focus on higher-level tasks.

A mission is not a single agent session but an ecosystem of agents coordinating through structured handoffs and shared state. The system employs a three-role architecture:

• The Orchestrator: Plans features, milestones, and the validation contract. It acts as a sounding board, asking clarifying questions and ensuring all requirements are met before implementation begins.
• Workers: Implement features, handle the code, commit via Git, and hand off their work. They operate with fresh context, avoiding accumulated baggage and ensuring focused execution.
• Validators: Perform verification. This includes traditional methods like linting and type-checking, but crucially, it also involves validating behavior end-to-end. The key insight here is that validation is adversarial by design, with separate agents ensuring correctness without being influenced by the implementation bias.

Alvoeiro emphasized that "tests written after implementation don’t catch bugs. They confirm decisions." The Missions system, therefore, relies on a validation contract written during planning, defining correctness independently of implementation, ensuring that tasks are completed according to predefined assertions.

Serial Execution for Robustness

In contrast to parallel execution, which can lead to conflicts and duplicated work among agents, Missions employs serial execution for features. This means only one worker or validator operates on a feature at a time, inheriting the full codebase from the last commit. While seemingly slower on paper, this approach drastically reduces error rates, as correctness compounds over multi-day runs. The system also features internal parallelism for read-only operations like code searching and API research.

Mission Control: A Dedicated Interface

To manage these long-running, asynchronous missions, Factory has developed "Mission Control." This interface provides a dedicated view to monitor active workers, read handoff summaries, and understand the progress of tasks. It allows engineers to stay informed without constant direct oversight, enabling them to step away and return to a codebase that is cleaner and more advanced than when they left it.

The Power of Specialization and Adaptability

Alvoeiro stressed the importance of using the right model for each role within the mission architecture. Planning might benefit from models with slow, careful reasoning, while implementation requires code fluency and creativity. Validation, on the other hand, demands strict instruction following. The model-agnostic architecture allows for compounding advantages as models specialize, ensuring that the system remains adaptable and improves with each new model release without requiring code changes.

Ultimately, Alvoeiro concluded that by leveraging this structured approach to multi-agent systems, teams can significantly increase their productivity, tackling problems that are orders of magnitude more complex and leaving their codebase in a better state than when they started.