Multi-Agent Software Development System with Extended Autonomous Execution

factory · Tech · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Autonomous software development

Factory wanted coding agents to run for days or weeks on complex software tasks while reducing the human-attention bottleneck that limits how many engineering tasks can be supervised.

Constraints:

Engineers can supervise only a few tasks despite large backlogs.
Long-running coding agents need coherent state and review over days.
Direct agent communication can fragment state without a coordinator.
Generated code still needs independent validation and tests.

Architecture

Factory built Missions, a long-running multi-agent software-development system with orchestrators, workers, and validators. It combines delegation, creator-verifier review, broadcast updates, and negotiation while excluding unconstrained direct communication to keep centralized state. Missions can plan, build, validate, and negotiate shared codebase resources over extended runs.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  orchestrators["Orchestrators"]
  workers["Workers"]
  validators["Validators"]
  broadcast-channel["Broadcast Channel"]
  orchestrators --> workers
  orchestrators --> validators
  workers --> orchestrators
  workers --> validators
  validators --> orchestrators
  validators --> workers
  broadcast-channel --> orchestrators
  broadcast-channel --> workers
  broadcast-channel --> validators

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Orchestrators`	Plan work, clarify goals, delegate tasks, and keep centralized state.	`Workers`, `Validators`
`Workers`	Implement delegated software-development subtasks.	`Orchestrators`, `Validators`
`Validators`	Independently check worker outputs and code quality.	`Orchestrators`, `Workers`
`Broadcast Channel`	Distributes shared constraints, status, and context to many agents.	`Orchestrators`, `Workers`, `Validators`

Data flow

A user describes a goal to an orchestrator. The orchestrator asks clarifying questions, creates a plan, delegates implementation to workers, broadcasts shared context, uses validators for independent review, and coordinates negotiation when agents contend for APIs or codebase areas.

“The system uses a three-role architecture (orchestrators, workers, and validators) that combines delegation, creator-verifier patterns, broadcast communication, and negotiation”summary, stated

“Orchestrators handle planning and strategic decision-making.”summary, stated

Why this architecture

Missions combines four multi-agent patterns because extended autonomous development requires division of labor, independent verification, shared state, and coordination over contested resources. Direct communication was excluded because it fragments state without a coordinator.

“Missions deliberately incorporates four of these five patterns—delegation, creator-verifier, broadcast, and negotiation—into a unified workflow”summary, stated

“Factory acknowledges this pattern is difficult to implement correctly because state fragments across conversations without a coordinator providing a single source of truth.”summary, stated

Models used: unspecified coding-agent models

Scale

Missions have run continuously for up to 16 days.
“Missions have successfully executed for up to 16 days continuously”summary, stated
Factory believes 30-day missions are achievable.
“the longest recorded mission running for 16 days and the team believing 30-day missions are achievable.”summary, stated
A production example maintained 90% test coverage.
“while maintaining 90% test coverage and producing cleaner codebases than the starting point.”summary, stated

Alternatives considered (roads not taken)

Use direct agent-to-agent communication freely

Rejected because: Factory found direct communication fragments state without a coordinator.

“notably excluding only direct communication to maintain centralized state management.”summary, stated

Let implementers validate their own work

Rejected because: The creator-verifier pattern uses a fresh validator to counter implementation bias.

“the implementing agent has cost bias—it wants its code to work—while a fresh agent with fresh context is more likely to identify issues”summary, stated

Patterns

`multi-agent-orchestration` (architecture)

Missions coordinates orchestrators, workers, validators, broadcast, and negotiation for long-running coding work.

“The system employs a three-role architecture that distributes responsibilities across specialized agent types:”summary, stated

`eval-driven-development` (quality)

Validators independently check worker outputs in a creator-verifier loop.

“Creator-Verifier establishes separation of concerns where one agent builds something and another independently checks the work.”summary, stated

`context-engineering` (context)

Broadcast and centralized coordination preserve shared context across long-running missions.

“Broadcast enables one agent to send information to many recipients, handling status updates, new context, and shared constraints.”summary, stated

Tradeoffs

Exclude direct communication

Chose Centralized state management through orchestrators over Free direct messages among agents.

Rationale: Central state reduces fragmentation during long missions.

“notably excluding only direct communication to maintain centralized state management.”summary, stated

Run missions for extended periods

Chose Days- or weeks-long autonomous execution over Short coding-agent sessions only.

Rationale: Factory's goal is to overcome human attention limits on large backlogs.

“the longest recorded mission running for 16 days and the team believing 30-day missions are achievable.”summary, stated

Gotchas (what bit them)

Long-running direct agent communication fragments state.

Root cause: Messages split across conversations without a single source of truth.

Resolution: Missions excludes direct communication and keeps centralized state management.

“state fragments across conversations without a coordinator providing a single source of truth.”summary, stated

Implementing agents have bias toward their own code.

Root cause: The creator wants its code to work and may miss defects.

Resolution: Factory uses validator agents with fresh context for independent review.

“the implementing agent has cost bias—it wants its code to work—while a fresh agent with fresh context is more likely to identify issues”summary, stated

Evaluation

The case reports mission duration, production usage examples, test coverage, and qualitative codebase improvement.

Metrics: up to 16 days continuous execution · 90% test coverage · 30-day missions believed achievable

“Missions have successfully executed for up to 16 days continuously, with production usage demonstrating the ability to build complex applications like Slack clones”summary, stated

Outcomes

Missions can run multi-agent software-development tasks for up to 16 days.
Factory reports complex-app builds such as Slack clones with 90% test coverage.
The system addresses human attention as the bottleneck in supervising many coding tasks.

The case reports 16-day continuous missions, 90% test coverage, and ambition for 30-day runs.

“The core insight driving this work is that modern software engineering is bottlenecked not by intelligence but by human attention”summary, stated