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

Luke Alvoeiro

AI Engineer Europe 2026

[Talk page](https://ai.engineer/talks/ow1we5PzK-o-production-multi-agent-architecture) · [Video](https://www.youtube.com/watch?v=ow1we5PzK-o)

## The Multi-Agent Architecture That Actually Ships

Luke Alvoeiro explains how Factory’s Missions combines upfront validation contracts, specialized agent roles, structured handoffs, and carefully limited parallelism to execute software projects over hours or days.

![Selected presentation frame from The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory at 287 seconds](https://ai.engineer/api/talk-essay-media/672870626230aeca34aeeb2af01eaa1fe415adb6a761bbe50619e9b6c04cb115)

The Multi-Agent Architecture That Actually Ships

### The real bottleneck is human attention

[0:15](https://www.youtube.com/watch?v=ow1we5PzK-o&t=15s)

Luke Alvoeiro frames modern software development as a problem of **human attention**, not simply model intelligence. Engineers may face dozens of potential features but can advance only a handful because implementation, supervision, and review all compete for their time. The architectural question is whether a person can specify what should be built while an agent system determines how to execute it over extended periods. [0:15](https://www.youtube.com/watch?v=ow1we5PzK-o&t=15s) [1:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=77s)

To organize the fragmented landscape of multi-agent systems, Alvoeiro identifies five interaction patterns. **Delegation** lets one agent assign work to another; **creator-verifier** separates implementation from independent review; **direct communication** enables agent-to-agent exchanges without a central coordinator; **negotiation** coordinates access to shared resources; and **broadcast** distributes information or constraints across a group. Each pattern addresses a different coordination problem. [1:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=77s) [2:22](https://www.youtube.com/watch?v=ow1we5PzK-o&t=142s) [3:23](https://www.youtube.com/watch?v=ow1we5PzK-o&t=203s)

These patterns carry different tradeoffs. Direct communication can fragment state when no coordinator maintains a single source of truth, while negotiation can produce mutually beneficial coordination rather than adversarial competition. Factory’s **Missions** combines delegation, creator-verifier, negotiation, and broadcast into a workflow in which a person discusses scope, approves a plan, and then allows the system to handle extended execution. [2:22](https://www.youtube.com/watch?v=ow1we5PzK-o&t=142s) [3:23](https://www.youtube.com/watch?v=ow1we5PzK-o&t=203s)

![Selected presentation frame from The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory at 108 seconds](https://ai.engineer/api/talk-essay-media/3d6cc6c304138c65a8266f482646b5fba661ede84732500a1dabf5a5e5f40097)

The real bottleneck is human attention

- Human attention limits software delivery because implementation supervision and commit review compete across tasks.
- Five coordination patterns address distinct needs: delegation, creator-verifier, direct communication, negotiation, and broadcast.
- Direct communication can fragment shared state, while broadcast distributes updates and constraints across agents.
- Missions combines delegation, creator-verifier, negotiation, and broadcast after a human scopes and approves the plan.

### Three roles turn an assignment into a managed mission

[2:22](https://www.youtube.com/watch?v=ow1we5PzK-o&t=142s)

A mission is not one uninterrupted agent conversation. It is an **ecosystem of agents** linked by shared state and structured handoffs, with three distinct roles: orchestrator, worker, and validator. The **orchestrator** clarifies requirements, asks strategic questions, and produces a plan containing features, milestones, and a validation contract that establishes what completion means before implementation begins. [4:27](https://www.youtube.com/watch?v=ow1we5PzK-o&t=267s)

**Workers** implement individual features with clean context rather than carrying the accumulated history and degraded attention of a single prolonged session. Each worker reads its specification, makes the required changes, and commits through Git, allowing the next worker to begin from a working codebase without inheriting the previous agent’s full conversational baggage. [4:27](https://www.youtube.com/watch?v=ow1we5PzK-o&t=267s)

**Validators** remain separate from the agents that created the implementation. Beyond conventional linting, type checking, testing, and code review, they examine whether the software actually works end to end. This separation is designed to reduce the bias of an implementation agent evaluating its own decisions and to prevent a long-running mission from drifting away from its intended behavior. [2:22](https://www.youtube.com/watch?v=ow1we5PzK-o&t=142s) [5:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=334s)

![Selected presentation frame from The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory at 271 seconds](https://ai.engineer/api/talk-essay-media/8ad6d0925bcdf1ef24244752f7020471e3c67216c0c468b6d3d41e944e02cf46)

Three roles turn an assignment into a managed mission

- Orchestrators clarify requirements and define features, milestones, and a validation contract before coding begins.
- Workers implement assigned specifications with clean context and commit through Git for subsequent workers.
- Independent validators combine conventional checks with end-to-end behavioral verification.
- Separating implementation from verification reduces sunk-cost bias and preserves independent review.

Three-role mission execution
Planning establishes correctness before implementation and independent verification.
- Orchestrator — Clarifies requirements and creates the mission plan.
- Validation contract — Defines completion before coding begins.
- Worker — Implements features with clean context and Git commits.
- Validator — Checks code quality and end-to-end behavior.
- Orchestrator → Validation contract (defines)
- Validation contract → Worker (precedes implementation)
- Worker → Validator (implementation then verification)

### Define correctness before writing code

[5:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=334s)

The central safeguard is the **validation contract**, written during planning before any implementation exists. Alvoeiro argues that tests written after code can mirror the choices already embedded in that implementation instead of independently checking its intended purpose. By specifying correctness first, the mission gives later validators a standard that does not originate from the code they are evaluating. [5:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=334s)

A complex project may require hundreds of assertions, with every feature assigned one or more assertions and the complete feature set collectively covering the contract. At each milestone, a **scrutiny validator** runs the test suite, type checks, linting, and dedicated code-review agents for completed features. A separate **user testing validator** launches the application and exercises practical flows by interacting with forms, rendered pages, buttons, and other application behavior. [6:42](https://www.youtube.com/watch?v=ow1we5PzK-o&t=402s)

Behavioral validation has a significant cost: interacting with a live application takes longer than conventional scrutiny, and Alvoeiro reports that much of a mission’s wall-clock time can be spent waiting for real-world execution rather than generating tokens. The benefit is independent, adversarial verification by agents that have not previously seen the implementation and are not invested in defending it. [7:38](https://www.youtube.com/watch?v=ow1we5PzK-o&t=458s)

When work fails validation, the system relies on **structured handoffs** rather than agent memory. Workers record completed and unfinished work, executed commands and their exit codes, discovered issues, and compliance with orchestrator-defined procedures. Milestone boundaries then become opportunities to identify errors, scope corrective features, and return execution to the original plan. [7:38](https://www.youtube.com/watch?v=ow1we5PzK-o&t=458s) [8:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=523s)

![Selected presentation frame from The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory at 420 seconds](https://ai.engineer/api/talk-essay-media/0c5ca97d87e2314fdca9793af7166658e2ba959546621b070702e3bd1f912ea9)

Define correctness before writing code

- Validation contracts define correctness before implementation and assign assertions across all planned features.
- Scrutiny validators run tests, type checks, lint, and dedicated code reviews; user testing validators exercise live application flows.
- Live behavioral validation is slower than scrutiny and can dominate mission wall-clock time.
- Structured handoffs record completed work, outstanding issues, commands, exit codes, and procedural compliance to support corrective work.

Milestone validation and correction loop
Independent milestone checks expose issues, scope corrective work, and restore alignment with the mission.
- Feature implementation — Work progresses toward milestone assertions.
- Structured handoff — Records outcomes, commands, exit codes, and issues.
- Milestone validation — Scrutiny and live user testing inspect completed work.
- Corrective work — Detected issues become scoped follow-up work.
- Feature implementation → Structured handoff (worker records results)
- Structured handoff → Milestone validation (documented issues reviewed at milestones)
- Milestone validation → Corrective work (caught errors are scoped)
- Corrective work → Feature implementation (corrective work restores progress)

### Serialize code changes and parallelize safe research

[8:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=523s)

Alvoeiro challenges the assumption that adding more simultaneously active agents automatically increases software-delivery throughput. Factory found that concurrent implementation agents could overwrite or conflict with one another’s changes, duplicate work, and make incompatible architectural decisions. In that setting, coordination overhead consumed the expected speed gains while also increasing token expenditure. [8:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=523s)

Missions therefore executes features **serially**, with only one worker or validator active at a time. Parallelism is reserved for **read-only operations** inside a feature or validation step, such as searching a codebase, researching APIs, or conducting independent code reviews. Although this can appear slower in a simplified throughput calculation, Alvoeiro argues that fewer errors compound into an advantage across tasks lasting many days. [9:50](https://www.youtube.com/watch?v=ow1we5PzK-o&t=590s)

Because extended autonomous execution cannot be understood effectively through a conventional chat transcript alone, Factory built **Mission Control** as a dedicated operational view. It exposes project progress, budget consumption, the currently active worker, and handoff summaries describing discoveries and course corrections. The interface supports both active oversight and asynchronous supervision without requiring a human to monitor every implementation step. [9:50](https://www.youtube.com/watch?v=ow1we5PzK-o&t=590s) [10:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=645s)

The architecture has demonstrated extended duration, but its boundaries remain explicit. Alvoeiro says Factory’s longest mission ran for **16 days** and expresses a belief that missions could reach 30 days; the latter is presented as an expectation, not an observed result. He also identifies greater workload parallelization and orchestration across multiple missions as unresolved questions. [8:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=523s) [16:49](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1009s)

![Selected presentation frame from The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory at 604 seconds](https://ai.engineer/api/talk-essay-media/da84d66b5e9758e5fe3fbc9b95d149da5bbedff9de4ea014d93351205ee875e4)

Serialize code changes and parallelize safe research

- Concurrent implementation agents can conflict, duplicate work, and make inconsistent architectural decisions.
- Missions runs one worker or validator at a time while parallelizing read-only code search, API research, and code review.
- Mission Control tracks project progress, budget consumption, active work, and handoff summaries for asynchronous oversight.
- The longest reported mission ran 16 days; 30-day missions remain an expectation, and broader parallelization remains unresolved.

### Match models to roles and keep orchestration adaptable

[10:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=645s)

The three roles impose different demands on underlying models. Planning benefits from careful reasoning, implementation from fast coding fluency and creativity, and validation from precise instruction following. Alvoeiro describes the emerging operational skill of choosing among these capabilities as **Droid whispering**: understanding how different models behave, where they fail, and how those failures interact across a multi-day workflow. [10:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=645s) [11:42](https://www.youtube.com/watch?v=ow1we5PzK-o&t=702s)

A **model-agnostic architecture** allows different models or providers to occupy different roles, including using a separate provider for validation to reduce the risk of shared biases. Conversely, validation contracts and milestone checkpoints can compensate for less capable individual models, which Alvoeiro says allows missions to run successfully even with open weight models. His argument is not that any model works equally well, but that system structure and deliberate role assignment can improve reliability. [11:42](https://www.youtube.com/watch?v=ow1we5PzK-o&t=702s) [12:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=765s)

In an example involving a Slack clone, Alvoeiro reports that implementation accounted for **60% of time and 60% of tokens**, validation did not succeed on the first attempt, and follow-up features were needed. He also describes a final codebase in which approximately **50% of lines were tests** and **90% of code was covered by those tests**, with prompt caching used to mitigate the cost of long-running execution. These figures describe the presented example rather than a guaranteed outcome for every mission. [12:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=765s)

To avoid making the architecture obsolete when models improve, Factory places most orchestration behavior in **prompts and skills** rather than a rigid hard-coded state machine. Alvoeiro describes roughly 700 lines of text governing feature decomposition and failure handling, mission-specific worker skills, and a thin deterministic layer responsible for bookkeeping, validation, and blocking progress when handoff issues remain unresolved. The intended division is straightforward: the system supplies operational discipline while models supply adaptable intelligence. [14:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=874s) [15:04](https://www.youtube.com/watch?v=ow1we5PzK-o&t=904s) Returning to the opening human-attention bottleneck, Alvoeiro argues that Missions lets teams focus on architecture and product decisions while the system manages execution. He also says the accumulated end-to-end tests, unit tests, skills, and structure leave the codebase cleaner than it began, making both humans and agents more productive in subsequent work. [15:51](https://www.youtube.com/watch?v=ow1we5PzK-o&t=951s) [16:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=977s)

![Selected presentation frame from The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory at 859 seconds](https://ai.engineer/api/talk-essay-media/f74ef81ae27c6aa5ee17232328d58c5de27246bc281c25f9bc57fefedd084784)

Match models to roles and keep orchestration adaptable

- Assign models by role: careful reasoning for planning, coding fluency and creativity for implementation, and precise instruction following for validation.
- Model-agnostic orchestration supports different validation providers, while contracts and checkpoints can improve outcomes with open weight models.
- In the Slack-clone example, implementation consumed 60% of time and tokens; tests represented 50% of code and covered 90% of the codebase.
- Prompts and mission-specific skills govern orchestration, while a thin deterministic layer handles bookkeeping, validation, and unresolved handoff blockers.

## Key takeaways

- Treat **human attention** as the limiting resource: let people set goals and approve scope while a structured agent system manages extended execution. [0:15](https://www.youtube.com/watch?v=ow1we5PzK-o&t=15s) [1:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=77s) [3:23](https://www.youtube.com/watch?v=ow1we5PzK-o&t=203s)
- Separate **orchestration, implementation, and validation** so planning, coding, and independent review do not share the same responsibilities or implementation bias. [4:27](https://www.youtube.com/watch?v=ow1we5PzK-o&t=267s) [5:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=334s)
- Write a **validation contract before coding**, then combine conventional scrutiny with live end-to-end user testing at milestone boundaries. [5:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=334s) [6:42](https://www.youtube.com/watch?v=ow1we5PzK-o&t=402s) [7:38](https://www.youtube.com/watch?v=ow1we5PzK-o&t=458s)
- Use **structured handoffs** to preserve completed work, unfinished tasks, command results, discovered issues, and procedural compliance across agents. [7:38](https://www.youtube.com/watch?v=ow1we5PzK-o&t=458s) [8:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=523s)
- Keep code-changing execution **serial**, reserving parallelism for read-only research and review to reduce conflicts and coordination overhead. [8:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=523s) [9:50](https://www.youtube.com/watch?v=ow1we5PzK-o&t=590s)
- Assign models according to role-specific strengths and keep orchestration in adaptable **prompts and skills**, with deterministic code enforcing essential operational safeguards. [10:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=645s) [11:42](https://www.youtube.com/watch?v=ow1we5PzK-o&t=702s) [14:00](https://www.youtube.com/watch?v=ow1we5PzK-o&t=840s) [15:04](https://www.youtube.com/watch?v=ow1we5PzK-o&t=904s)

## Slides

### Assembling agent teams

Luke Alvoeiro aims to show how to assemble agent teams for harder tasks. His title slide puts the gap at 15x compared with a single agent.

[0:21](https://www.youtube.com/watch?v=ow1we5PzK-o&t=21s) [Speaker beside a slide stating that agent teams can solve problems 15x harder than single agents can, attributed to Luke Alvoeiro of Factory.](https://assets.ai.engineer/sites/aiecode2025/sha256/8b463d57fe32a49246f1ccba27fefa39a3007d22c43b7818bb7197098a640787.webp)

Assembling agent teams that solve problems 15x harder than single agents can

Luke Alvoeiro - Factory

Interface text:
AI Engineer EUROPE
Google DeepMind

### Assembling agent teams

Luke Alvoeiro sets out to show how agent teams can solve problems 15x harder than single agents can. He leads Factory’s core agent harness.

[0:41](https://www.youtube.com/watch?v=ow1we5PzK-o&t=41s) [Title slide: Assembling agent teams that solve problems 15x harder than single agents can.](https://assets.ai.engineer/sites/aiecode2025/sha256/bd64ddb7009b87f20f67785dfae66f94fb7a1b48cedf7907be2d45b7e6bea262.webp)

Assembling agent teams that solve problems 15x harder than single agents can

Luke Alvoeiro - Factory

AI Engineer EUROPE
PRESENTED BY
Google DeepMind

AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### The bottleneck is no longer intelligence

Alvoeiro argues that engineers lack the bandwidth to supervise every task, even as models become capable of tackling their backlog. He proposes letting humans decide what to build while a system works out how.

[1:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=94s) [A bottleneck diagram and text about limited engineering attention, followed by a question about humans deciding what to build and the system determining how.](https://assets.ai.engineer/sites/aiecode2025/sha256/d998d6be14f3fb9b80915ec505e3da1faea580089c120cbb73be074942116fcc.webp)

AGENT TEAMS
The bottleneck is no longer intelligence

The best engineers can only focus on a couple things at a time. They have a backlog of 50 features but can only drive a few forward per day. Today's models are smart enough to build all 50.

What if the human decides what to build, and the system figures out how?

AI Engineer - Factory
2026
1

Interface text:
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### Five multi-agent strategies

Direct communication connects agents peer-to-peer without a coordinator, risking fragmented state. Broadcast sends shared updates from one agent to many to maintain coherence.

[1:48](https://www.youtube.com/watch?v=ow1we5PzK-o&t=108s) [Five cards describe delegation, creator-verifier, direct communication, negotiation, and broadcast.](https://assets.ai.engineer/sites/aiecode2025/sha256/1248fbd14784a10e7fd2f4aa4a574f7d5daad344527da26e91140110c6c66c65.webp)

AGENT TEAMS
Five multi-agent strategies

Delegation
One agent spawns another for a subtask. The simplest multi-agent pattern.

Creator-Verifier
One agent builds, a different agent checks. Separation of concerns removes sunk-cost bias.

Direct Communication
Agents talking peer-to-peer without a coordinator. Hard to get right: state fragments.

Negotiation
Two agents coordinate over shared resources. Best when there's a possible win-win.

Broadcast
One agent sends status updates and shared context to many. Critical for coherence.

AI Engineer - Factory
2026
2

Interface text:
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

[1:54](https://www.youtube.com/watch?v=ow1we5PzK-o&t=114s) [Slide describing delegation, creator-verifier, direct communication, negotiation, and broadcast.](https://assets.ai.engineer/sites/aiecode2025/sha256/3021f9b161f7d3fbefb458edcc2d53657dd010725a7315f1ba70397c3605fa93.webp)

AGENT TEAMS
Five multi-agent strategies

Delegation
One agent spawns another for a subtask. The simplest multi-agent pattern.

Creator-Verifier
One agent builds, a different agent checks. Separation of concerns removes sunk-cost bias.

Direct Communication
Agents talking peer-to-peer without a coordinator. Hard to get right: state fragments.

Negotiation
Two agents coordinate over shared resources. Best when there's a possible win-win.

Broadcast
One agent sends status updates and shared context to many. Critical for coherence.

AI Engineer - Factory
2026
2

Interface text:
AI Engineer EUROPE
Engineering the future of AI

### Five multi-agent strategies

Agents delegate tasks, separate building from checking, negotiate shared resources, or broadcast context. Direct peer communication skips a coordinator but can fragment state.

[2:07](https://www.youtube.com/watch?v=ow1we5PzK-o&t=127s) [Five cards explain delegation, creator-verifier, direct communication, negotiation, and broadcast.](https://assets.ai.engineer/sites/aiecode2025/sha256/13b989dac0781ad2ec23f29ea698cd56e016482ba66a252fe758cf46de1bc1e7.webp)

Five multi-agent strategies

AGENT TEAMS

Delegation
One agent spawns another for a subtask. The simplest multi-agent pattern.

Creator-Verifier
One agent builds, a different agent checks. Separation of concerns removes sunk-cost bias.

Direct Communication
Agents talking peer-to-peer without a coordinator. Hard to get right: state fragments.

Negotiation
Two agents coordinate over shared resources. Best when there's a possible win-win.

Broadcast
One agent sends status updates and shared context to many. Critical for coherence.

AI Engineer - Factory
2026
2

### Introducing Missions

After a user describes a software goal, scopes it through conversation, and approves a plan, Missions coordinates agents through structured handoffs and shared state to execute over hours or days.

[4:14](https://www.youtube.com/watch?v=ow1we5PzK-o&t=254s) [A four-step Missions workflow leads from describing a software goal to execution; agents coordinate through structured handoffs and shared state.](https://assets.ai.engineer/sites/aiecode2025/sha256/35d63aaf2e64843f27f46c2c47103ba0601c438b98ee28322317a46a60922bc3.webp)

INTRODUCING MISSIONS

Missions – a system that combines delegation, creator-verifier, broadcast, and negotiation into a single workflow

HOW TO USE THEM
1. Describe a software goal.
2. Scope it through conversation.
3. Approve the plan
4. Missions handles execution

A mission is not a single agent session that runs for a long time. It's an ecosystem of agents coordinating through structured handoffs and shared state.

AI Engineer - Factory
2026
3

Interface text:
AI Engineer EUROPE
Google DeepMind

[4:27](https://www.youtube.com/watch?v=ow1we5PzK-o&t=267s) [Missions combines agent coordination patterns into a workflow from describing a goal through execution.](https://assets.ai.engineer/sites/aiecode2025/sha256/41e9172b996650b9129afbb8aa9b06873a2bb5673cc96b3ea8ba789249f7ce01.webp)

INTRODUCING MISSIONS

Missions – a system that combines delegation, creator-verifier, broadcast, and negotiation into a single workflow

HOW TO USE THEM
1. Describe a software goal.
2. Scope it through conversation.
3. Approve the plan
4. Missions handles execution

A mission is not a single agent session that runs for a long time. It's an ecosystem of agents coordinating through structured handoffs and shared state.

AI Engineer - Factory
2026
3

Interface text:
AI Engineer EUROPE
Google DeepMind

### The validation loop

Before coding, the orchestrator defines correctness in a validation contract. After each milestone, one validator checks code and tests while another exercises the live app; neither has seen the code before.

[6:56](https://www.youtube.com/watch?v=ow1we5PzK-o&t=416s) [A planning-stage validation contract is followed by scrutiny and user-testing validators after each milestone.](https://assets.ai.engineer/sites/aiecode2025/sha256/8589eeb5a54e832a811606fb762e6dd239232f61a21dbd20536914695c9efefc.webp)

HOW THEY WORK
The validation loop
Tests written after implementation don't catch bugs. They confirm decisions.

PLANNING PHASE
Validation Contract
Written by orchestrator during planning, before any code. Hundreds of assertions define correctness independently of implementation.

After each milestone...

</>
Scrutiny Validator
Runs tests, typechecking, linting. Spawns code review agents for each completed feature.

</>
User-Testing Validator
Acts like a QA engineer. Launches the app, navigates via computer-use & verifies flows end-to-end.

Neither validator has ever seen the code. Validation is adversarial by design.

AI Engineer - Factory
2026
5

### Structured handoffs

When a worker finishes a feature, it records what happened in a structured handoff. The system uses these reports to preserve context across agents and scope corrective work at milestone boundaries.

[8:07](https://www.youtube.com/watch?v=ow1we5PzK-o&t=487s) [Workers report completed and unfinished work, commands and exit codes, issues, and whether procedures were followed, alongside a continuous learning loop.](https://assets.ai.engineer/sites/aiecode2025/sha256/4e37f43844348cc63c404b69d9ef47f68c558ee4ddbc4950d2f96f135003bcf0.webp)

HOW THEY WORK
Structured handoffs
How agents stay coherent over days, not just minutes.

Every worker reports
• What was implemented
• What was left undone
• Commands run + exit codes
• Issues discovered
• Whether procedures were followed

New Task
Execute
Observe
Learn
CONTINUOUS LEARNING

AI Engineer - Factory
2026
6

[8:54](https://www.youtube.com/watch?v=ow1we5PzK-o&t=534s) [Handoff reports list completed and unfinished work, commands and exit codes, issues, and procedure compliance, alongside a continuous learning cycle.](https://assets.ai.engineer/sites/aiecode2025/sha256/8220bc2ad46ac0d8551624dbd6096640d2da369e797a61a6a4dca3cde58927c2.webp)

HOW THEY WORK
Structured handoffs
How agents stay coherent over days, not just minutes.

Every worker reports
• What was implemented
• What was left undone
• Commands run + exit codes
• Issues discovered
• Whether procedures were followed

New Task
Execute
Observe
Learn
Encode Skill
CONTINUOUS LEARNING

AI Engineer - Factory
2026
6

Interface text:
AI Engineer EUROPE
together.ai
Engineering the future of AI

### Why serial beats parallel (mostly)

Factory runs Mission features serially, with one worker or validator at a time. In software development, parallel agents conflicted and duplicated work, while coordination costs ate into speed gains.

[9:14](https://www.youtube.com/watch?v=ow1we5PzK-o&t=554s) [Title slide introducing how the system should execute work.](https://assets.ai.engineer/sites/aiecode2025/sha256/6bca227dc9872e8db2d5e9edc79ddbc9fad02b25160c0a0b33fe908e4d6126d8.webp)

Why serial beats parallel (mostly)
HOW THEY WORK
The next question, how should this execute...

AI Engineer - Factory
2026
7

Interface text:
AI Engineer EUROPE
OpenAI
SENTRY
PRESENTED BY
Google DeepMind

### Why serial beats parallel (mostly)

Factory found that parallel software agents can step on each other’s changes, duplicate work and make inconsistent architecture decisions. Coordination overhead eats into speed gains, and conflicts burn tokens.

[9:23](https://www.youtube.com/watch?v=ow1we5PzK-o&t=563s) [Parallelism can cause agent conflicts, duplicate work, inconsistent architecture, coordination overhead, and token consumption.](https://assets.ai.engineer/sites/aiecode2025/sha256/c574bdb2fdd1c46d7dc65c1cc56b3ac23f36c9fefb71eda1eac95ff76f5c16b7.webp)

HOW THEY WORK
Why serial beats parallel (mostly)
The next question, how should this execute...

WHAT PEOPLE EXPECT
Parallelism
• Agents conflict and step on each other
• Duplicate work and inconsistent architecture
• Coordination overhead eats speed gains
• Every conflict burns tokens

AI Engineer - Factory
2026
7

Interface text:
AI Engineer EUROPE
PRESENTED BY
Google DeepMind

### Why serial beats parallel (mostly)

Factory runs features serially after parallel agents conflicted, duplicated work and lost speed to coordination. Read-only code search, API research and reviews can still run in parallel.

[9:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=574s) [The parallelism drawbacks card returns, listing conflicts, duplicate work, coordination overhead, and token consumption.](https://assets.ai.engineer/sites/aiecode2025/sha256/990d6a5b17aaec72f1a576746febf9cc9407e71548bb5753960fbf786073f38f.webp)

HOW THEY WORK
Why serial beats parallel (mostly)
The next question, how should this execute...

WHAT PEOPLE EXPECT
Parallelism
• Agents conflict and step on each other
• Duplicate work and inconsistent architecture
• Coordination overhead eats speed gains
• Every conflict burns tokens

AI Engineer - Factory
2026
7

Other visible text:
AI Engineer EUROPE
OpenAI
SENTRY
DeepMind
Braintrust
WorkOS

### Why serial beats parallel (mostly)

Missions runs one feature at a time, passing the codebase through git. It parallelizes read-only research and reviews to avoid conflicting changes.

[9:54](https://www.youtube.com/watch?v=ow1we5PzK-o&t=594s) [A comparison of parallelism drawbacks with serial feature execution and parallel exploration, research, documentation, and reviews.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb902da82df14f1b20bae6ff5782dbe337b48171e0190356635754a4b8281187.webp)

Why serial beats parallel (mostly)
HOW THEY WORK
The next question, how should this execute...

WHAT PEOPLE EXPECT
Parallelism
• Agents conflict and step on each other
• Duplicate work and inconsistent architecture
• Coordination overhead eats speed gains
• Every conflict burns tokens

WHAT ACTUALLY WORKS
Serial Execution
Features execute one at a time. Each worker inherits the full codebase from the last through git

Parallelism is reserved for work that can't conflict: codebase exploration, API research, documentation reads, and validation reviews.

Slower on paper. But for multi-day runs, correctness compounds.

AI Engineer - Factory
2026
7

Interface text:
AI Engineer EUROPE
OpenAI
SENTRY
DeepMind
Engineering the future of AI

[10:05](https://www.youtube.com/watch?v=ow1we5PzK-o&t=605s) [Two panels contrast conflicts in parallel work with serial execution and targeted parallel research.](https://assets.ai.engineer/sites/aiecode2025/sha256/990fece7b91a627f891d5442b12f52af2c4c4b525a635613cde66d9827a81d08.webp)

Why serial beats parallel (mostly)
HOW THEY WORK
The next question, how should this execute...

WHAT PEOPLE EXPECT
Parallelism
• Agents conflict and step on each other
• Duplicate work and inconsistent architecture
• Coordination overhead eats speed gains
• Every conflict burns tokens

WHAT ACTUALLY WORKS
Serial Execution
Features execute one at a time. Each worker inherits the full codebase from the last through git

Parallelism is reserved for work that can't conflict: codebase exploration, API research, documentation reads, and validation reviews.

Slower on paper. But for multi-day runs, correctness compounds.

AI Engineer - Factory
2026
7

### Mission Control overview

Mission Control brings the active feature, progress log, and worker output together so a project manager can monitor a multi-day mission at a glance.

[10:26](https://www.youtube.com/watch?v=ow1we5PzK-o&t=626s) [Mission Control shows an active feature, progress log and worker.](https://assets.ai.engineer/sites/aiecode2025/sha256/29528ad1943add74219b8693dff6c96e82023ab26c085c67299ed963c2a9b7dc.webp)

USING MISSIONS
Mission Control

A dedicated view for multi-day autonomous work. Monitor, redirect, or close your laptop and come back tomorrow.

Monitor from a bird's eye view

AI Engineer - Factory
2026
8

Interface text:
Droid
Mission Control  ~/Development/note-tracker
TIME 56m 54s  Input 324.0K  Cached 16.8M  Output 111.0K
RUNNING  3/17 [+6]

Active Feature  scrutiny-validator-app-shell
skill scrutiny-validator
milestone app-shell

Preconditions
- All implementation features for milestone "app-shell" are complete

Expected Behavior
- Validators pass (test, typecheck, lint)
- Review subagents spawned for each feature
- Findings synthesized into scrutiny report

Description
Scrutiny validation for milestone "app-shell". Runs test suite, typecheck, and lint. Spawns review subagents for each completed feature. Synthesizes findings. Always returns to orchestrator.

Features  3/11
✓ bootstrap-tauri-workspace
✓ menu-bar-shell-and-lifecycle
✓ quick-note-save-and-main-list
● scrutiny-validator-app-shell
○ user-testing-validator-app-shell
○ categories-and-tagging-experience
○ due-date-parsing-and-note-metadata
○ google-calendar-auth-and-secure-storage
+3 more

Progress Log  1-9 of 10
<1m ago  #95fb1b2d started [scrutiny-validator-app-shell]
<1m ago  Milestone validation: app-shell
<1m ago  #d1b6b4a7 completed [quick-note-save-and-main-list] ✓
5m ago  #d1b6b4a7 started [quick-note-save-and-main-list]
5m ago  #afc827a8 completed [menu-bar-shell-and-lifecycle] ✓
13m ago  #afc827a8 started [menu-bar-shell-and-lifecycle]
13m ago  #1963e245 completed [bootstrap-tauri-workspace] ✓
21m ago  #1963e245 started [bootstrap-tauri-workspace]
21m ago  Run started: Mission artifacts authored, repo scaffold...

Active Worker  #1  scrutiny-validator-app-shell  Duration 7s
> ## Your Assigned Feature ```json { "id": "scrutiny-validator-app-shell", "description": "Scrutiny validation for milestone \"app-shell\". Runs test suite, typecheck, and lint. Spawns review subagents for each completed feature. Synthesizes findings. Always returns to orchestrato...

F Features  W Workers  M Models  P Pause  D Mission Dir  Ctrl+T Back To Orchestrator

### Inspecting workers

Mission Control lists four workers: one running and three completed. The view lets the user inspect individual workers during a multi-day mission.

[10:31](https://www.youtube.com/watch?v=ow1we5PzK-o&t=631s) [Mission Control lists active and completed workers.](https://assets.ai.engineer/sites/aiecode2025/sha256/a6bf5e78211f3f65fe87503c8d0dc8fd31565233ef4d10c9cd2d5f9b0236854a.webp)

USING MISSIONS

Mission Control

A dedicated view for multi-day autonomous work. Monitor, redirect, or close your laptop and come back tomorrow.

Inspect all the workers

AI Engineer - Factory
2026
8

Interface text:
Droid
Mission Control  ~/Development/note-tracker
TIME 56m 54s  Input 324.[illegible]K  Cached 16.8M  Output 111.0K

Workers (4)
All (4) | Active (1) | Completed (3) | Failed (0)

#  Session  Start  Duration  Status  Input  Cached  Output  Feature
1  95fb1b2d  15:08  10s  Running  -  -  -  scrutiny-validator-app-shell
4  d1b6b4a7  15:02  5m 47s  Success  40  2.0M  18.0K  quick-note-save-and-main-list
3  afc827a8  14:54  7m 36s  Success  60  7.3M  21.0K  menu-bar-shell-and-lifecycle
2  1963e245  14:46  8m 1s  Success  54  5.0M  15.1K  bootstrap-tauri-workspace

↑↓ Select  Enter View  T Filter  Esc Back  F Features  M Models

### Reading worker handoffs

Mission Control opens a completed worker’s session, showing its plan, commands, and completion status. Alvoeiro says handoff summaries capture discoveries and how work may change course.

[10:35](https://www.youtube.com/watch?v=ow1we5PzK-o&t=635s) [Mission Control displays a completed worker session and its activity.](https://assets.ai.engineer/sites/aiecode2025/sha256/ebda5e1e1177be27580847655093a5f6bb422fe359219954e22df27b99ecbd27.webp)

USING MISSIONS

Mission Control

A dedicated view for multi-day autonomous work. Monitor, redirect, or close your laptop and come back tomorrow.

Worker Session
Session: [illegible]
Feature: quick-note-save-and-main-list
Model: Opus 4.6 (High)
Status: Success · Duration: 5m 47s
Tokens: Input 40 · Cached 2.0M · Output 18.0K

↑93 more above
Plan 1. [completed] Run baseline tests (pnpm test + cargo test) 2. [completed] Add SQLite dependency and create note persistence layer in Rust...
→TODO List Updated

Execute cd /Users/luke/Development/note-tracker && git status
→On branch main Changes not staged for commit: [illegible]
Execute cd /Users/luke/Development/note-tracker && git add -A && git commit -m "Add note persistence with SQLite and quick-note save path - Ad...
→[illegible]
Execute cd /Users/luke/Development/note-tracker && git status && git rev-parse HEAD
→On branch main nothing to commit, working tree clean [illegible] [Process exited with code 0]

Clean working tree. Now let me call EndFeatureRun:

End Feature Run success
→[illegible]

Read the handoffs

AI Engineer - Factory
2026
8

Interface text:
Droid
Mission Control ~/Development/note-tracker
TIME 56m 54s · Input 324.0K · Cached 16.8M · Output 111.0K
↑↓ Scroll   [] Density   g Top   G Bottom   s Interrupt/Chat   h Handoff   Esc Back

### The right model in each role

Missions can use different models for planning, implementation, and validation. A separate validation provider may reduce shared training-data bias, while model-agnostic design lets each role use a specialized model.

[12:24](https://www.youtube.com/watch?v=ow1we5PzK-o&t=744s) [Three panels describe model roles, followed by a conclusion about model-agnostic architecture.](https://assets.ai.engineer/sites/aiecode2025/sha256/f1200cff5a721699c9c8c7b67e929d892c0633f59b8e62c73cf67b8fe86289df.webp)

USING MISSIONS

The right model in each role

No single model is best at planning, implementation, and validation.

PLANNING
Slow, careful reasoning.
Strategic questions, constraint analysis.

IMPLEMENTATION
Code fluency and creativity.
Fast generation, tool use.

VALIDATION
Strict instruction following.
Different provider avoids training-data bias.

Model-agnostic architecture = compounding advantage as models specialize

You're only as strong as your weakest link. If locked into one model family, you're constrained by that family's weakest capability.

AI Engineer - Factory
2026
9

### Breaking down a real mission

A Slack-clone mission ran for 16.5 hours, with 60.5% spent on implementation. Its milestone waterfall shows repeated implementation and validation; tests made up 52.5% of the code, with 89.25% statement coverage.

[13:02](https://www.youtube.com/watch?v=ow1we5PzK-o&t=782s) [Dashboard summarizing runtime, agent runs, tokens, code and test coverage for a Slack clone.](https://assets.ai.engineer/sites/aiecode2025/sha256/4122043fe548020c5a851d3baccceb0195d6d9946403fb30e57f614b761d04f5.webp)

USING MISSIONS
Breaking down a real mission
Building a clone of Slack

TIME
Total runtime — 16.5 h
Orchestration 0.38 h · 2.3%
Implementation 9.98 h · 60.5%
Validation 6.14 h · 37.2%

MILESTONE WATERFALL
Legend: impl, val
Timeline: 0h, 2h, 4h, 6h, 8h, 10h, 12h, 14h, 16h
Foundation
Channels & messaging
Conversations
Interactions
Rich features
Real-time polish

AGENT RUNS
185 total runs
subagents
Y-axis ticks: 3, 6, 9, 12
Timeline: 0h, 2h, 4h, 6h, 8h, 10h, 12h, 14h, 16h
Orchestration 1 · 12 subagents
Workers 63
Validators 27 · 82 subagents

TOKENS
778.5M total tokens
BY TYPE
Input 30.3M
Cache read 744.9M
Output 3.4M
BY ROLE
Orchestration 29.2M
Implementation 485.5M
Validation 263.8M

CODE
38.8k lines — 52.5% tests
CODE SPLIT
Source 18.5k lines
Tests 20.4k lines
STATEMENT COVERAGE
Covered 89.25%
Uncovered 10.75%

AI Engineer - Factory
2026
10

### What have people built

A home visualization sits beside a restaurant network connecting people, restaurants, and groups. The selected Danny Meyer view lists founding and training links. Enterprise uses include overnight prototypes and codebase modernization.

[13:58](https://www.youtube.com/watch?v=ow1we5PzK-o&t=838s) [Examples of a home visualization and a restaurant relationship network.](https://assets.ai.engineer/sites/aiecode2025/sha256/3ae52f991fa286239d7af5f815453431f2d114af3a15e07454358e6483adc74b.webp)

USING MISSIONS

What have people built

Prototypes & large features, internal tools, refactors & migrations, agent readiness

Interface text:
The sun sets
BEDROOM
68° Partly Cloudy

NYC Restaurant Network

RELATIONSHIP FILTERS
Trained Under
Founded
Worked At
Part Of
Spun Off
Invested In
Succeeded
Collaborated

LEGEND
Person
Restaurant
Restaurant Group

SHORTEST PATH
From...
To...
Find Path
Clear

TIMELINE
1800
2025

65 people
86 restaurants
9 groups

Danny Meyer
PERSON
Danny Meyer
Role: Restaurateur
Active: 1985–present
Founder of Union Square Hospitality Group. Pioneered “enlightened hospitality” philosophy.

CONNECTIONS (9)
Union Square Hospitality Group — Founded (1985)
Union Square Cafe — Founded (1985)
Gramercy Tavern — Founded (1994)
Eleven Madison Park — Founded (1998)
Shake Shack — Founded (2004)
Michael Anthony — Trained Under
Floyd Cardoz — Trained Under
Daniel Humm — Trained Under
Will Guidara — Trained Under

### Designed to not be made obsolete

Missions puts orchestration in prompts and per-mission skills so model improvements can carry through. A thin deterministic layer runs validation and blocks progress on unresolved handoffs.

[14:31](https://www.youtube.com/watch?v=ow1we5PzK-o&t=871s) [Slide describing orchestration through prompts and mission-specific skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/0a498b2af9cd8b749d643791197d400720b34d3ef69eca416fb6c1b704a6a5ca.webp)

USING MISSIONS

Designed to not be made obsolete

When the next model drops, does the system get better or break?

Almost all orchestration logic lives in prompts and skills.
• How it decomposes features
• How it handles failures
• When it escalates

Worker behavior is driven by skills that the orchestrator defines per-mission.

When a better model drops, the system just gets smarter. No code changes needed.

AI Engineer - Factory
2026
11

[15:21](https://www.youtube.com/watch?v=ow1we5PzK-o&t=921s) [Slide explaining that orchestration lives in prompts and skills, while a thin deterministic layer handles validation and bookkeeping.](https://assets.ai.engineer/sites/aiecode2025/sha256/bc0d46d34c80d082b60cd56756e5f3ca719e0c47fc2065eb957c958256fa5306.webp)

USING MISSIONS

Designed to not be made obsolete

When the next model drops, does the system get better or break?

Almost all orchestration logic lives in prompts and skills.
• How it decomposes features
• How it handles failures
• When it escalates

Worker behavior is driven by skills that the orchestrator defines per-mission.

When a better model drops, the system just gets smarter. No code changes needed.

THE THIN DETERMINISTIC LAYER

Hardcoded to handle bookkeeping
• Triggering validation
• Blocking progress when handoff issues aren't addressed

Missions ensure discipline.
The models provide intelligence.

AI Engineer - Factory
2026
11

Interface text:
AI Engineer EUROPE
Braintrust
Google DeepMind

### What this unlocks

Alvoeiro suggests Missions could increase a five-engineer team’s concurrent workstreams from 10 to 30, freeing engineers to focus on architecture and product decisions. He also calls for leaving the codebase better.

[15:49](https://www.youtube.com/watch?v=ow1we5PzK-o&t=949s) [Slide proposing an increase from 10 to 30 concurrent workstreams for five engineers and listing tests, skills, and configuration as codebase improvements.](https://assets.ai.engineer/sites/aiecode2025/sha256/cae9e4e9df656c09f7861a23c4ccc394518c56e2f4df5de41cf46a793d966031.webp)

LOOKING FORWARD
What this unlocks

10 → 30
concurrent workstreams with a team of 5 engineers

Engineers focus on architecture, product decisions, and the genuinely hard problems.

Leave your codebase in a better place than when you started
• E2E Tests
• Unit tests
• Skills
• setup.yaml
• Agents.md
• ... more!

AI Engineer - Factory
2026
12

Interface text:
AI Engineer EUROPE
Braintrust
WorkOS
OpenAI

### Missions are a composition

The orchestrator delegates work to agents, while separate validators check implementation. Agents reference shared state and use structured handoffs to preserve context.

[16:35](https://www.youtube.com/watch?v=ow1we5PzK-o&t=995s) [Diagram of an orchestrator, milestone workers and validators, research subagents, and shared state, alongside principles for connecting agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/70aaf6b584c611bec43c4e74065eae8fd0be5929cb158658748e431ff11be3da.webp)

LOOKING FORWARD
Missions are a composition

The connective tissue:
• Structured handoffs so agents don't lose context
• Validation separate from implementation
• The right model in each role
• Architecture that improves as models improve

THE ORCHESTRATOR

MILESTONE
Feature #1 → Feature #2 … → Feature #N
Workers
Scrutiny Validator + User-Testing Validator
Validators

Research / Readonly Subagent
Research / Readonly Subagent

Shared State
features.json
handoffs.jsonl
validation-contract.md
Agent Skills
+7 more files...

AI Engineer - Factory
2026
13

### Try it today

Open Droid and run /missions. Describe the goal, discuss scope with the orchestrator, and approve the plan before moving on to something else.

[17:56](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1076s) [Instructions to run /missions, describe the goal, discuss scope, and approve the plan.](https://assets.ai.engineer/sites/aiecode2025/sha256/4c96225fe49987fff7762afb073b9c17283cd3abd61a46a989884ece60aec733.webp)

Try it today

/missions

Describe what you want.
Argue with the orchestrator about scope.
Approve the plan.
Then go do something else.

## Full transcript

[0:00](https://www.youtube.com/watch?v=ow1we5PzK-o&t=0s) [upbeat music] Hi, everyone.

[0:16](https://www.youtube.com/watch?v=ow1we5PzK-o&t=16s) Uh, my name is Luke, and my goal is that twenty minutes from now, you'll be able to assemble agent teams that can complete tasks orders of magnitude harder than what you can complete with a single agent today.

[0:27](https://www.youtube.com/watch?v=ow1we5PzK-o&t=27s) Um, a little bit about me. So, um, I come from a background in dev tools. About two and a half years ago, I started a project at Block, which is where I was working at the time, um, and that project evolved into Goose.

[0:40](https://www.youtube.com/watch?v=ow1we5PzK-o&t=40s) Goose, um, is now one of the leading coding agents, is open source, um, and it's recently was, was donated to the AI, um, Agentic AI Foundation. So it's been really cool to see.

[0:53](https://www.youtube.com/watch?v=ow1we5PzK-o&t=53s) Now, um, nowadays, I work at Factory, where I lead our core agent harness, and Factory's mission is to bring autonomy to the entire software development life cycle.

[1:04](https://www.youtube.com/watch?v=ow1we5PzK-o&t=64s) So I wanna start off with a claim. Uh, the bottleneck in software engineering nowadays is not intelligence. It's now limited by human attention. Uh, even the best engineers can only complete a couple of tasks at a time.

[1:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=77s) Um, they may have a backlog of fifty features, but they can only drive a few forward per day because every task requires their attention, every commit needs their review.

[1:26](https://www.youtube.com/watch?v=ow1we5PzK-o&t=86s) Today's models are smart enough to figure out all fifty of these tasks, but there's not enough, uh, just bandwidth to supervise their implementation.

[1:36](https://www.youtube.com/watch?v=ow1we5PzK-o&t=96s) So we kept asking ourselves, what if a human decides what to build and then a system figures out how to do so, right? An agent could just work for hours, for days, and you come back to finished work.

[1:47](https://www.youtube.com/watch?v=ow1we5PzK-o&t=107s) So that's what I'm here to talk about.

[1:50](https://www.youtube.com/watch?v=ow1we5PzK-o&t=110s) Um, when you start researching multi-agent frameworks and systems, you quickly realize that the field's a bit of a mess. Everyone has their own framework, their own terminology, their own, uh, opinions of what works and doesn't work.

[2:02](https://www.youtube.com/watch?v=ow1we5PzK-o&t=122s) And so I wanna propose a simple taxonomy. There's five frontier multi-agent frameworks. One is delegation, right? This is where one agent spawns another agent, and the parent agent may say, "Go figure out the database schema," and then gets a response back.

[2:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=137s) This is the simplest form of multi-agent communication, and it's what, what most people implement first. Um, you have, you know, sub-agents in coding tools are the most common example.

[2:28](https://www.youtube.com/watch?v=ow1we5PzK-o&t=148s) Um, the, the other one is creator verifier, right? Where one agent builds something, and then you have another agent that checks that work. And the key here is, like, a separation of concerns.

[2:38](https://www.youtube.com/watch?v=ow1we5PzK-o&t=158s) The par-- the, the agent that implemented the, the code is, has sunk cost bias, right? It wants that code to work. Um, a fresh agent with fresh context is way more likely to find issues, and this is why we do code review as humans as well.

[2:51](https://www.youtube.com/watch?v=ow1we5PzK-o&t=171s) Um, another one is direct communication. This is when agents communicate without a central coordinator, right? It's a kind of like DM-ing each other.

[3:00](https://www.youtube.com/watch?v=ow1we5PzK-o&t=180s) It's hard to get right though because state fragments across conversations without that coordinator, and there's no single source of truth. Um, the next one is negotiation, right? Negotiation is when agents communicate, um, but over a shared resource.

[3:16](https://www.youtube.com/watch?v=ow1we5PzK-o&t=196s) So that might be, you know, they wanna use the same API, they wanna modify the same portion of the code base. Uh, but negotiation doesn't need to be adversarial.

[3:25](https://www.youtube.com/watch?v=ow1we5PzK-o&t=205s) In fact, the best use case is when there's, uh, net pos-- net positive sum trading, right? And that's, um, when agents have, like, a potential win-win situation while interacting.

[3:37](https://www.youtube.com/watch?v=ow1we5PzK-o&t=217s) And then the last one is broadcast, and that is when one agent sends information to many. Uh, think of it like, you know, status updates, uh, new context that applies to everyone, new shared constraints.

[3:48](https://www.youtube.com/watch?v=ow1we5PzK-o&t=228s) Um, it's a bit less, uh, flashy than the other ones, but it's critical for maintaining coherence over long-running tasks. And so when you have all of these different building blocks, how do you assemble that into a system that can run for many days?

[4:03](https://www.youtube.com/watch?v=ow1we5PzK-o&t=243s) So Missions is our answer. It's a system that combines four of those: delegation, creator verifier, uh, broadcast, and negotiation into a single workflow. You describe a goal, you scope that through a conversation, you approve a plan, and then the system handles execution for hours or days, and that enables you to focus on something else.

[4:27](https://www.youtube.com/watch?v=ow1we5PzK-o&t=267s) Notably, a mission is not a single agent session. It's an ecosystem of agents that communicate through structured handoffs and shared state.

[4:36](https://www.youtube.com/watch?v=ow1we5PzK-o&t=276s) It uses a three-role architecture. There's orchestrator, there's workers, and then there's validators. The orchestrator handles planning. When you describe what you want, the orchestrator is kind of like your sounding board.

[4:47](https://www.youtube.com/watch?v=ow1we5PzK-o&t=287s) It asks you the right strategic questions. It, um, you know, checks out if there's any unclear requirements in, in the problem space, and then it eventually produces a plan that includes features, milestones, and then something that's called a validation contract.

[5:03](https://www.youtube.com/watch?v=ow1we5PzK-o&t=303s) And that validation contract defines what done sort of means before any coding is done. And I'll come back to why that matters because it turns out to be really important to the system.

[5:14](https://www.youtube.com/watch?v=ow1we5PzK-o&t=314s) The next role are workers. They handle implementation. Um, when a feature is assigned to a worker, that worker has clean context, no accumulated baggage, no degraded attention, right? The worker reads its spec, it implements the feature, and then commits, um, via Git, allowing the next worker to inherit a clean slate and a working code base.

[5:35](https://www.youtube.com/watch?v=ow1we5PzK-o&t=335s) And then the last role are validators. They handle verification. And so most systems validate by maybe running lint, type checks, tests, maybe they do code review. Missions does all of that, but we also validate behavior.

[5:48](https://www.youtube.com/watch?v=ow1we5PzK-o&t=348s) Instead of just asking, you know, does the code look right? We wonder, does this work end to end? That's the difference that lets, lets Missions run for many hours, many days in a row without drifting.

[6:00](https://www.youtube.com/watch?v=ow1we5PzK-o&t=360s) And making it work had to involve sort of rethinking validation entirely. So when you've worked with coding agents before, you've probably seen this pattern where an agent builds a feature, it writes some tests, the tests pass, there's full coverage.

[6:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=377s) But the tests were sort of shaped by the code, not by what the code was attempting to actually do.

[6:23](https://www.youtube.com/watch?v=ow1we5PzK-o&t=383s) Tests written after implementation don't catch bugs. They confirm decisions. So if you rely on validation like that, your system will eventually drift.

[6:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=394s) That's why this validation contract exists. It's written during planning, before any code, and it defines correctness independently of implementation. So for a complex project, this can be hundreds of assertions, and each feature is assigned one or more assertions that it must satisfy.

[6:51](https://www.youtube.com/watch?v=ow1we5PzK-o&t=411s) The sum of all features must mean that every assertion is covered.

[6:58](https://www.youtube.com/watch?v=ow1we5PzK-o&t=418s) After each of-- after each milestone of features, we have, uh, two types of validators that run. So you have the scrutiny validator and the user testing validator. The first one is more traditional.

[7:09](https://www.youtube.com/watch?v=ow1we5PzK-o&t=429s) It runs the test suite, type-checking, lints, and critically, it spawns, uh, dedicated code review agents for each completed feature within the milestone. And then the second one, which is the user testing validator, is more interesting.

[7:21](https://www.youtube.com/watch?v=ow1we5PzK-o&t=441s) It kind of acts like a QA engineer. It spawns the application, it interacts with it through computer use or something similar to that. It, uh, fills out forms, you know, uh, checks that pages render correctly, clicks buttons, and ensures that functional flows work holistically.

[7:38](https://www.youtube.com/watch?v=ow1we5PzK-o&t=458s) So this step takes significantly longer than the previous one of, of the scrutiny validator, uh, because the, the system is interacting with a live application. And what we've noticed is that Missions, most of the Missions wall clock time is actually spent here waiting for this, like, real-world execution to occur instead of generating tokens.

[7:59](https://www.youtube.com/watch?v=ow1we5PzK-o&t=479s) Critically, neither validator has seen the code before. They are not invested in the implementation, and so validation is adversarial by design.

[8:09](https://www.youtube.com/watch?v=ow1we5PzK-o&t=489s) Okay, so then validation catches bugs, right? But for a system that runs for many days, you also need to make sure that context isn't lost between the agents. When a worker finishes a feature, it doesn't just say, "I'm done."

[8:23](https://www.youtube.com/watch?v=ow1we5PzK-o&t=503s) It fills out a structured handoff detailing what was completed, what was left undone, what commands were run throughout that, that, uh, agent loop, and what were the c- the exit codes of those commands, um, what issues were discovered, and did it abide by the procedures that the orchestrator defined for that worker.

[8:44](https://www.youtube.com/watch?v=ow1we5PzK-o&t=524s) That's how we catch issues and how the system self-heals.

[8:48](https://www.youtube.com/watch?v=ow1we5PzK-o&t=528s) The errors get caught at milestone boundaries, corrective work gets scoped, and the Mission sort of, like, pulls itself back on track, not by hoping that agents remember what happened, but by forcing them to write it down and then actually address issues, and I'll, I'll present on that in just a sec.

[9:06](https://www.youtube.com/watch?v=ow1we5PzK-o&t=546s) Um, our longest Mission ran for sixteen days, which is much longer than a full sprint, and we believe that they can run for thirty. That's only possible because of this structure.

[9:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=557s) So once we had this architecture, the next question beame- became, um, how do we actually run it, right? Um, the most obvious choice is, like, parallelism. If you have ten agents running at one point in time, then you have ten times the throughput.

[9:31](https://www.youtube.com/watch?v=ow1we5PzK-o&t=571s) But we tried that, and it doesn't really work for tasks in the, like, software dev domain because agents conflict. They step on each other's changes, they duplicate work, they make inconsistent architectural decisions.

[9:43](https://www.youtube.com/watch?v=ow1we5PzK-o&t=583s) And so the coordination overhead ends up eating up the speed gains all the while you're burning tokens. The difference with Missions is that we run features serially. So there's only one worker or validator running at any given point in time.

[9:58](https://www.youtube.com/watch?v=ow1we5PzK-o&t=598s) Within a feature, we allow for parallelization on read-only operations. So you have something like, uh, searching through the code base or researching APIs, all that gets parallelized. Within validators, we also parallelize read-only operations such as code review.

[10:15](https://www.youtube.com/watch?v=ow1we5PzK-o&t=615s) This is serial execution with int-- with targeted internal parallelization. It seems slower on paper, but the error rate drops dramatically, and when you have tasks that run for many days, this sort of correctness compounds.

[10:30](https://www.youtube.com/watch?v=ow1we5PzK-o&t=630s) Now, your, your standard chat interface doesn't really work for something that lasts many days. At a quick glance, you need to be, be able to see how much of the project have you completed and what's, what amount of the budget that you originally, like, set off with have you burned through.

[10:45](https://www.youtube.com/watch?v=ow1we5PzK-o&t=645s) So using a Mission, actually, we built Mission Control, which is a dedicated view for this. You can see what is, what is active worker doing right now, uh, read off handoff summaries that detail what did the worker or the validator discover, um, how it's cl- gonna sort of like alter its course, uh, moving forward.

[11:03](https://www.youtube.com/watch?v=ow1we5PzK-o&t=663s) Or you could just, you know, go check out, um, you know, go hang out with your friends that night. This entire view lets you just run Missions asynchronously, and you could be plugged in as a project manager overseeing the implementation, or you could just, you know, go and, and, uh, hang out with your friends.

[11:22](https://www.youtube.com/watch?v=ow1we5PzK-o&t=682s) Okay, so the right model in each role. Uh,

[11:26](https://www.youtube.com/watch?v=ow1we5PzK-o&t=686s) everything here sort of assum- assumes one thing, and that is that you're using the right model in each role. Planning benefits from slow, careful reasoning, implementation from fast code fluency and creativity, validation benefits from, uh, precise instruction following, right?

[11:42](https://www.youtube.com/watch?v=ow1we5PzK-o&t=702s) And so no single model nor model provider is best at all three of these. Using systems like Missions requires the development of a new skill, which internally we've been calling Droid whispering.

[11:53](https://www.youtube.com/watch?v=ow1we5PzK-o&t=713s) But it's this idea that you need to be able to mentally model how different LLMs interact, where they fail, how those failures compound over a multi-day run, and then you need to make a deliberate choice as to which model sits in which seat.

[12:06](https://www.youtube.com/watch?v=ow1we5PzK-o&t=726s) Theo, the engineer who built our Missions prototype, came up with our, our model defaults, but we really encourage people to make these, uh, their own and customize them to the needs of their project.

[12:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=737s) So, for example, validation might use a different model provider entirely to make sure that it's not biased by the same training data.

[12:24](https://www.youtube.com/watch?v=ow1we5PzK-o&t=744s) This is a structural advantage of a model-agnostic architecture. You're only as strong as your weakest link, and if you're locked into one model provider, then you're constrained by that family's weakest capability.

[12:36](https://www.youtube.com/watch?v=ow1we5PzK-o&t=756s) As models continue to specialize, the ability to put the right model in the right seat becomes a compounding advantage.

[12:44](https://www.youtube.com/watch?v=ow1we5PzK-o&t=764s) It works in the other direction, too. If you're using Missions, the structure of that can compensate for models that are not quite at like the frontier level performance. So the validation contracts, the milestone checkpoints, they allow you to run Missions very, very successfully, even using open weight models.

[13:04](https://www.youtube.com/watch?v=ow1we5PzK-o&t=784s) Now, this all sounds quite theoretical. What does it actually look like in production? I wrote an example of building a clone of Slack right here. This slide has a ton of info, but I'll walk you through just a few things that I wanna call out.

[13:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=797s) Sixty percent of our time is spent on implementation and sixty percent of our tokens as well. Notice how validation never succeeds on the first go. That's in the Mission, um, what's it?

[13:29](https://www.youtube.com/watch?v=ow1we5PzK-o&t=809s) The one on the bottom left. Um, we almost always have to create follow-up features. So it really demonstrates like the value of a system that does this QA loop.

[13:39](https://www.youtube.com/watch?v=ow1we5PzK-o&t=819s) You end up with sev-- with fifty percent of your lines of code at the very end in the bottom right being tests, and ninety percent of your, uh, code is covered by those tests.

[13:49](https://www.youtube.com/watch?v=ow1we5PzK-o&t=829s) And lastly, we take advantage of prompt caching heavily to make sure that we're sort of offsetting, um, the, the price of running such a long task.

[14:00](https://www.youtube.com/watch?v=ow1we5PzK-o&t=840s) People have really taken to Missions, and it's been awesome to see what folks have been building with them. Um, some examples I've included in this slide, but ones that I wanna call out are specifically in the enterprise setting, which is where Factory really shines.

[14:13](https://www.youtube.com/watch?v=ow1we5PzK-o&t=853s) Um, they've been used to prototyping new ideas and features overnight to, um, make sure that people can, uh, build internal tools at increasingly rapid rates to run huge refactors and migrations for ML search, or research, sorry, and to modernize, uh, code bases so that agents are more productive in them.

[14:34](https://www.youtube.com/watch?v=ow1we5PzK-o&t=874s) Um, one thing that I wanted to talk about was also this concept of like the bitter lesson. Because every person building multi-agent systems has this fear of the next model release sort of like making their ob-- their architecture obsolete overnight.

[14:48](https://www.youtube.com/watch?v=ow1we5PzK-o&t=888s) Um, so when we were building Missions, we decided we had to make this system get better with every model improvement. This means that almost all of the orchestration logic is defined in prompts and skills, um, instead of like a hard-coded state machine.

[15:04](https://www.youtube.com/watch?v=ow1we5PzK-o&t=904s) How it decomposes failures and, um, or ha- or decomposes features and handles failures is all in about like seven hundred lines of text, and four sentences of this can alter the execution strategy pretty dramatically.

[15:18](https://www.youtube.com/watch?v=ow1we5PzK-o&t=918s) Worker behavior is driven by skills that the orchestrator defines per mission, so you get very customized behavior. And the only deterministic logic is very thin, and it's focused on enabling models to do what they do best while the system handles like the bookkeeping, right?

[15:32](https://www.youtube.com/watch?v=ow1we5PzK-o&t=932s) Stuff like running validation and ensuring that progress is blocked when there are some handoff issues that are not addressed. So Missions sort of ensure the, the discipline, and the models provide the intelligence, uh, using primitives that they're already familiar with, like AGENTS.md, skills, et cetera.

[15:51](https://www.youtube.com/watch?v=ow1we5PzK-o&t=951s) So what does this unlock? Remember the bottleneck that I started off with, human attention. The economics are sort of changing. Before, a team of five engineers might be able to, uh, work on ten work streams at any given point in time.

[16:04](https://www.youtube.com/watch?v=ow1we5PzK-o&t=964s) Now, maybe with Missions, we can bring that up to thirty. The team can focus on interesting problems such as, uh, the architecture, product decisions, um, instead of, uh, worrying about the execution per se.

[16:17](https://www.youtube.com/watch?v=ow1we5PzK-o&t=977s) And the important thing is the code base ends up cleaner than when you started. The end-to-end tests, the unit tests, the skills, the structure that Missions provide, uh, means that agents and humans are more productive in that environment moving forward.

[16:33](https://www.youtube.com/watch?v=ow1we5PzK-o&t=993s) So now that you understand how Missions are structured and how they actually work, you can see that they're really a composition of those original, um, strategies, right? Delegation shows up everywhere in how the orchestrator spawns workers and, uh, how we spawn research sub-agents.

[16:49](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1009s) Creator Verifier is fundamental in that validation and implementation are always separate agents with separate context. Broadcast runs through the shared, uh, Mission state that every agent references. And negotiation shows up at milestone boundaries where the orchestrator decides, you know, does this, does this h-hand-off summary sort of like look correct?

[17:07](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1027s) Do we need to create follow-up features, rescope, et cetera?

[17:11](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1031s) But strategies aren't enough. You need the connective tissue. You need, uh, these structured handoffs so that agents don't lose context. You need the right model in each role, and you need an architecture that will improve with each model improvement.

[17:24](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1044s) So what I like to think about is that people in this room who are thinking in terms of agent ecosystems, who develop an intuition for how different models compose under pressure, um, that those folks are gonna be really shipping the next generation of innovation.

[17:39](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1059s) Uh, there's a lot of open questions still, right? Um, how do we further parallelize the workload of Missions so that they run faster? How do we start orchestrating Missions themselves into even more complex workflows?

[17:50](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1070s) Uh, but the data from production Missions is clear. This works on real projects at scale today. So this is what I'll leave you with. Open Droid, try running /missions, argue with the orchestrator about the scope, approve the plan, and then go do something else.

[18:08](https://www.youtube.com/watch?v=ow1we5PzK-o&t=1088s) I'm excited to see what you guys build, and I'll be around to answer any questions, uh, for the rest of the day. Thanks. [applauding] [upbeat music]
