---
schema: "swft.publication/v1"
id: "agent-swarm-explainer"
title: "What is an agent swarm?"
description: "An agent swarm coordinates multiple coding agents toward shared work through a task graph, orchestration, and named human checkpoints — distinct from a single agent or an uncoordinated fleet."
summary: "An agent swarm coordinates several coding agents toward shared work: a task system breaks work into items, an orchestrator assigns them, checks judge the results, and people keep the named decisions. A single agent runs a line; a fleet runs separate jobs; a swarm coordinates dependencies between workers."
canonical: "https://swft.io/what-is-an-agent-swarm"
author: "SWFT Editorial"
author_type: "Organization"
published: "2026-09-23"
modified: "2026-09-23"
kind: "explainer"
section: "Guides"
tags: ["agent swarm", "multi-agent coding", "agent orchestration", "agent fleet", "software factory"]
evidence_labels: ["INFERENCE", "OBS", "SELF-REPORT", "STUDY"]
source_ids: ["google-agent-behavior-taxonomy", "latent-space-notion-token-town", "openai-symphony", "openai-symphony-blog", "steve-yegge-gas-city", "steve-yegge-gas-town", "steve-yegge-shape-things-to-come", "stripe-minions-part-one", "stripe-minions-scale-update"]
authorship_disclosure: "AI-drafted from the cited public sources and independently checked by a second AI editorial-review agent (Codex) for source fit, claim boundaries, overlap, and reader utility. SWFT Editorial is responsible for corrections."
---

# What is an agent swarm?

How coordinated coding agents share work: the task graph, the orchestrator, the checks, and the human decisions that stay.

> **Authorship:** AI-drafted from the cited public sources and independently checked by a second AI editorial-review agent (Codex) for source fit, claim boundaries, overlap, and reader utility. SWFT Editorial is responsible for corrections.

## Quick answer

An agent swarm coordinates several coding agents toward shared work: a task system breaks work into items, an orchestrator assigns them, checks judge the results, and people keep the named decisions. A single agent runs a line; a fleet runs separate jobs; a swarm coordinates dependencies between workers.

An **agent swarm** coordinates several coding agents toward shared work. The phrase gets used loosely, so the useful line is coordination. One agent finishing a task is a worker. Many agents doing separate jobs are a fleet. A swarm adds a shared task system: work is broken into items, dependencies are tracked, and results are checked before they join the product.

A request enters as a work item — a bug, a migration slice, a feature with a definition of done. An orchestrator assigns items to workers, records what each worker changed, and routes failures back into the queue. Review and release stay named human or policy decisions.

## What a swarm adds beyond one agent

