What is an agent swarm for engineering?

An agent swarm for engineering is a group of coding agents working on one goal at the same time, each on its own piece, while an orchestrator splits the work, tracks it and collects the results. It pays off on work that divides into independent changes, like a feature that spans a database, an API and a web app. People still decide what merges, and changes to the same files still land one after another.
How a swarm differs from a single agent
A single agent works through a task in order, in one context window, on one checkout. For most bug fixes and contained features, that's the right tool. It slows down when a task has several independent parts: the agent does them one at a time, and by the fourth part its context is still full of what it read for the first.
A swarm hands those parts to separate agents. Four things make it a swarm rather than a few agents that happen to run at once:
- An orchestrator holds the goal. It splits the work, starts an agent for each piece, and decides what runs now and what waits.
- Workers each take one piece. A worker starts from a written brief, not from the orchestrator's conversation, so the brief has to name the files, the constraints and the check that proves the piece is done.
- Isolation keeps writers apart. Every worker that edits code gets its own checkout, so one agent's half-finished change never lands in another agent's commit.
- Reports close the loop. Workers report when they finish or get stuck, and the orchestrator passes on only the questions a person has to answer.
Remove the orchestrator and a person splits and tracks the work by hand. Remove isolation and the agents overwrite each other in one working tree. Remove the reports and nobody knows which piece is done.
When a swarm helps
A swarm pays off when the pieces touch different files and each one can be tested alone. A feature across a database, an API and a web app fits, and so does a batch of unrelated bug fixes or one change repeated across 30 packages. The pieces run at the same time, and each comes back as a pull request small enough to review in one sitting.
It doesn't help when every change hits the same few files, when each step depends on what the last one found (a hard debugging session is the usual case), or when nothing tells a worker its piece is finished. One agent working in order finishes those sooner than a swarm that spends its time on merge conflicts.
A worked example: an audit log in four pieces
The goal. Add an audit log to an internal admin app. It records every change to organization settings and membership, shows the log to admins, and is documented. The repository has a database package, an API package, a web app and a docs folder, each with its own tests.
The split. The orchestrator reads the repository and finds four pieces with one dependency between them:
- Schema and write API. The
audit_logtable, its migration and a function that writes an entry. Everything else uses it, so it goes first. - Record the changes. Calls to the write function from the settings and membership endpoints. It needs piece 1, so it starts from piece 1's branch.
- Admin page. A list of entries with filters. It reads piece 1's table, so it also starts from that branch, but it only touches the web app, so it runs beside piece 2.
- Docs. What gets recorded and who can see it. It only touches the docs folder, so it starts right away.
The run. Pieces 1 and 4 start together, each on its own machine. Once piece 1's pull request is open and green, the orchestrator starts pieces 2 and 3 from its branch. Each worker runs its package's tests, opens a pull request and reports back with the link.
The decisions. Two questions go to a person instead of being guessed: approve the migration before it merges, and keep 90 days of history or a year. A failing test in piece 2 or a review comment on piece 3 stays with the worker that owns it.
The result. Four pull requests, merged in order: piece 1, then pieces 2 and 3, with the docs whenever they're ready. The work takes as long as its longest chain, piece 1 then piece 2, rather than the sum of all four.
What kept it bounded was a fixed goal, four pieces with one dependency, a test command for every package, and a person who owned the merges. Without the tests, nobody could tell a finished piece from a plausible one.
Where Capy fits
Capy is a platform that orchestrates agent swarms, and each part above has a counterpart in it:
- A Captain is the orchestrator. It's a long-lived agent that starts threads for the work, reads their reports, keeps its plan and rules in its own Drive, and tracks every open decision as an issue assigned to the person who owns it. How to work through a bug backlog with coding agents sets one up step by step.
- Each worker is a thread in the Captain's crew, with its own conversation, machine and pull requests. A thread can split its piece further with subagents.
- Every cloud thread runs on its own isolated Linux VM with your repositories cloned, so writers never share a working tree.
- The thread that opens a pull request follows its CI and review feedback and resolves conflicts with the base. With automatic review on, the review agent checks every diff at the pull request's exact head.
- Crew threads can use different models, including subscriptions and API keys you connect.
- Capy never merges a pull request unless you ask for that merge.
And where it doesn't:
- It doesn't make tightly coupled work parallel. Pieces that edit the same files still run in order, and the subagents guide says to stack them when in doubt.
- It doesn't remove review. A swarm opens more pull requests, and someone still decides which ones merge.
- It works with repositories on GitHub.com. GitHub Enterprise Server and other git hosts aren't supported.
- Cloud machines use machine time in Capy credits, even when the model runs on your own subscription, and your plan's limits set how many machines run at once.
Follow-up questions
How many agents should a swarm run at once?
One per independent piece. The audit log needs four agents, not ten, and adding workers to a piece that can't be split only adds merge conflicts. When the work does split wide, a Capy thread runs 8 subagents at once by default and can be raised to 100, and a Captain runs many threads.
Is an agent swarm the same as multi-agent orchestration?
Orchestration is the coordinating work: splitting, sequencing, isolating and reviewing. The swarm is the group of agents being coordinated. Multi-agent orchestration for a refactor walks through that work for one change.
Does every agent need the same model?
No. A mechanical piece can run on a cheaper model and a hard one on a stronger model. In Capy, each subagent and each crew thread can run its own model.
What should a person give the orchestrator up front?
The goal, the pieces you already know about, how to test each piece, and the decisions it should bring back rather than make. A Captain takes this as its first message and saves it as rules.




