What is the difference between one agent and many agents?
A single-agent workflow is one AI coding agent session working on one task in one working copy: you prompt, it works, you review, then you start the next task. A multi-agent workflow runs several agent sessions at once, each on its own task and its own workspace, or several attempts at the same task.
Neither is more advanced. They trade different things: one agent trades speed for simplicity, many agents trade attention for throughput. The broader picture is in multi-agent development.
How does sequential work compare to parallel work?
Sequential work finishes tasks one after another; parallel work lets independent tasks overlap, so you wait for the longest one instead of all of them in a row. Review, though, still happens one diff at a time.
| Dimension | One agent | Many agents |
|---|---|---|
| Order of work | One task, then the next | Independent tasks at the same time |
| Waiting | The sum of every task | Closer to the longest task, plus your review time |
| Working copies | One is enough | One per agent, or they overwrite each other's files |
| Review load | One diff at a time, as it arrives | Several diffs arriving close together |
| Usage | One session's usage | Each agent uses its own subscription or API quota |
| Conflicts | None between agents | None while working if isolated; possible at merge time |
| When one attempt goes wrong | Everything behind it waits | The other tasks keep going |
| Best for | Small, coupled or exploratory work | Independent tasks and competing attempts |
What does coordinating many agents cost?
Coordination costs attention, usage and merge work. Parallel agents are not free throughput; each one adds something for you to manage.
- Review time. Every agent produces a diff, and you should read every diff before it merges. This is usually the real bottleneck.
- Usage. Each agent spends from its own vendor's subscription or API key. Three agents on one task means three sessions of usage, not one.
- Merge conflicts. Separate workspaces stop agents from overwriting each other while they work. They do not stop two branches from touching the same lines; you still resolve that at merge time.
- Split context. Each agent only knows what its prompt and its workspace tell it. Vague prompts get multiplied, not fixed.
- Switching. Checking on five sessions costs more than checking on one, unless something tells you which one needs you.
Tallos is built to lower those costs: a separate parallel workspace per task, agent status in the sidebar, diff review with line comments you send back to the agent, and squads with round and member limits plus a run history that shows an estimated cost when the agents report their usage.
When is one agent enough?
One agent is enough when the work is small, tightly coupled or still unclear. Adding agents to those tasks adds coordination without adding progress.
- Small changes that finish before you would have set up a second task.
- Coupled steps where each change depends on the previous one: a migration, then the code that uses it, then the tests.
- Exploration: asking an agent to explain code, trace a bug or sketch options.
- Limited review time: if you can only read one diff carefully today, run one agent.
- Tight usage budget: one session spends less than several.
What patterns work for running many agents?
Four patterns cover most multi-agent work: independent tasks, best-of-N, build + review, and a leader that divides the work. The last three are templates for squads in Tallos.
| Pattern | How it works | Good for | In Tallos |
|---|---|---|---|
| Independent tasks | Different tasks, one agent and one workspace each | A backlog of unrelated fixes and chores | One workspace per task, any agent per workspace |
| Best-of-N | The same objective given to several agents; keep the best result | Hard problems with no obvious approach | Squad template "3 attempts, pick the best" |
| Build + review | One agent builds, another reviews; they loop until the reviewer approves | Changes that need a second pair of eyes | Squad template "Build + review" |
| Leader divides | A leader splits the objective, workers take parts, the leader combines them | Features that span API, UI and tests | Squad template "Leader divides the work" |
Best-of-N turns disagreement into a signal: where attempts agree, the approach is probably sound; where they differ, you have found the hard part. See the best-of-three squad. Build + review puts a reviewer in the loop before you ever see the diff; see build and review. Leader divides fits larger features, as in ship a feature.
Start with two agents on two independent tasks. Scale up from there.
How do I go from one agent to many?
Add agents one at a time and let your review capacity set the pace.
- 1
Pick two independent tasks
Choose tasks that touch different parts of the code, so their branches are unlikely to conflict.
- 2
Give each its own workspace
In Tallos, each task gets its own git worktree and branch, so the agents never share files.
- 3
Write self-contained prompts
State the goal, the files involved and how to check the result, including which tests to run.
- 4
Review before you add more
Read both diffs, send line comments back, merge. If review felt rushed, stay at two.
- 5
Try best-of-N on a hard task
Run a squad with three attempts and let the leader recommend one. You still accept or discard.
- 6
Set limits
Squads default to 5 rounds and 4 members working at once; raise them only when a task needs it.
A guided walkthrough is in your first squad, and the full playbook is in how to run AI agents in parallel.
Frequently asked questions
Is running many AI agents faster than running one?
For independent tasks, usually yes in wall-clock time, because the work overlaps. For coupled tasks it often is not, and review time does not shrink, so the real gain depends on your tasks and how fast you review.
Does running more agents cost more?
Yes. Each agent spends from its own subscription or API key, so several agents use more than one. Tallos uses the accounts you already have and does not resell model access; squad limits and the run history's estimated cost help you keep spend visible.
Will parallel agents overwrite each other's changes?
Not if each one has its own working copy. Tallos gives every task a separate git worktree on its own branch; conflicts can still appear later, when you merge branches that touched the same lines.
How many agents should I run at once?
As many as you can review properly. Start with two, and add more only when reviewing their diffs still feels careful rather than rushed.
What is best-of-N?
Best-of-N gives the same objective to several agents working independently, then compares the results and keeps the best one. In Tallos it is the squad template "3 attempts, pick the best".
Can different agents work on the same project together?
Yes. Each squad member can use a different agent and model, so Claude Code can build while Codex reviews, or Claude Code, Codex and Gemini CLI can each take one attempt.
What are the limits on a squad?
By default a squad runs up to 5 rounds with up to 4 members working at once. You can raise that to a maximum of 20 rounds and 12 members.