**A shared work record.** [Steve Yegge's Gas Town](https://yegge.ai/essays/welcome-to-gas-town/) and its successor [Gas City](https://yegge.ai/essays/welcome-to-gas-city/) are first-party experiments in exactly this: persistent work items, dependency graphs, and named worker roles that live outside any single agent session. Yegge is unusually candid about the costs — he reports that Gas Town failed under a later model and that these systems still need a person steering them. The mechanism is what matters, not the project names.

**Orchestration.** [OpenAI's Symphony spec](https://openai.com/index/open-source-codex-orchestration-symphony/) turns a Linear board into a state machine: each task becomes an isolated agent run with proof-of-work requirements and a protected landing path. The [Symphony repository](https://github.com/openai/symphony) is the inspectable version of that design.

**Backpressure and review at volume.** [Stripe's Minions](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) run inside scoped context with internal checks, and every result still passes human review. In August 2026, Stripe president Will Gaybrick reported roughly [7,000 pull requests from Minions in one week](https://www.youtube.com/watch?v=P5iICDVn5gc) — about 30 percent of that week's pull requests — a first-party figure, not an independent count.

## Swarm, fleet, or one worker?

The distinction is what happens between workers, not how many exist.

- **One agent** can run a repeatable line: brief in, checked change out.
- **A fleet** is many agents doing separate jobs. Shared infrastructure helps, but no worker waits on another's result.
- **A swarm** adds coordination: a task graph, handoffs, and merge order matter. The hard parts are the seams — who reviews a worker's output, what happens when two workers touch the same file, and where a rejected result goes.

A [Google Research taxonomy](https://research.google/pubs/towards-ai-as-a-collaborative-partner-a-taxonomy-of-ai-agent-behavior-in-software-engineering/) of agent behavior in software engineering underlines the same point from the worker side: as agents take collaborative roles, the organization has to specify behavior expectations that used to live in team habits.

## Where the human decisions sit

Documented swarms keep people at named gates rather than "in the loop" generally: product choices and task acceptance, permissions, review of agent work, merge and release authority, and the decision to widen or shrink the swarm's scope. [Notion's Token Town account](https://www.latent.space/p/notion) describes the same pattern in its eval and self-verification work: the system earns autonomy task class by task class.

## How to recognize a real swarm

Three tests separate a swarm from a demo of parallel agents. First, repeatability: another work item of the same kind can follow the documented path. Second, an inspectable work record: the team can see what each worker did, what checked it, and why it stopped or shipped. Third, named coordination: dependencies and merge order are explicit somewhere a person can audit, not implicit in one long session.

For the reported scale of these systems — concurrent workers, completed runs, and the limits beside each number — see [Agent scale](/scale). For the system a swarm operates inside, see [What is a software factory?](/what-is-a-software-factory).

## Questions product teams ask

### Is an agent swarm the same as multi-agent?

Multi-agent describes any system with more than one agent. A swarm is the coordinated case: agents share a task system with dependencies, handoffs, and checked results. Many independent agents doing separate jobs are a fleet, not a swarm.

### How many agents make a swarm?

There is no threshold. Two agents coordinating dependent work through a shared task record act as a swarm; hundreds running unrelated jobs do not. The coordination mechanism, not the headcount, is the test.

### Do agent swarms remove human review?

No documented case does. Operator accounts keep people at named gates — task acceptance, permissions, review, and release — while agents do bounded implementation work between those gates.

### Where can I see how large reported swarms are?

SWFT's agent-scale reference collects dated, source-bound figures for concurrent workers, completed runs, and adoption, with the limits beside each number.

## How we know

- **Observed artifact (OBS)** OpenAI published an inspectable orchestration spec that turns a work board into a state machine of isolated agent runs. Sources: [Symphony](https://github.com/openai/symphony); [An open-source spec for Codex orchestration: Symphony](https://openai.com/index/open-source-codex-orchestration-symphony/).
- **First-party report (SELF-REPORT)** Operator accounts describe swarm-scale coordination: Stripe reports thousands of agent-produced pull requests per week with human review; Yegge documents task-graph orchestrators and their failure modes; Notion describes staged autonomy through evals. Sources: [Minions: Stripe's one-shot, end-to-end coding agents](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents); [Tokens Are the New Dollars](https://www.youtube.com/watch?v=P5iICDVn5gc); [Welcome to Gas Town](https://yegge.ai/essays/welcome-to-gas-town/); [Welcome to Gas City](https://yegge.ai/essays/welcome-to-gas-city/); [The Shape of Things to Come](https://yegge.ai/essays/the-shape-of-things-to-come/); [Notion's Token Town](https://www.latent.space/p/notion).
- **Independent study (STUDY)** Research on coding-agent collaboration derives behavior expectations agents and their organizations must make explicit. Sources: [Towards AI as a Collaborative Partner: A Taxonomy of AI Agent Behavior in Software Engineering](https://research.google/pubs/towards-ai-as-a-collaborative-partner-a-taxonomy-of-ai-agent-behavior-in-software-engineering/).
- **Analysis (INFERENCE)** SWFT's boundary — coordination of shared work, not worker count, distinguishes a swarm from a fleet — reconciles the loose usage across operator accounts. Sources: [Welcome to Gas Town](https://yegge.ai/essays/welcome-to-gas-town/); [An open-source spec for Codex orchestration: Symphony](https://openai.com/index/open-source-codex-orchestration-symphony/); [Minions: Stripe's one-shot, end-to-end coding agents](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents).

## Sources

- **Independent study (STUDY)** [Towards AI as a Collaborative Partner: A Taxonomy of AI Agent Behavior in Software Engineering](https://research.google/pubs/towards-ai-as-a-collaborative-partner-a-taxonomy-of-ai-agent-behavior-in-software-engineering/) — Google Research; accessed 2026-08-31. Research deriving enterprise expectations for coding-agent behavior from developer rules and interviews.
- **First-party report (SELF-REPORT)** [Notion's Token Town](https://www.latent.space/p/notion) — Latent Space; accessed 2026-09-01. An operator interview about regression, launch, and headroom evals, self-verification, agent skills, and the changing boundary between product and engineering work.
- **Observed artifact (OBS)** [Symphony](https://github.com/openai/symphony) — OpenAI; accessed 2026-08-31. Open-source engineering preview for turning project work into isolated agent implementation runs with proof of work and protected landing.
- **First-party report (SELF-REPORT)** [An open-source spec for Codex orchestration: Symphony](https://openai.com/index/open-source-codex-orchestration-symphony/) — OpenAI; published 2026-04-27; accessed 2026-09-01. OpenAI's account of turning a Linear board into a state machine and control plane for continuous isolated agent work, task dependencies, retries, and human review.
- **First-party report (SELF-REPORT)** [Welcome to Gas City](https://yegge.ai/essays/welcome-to-gas-city/) — Steve Yegge; published 2026-04-24; accessed 2026-09-01. Yegge's first-party account of Gas City, built by Julian Knutsen and Chris Sells, replacing Gas Town's fixed topology with composable agent packs, a supervisor plane, durable work data, observability, and external sandbox integrations.
- **First-party report (SELF-REPORT)** [Welcome to Gas Town](https://yegge.ai/essays/welcome-to-gas-town/) — Steve Yegge; published 2026-01-01; accessed 2026-09-01. Yegge's launch account for an experimental multi-agent orchestrator built around persistent work records, dependency graphs, named worker roles, durable workflows, merge handling, and human oversight. The post explicitly warns that the system was new, complicated, and not ready for most users.
- **First-party report (SELF-REPORT)** [The Shape of Things to Come](https://yegge.ai/essays/the-shape-of-things-to-come/) — Steve Yegge; accessed 2026-09-01. Yegge's August account says Gas Town failed under a later model, rejects reusable harnesses, and describes Wheelhouse as a bespoke successor with producer, consumer, review, merge, and standing production-agent roles. The operating claims and forecasts remain first-party reports.
- **First-party report (SELF-REPORT)** [Minions: Stripe's one-shot, end-to-end coding agents](https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents) — Stripe Dev Blog; published 2026-02-09; accessed 2026-09-01. Stripe's account of Minions' intake surfaces, prewarmed devboxes, Blueprints, scoped context, internal tools, checks, human review, and early scale.
- **First-party report (SELF-REPORT)** [Tokens Are the New Dollars](https://www.youtube.com/watch?v=P5iICDVn5gc) — Andreessen Horowitz; published 2026-08-17; accessed 2026-09-01. Stripe president Will Gaybrick reports that roughly 7,000 PRs came from Minions in the preceding week, about 30 percent of that week's PRs; he does not say all were merged.

## Read next

- [Agent swarm scale: documented runs and adoption](/scale)
- [What is a software factory?](/what-is-a-software-factory)
- [Three visions of the AI software factory](/ideas/three-visions-of-the-ai-software-factory)