How to manage multiple AI agents

Updated Oct 10, 2026·7 min read

The short answer

To manage multiple AI agents, give them one list of work, one plan per job and one holder per job. Write the project down once so every agent starts from the same place, have agents hand over with short notes when they stop, and let only the real decisions reach you: scope, customers, or a choice between options.

Why several agents get messy

One agent is a helper. Two or three is a small team, and a team needs what every team needs: someone deciding what comes next, a shared picture of the project, and a clean way to pass work along.

Without that, the same things go wrong for almost everyone who runs Claude Code, Cursor, Codex and Grok side by side:

Two agents do the same job. Nobody said who had it, so both started.
One agent undoes another. They worked on the same files at the same time.
Every new session starts from zero. You explain the project again, and again.
You become the router. Every question comes to you, so you spend the day answering instead of deciding.

None of this is a model problem. It is a management problem, and it has a small set of fixes.

1. Keep one list of work

Put every job in one ranked list: what customers asked for, what you want to build, and what your agents found while they worked. One row is one problem.

When an agent finishes, it takes the next row from the list instead of asking you what to do. When something new comes up, it goes on the list instead of into a chat you will never find again.

2. Write one plan per job

Each job gets a short plan that any agent can pick up cold. It doesn't need to be long. It needs to answer four things:

The problem. What the person experiences, in a sentence or two.
What to build. The outcome first, then the direction.
Files to touch. The parts of the code this job changes, checked against your repo.
Done When. A few lines that say what must be true when the job is finished, each one checkable on its own.

This is a spec. You can write it, your agent can write it, or you can ask a tool to draft it for you. What matters is that every agent reads the same one.

3. Give each job one holder

One agent holds a job at a time. It claims the job before it starts, and the list shows who has it. Another agent that picks up the list skips anything already held.

For coding agents working in the same repo, give each one its own branch, and its own working copy (a git worktree) when they run at the same time. Most "agents overwrote each other" stories are two agents in one folder.

4. Write the project down once

Keep one short file at the root of the repo that says what the project is for, how it's built and the rules every agent follows. CLAUDE.md and AGENTS.md are the common names. Claude Code, Cursor, Codex and Grok can all be pointed at it.

Keep it short and stable: what the product does, who it's for, how to run it, and the few rules that never change. Things that change every week belong in the plan for the job, not in this file. Your agents don't share a brain, so the file is how they share a starting point.

5. Hand over with notes, not a transcript

When an agent stops before the job is done, it leaves a short note on the job:

what it did
what it tried that didn't work, and why
the exact next step

The next agent reads the note and the plan, not the whole conversation. A good handoff note is five lines. A pasted transcript is five hundred, and the useful part is buried in it.

6. Let only the real decisions reach you

Most questions an agent asks, it can settle itself: naming, small layout calls, which test to add. Tell your agents to settle those and carry on.

A question should come to you only when it changes what's in or out, touches customers, money or data that can't come back, goes against a rule you set, or is a real choice between options. When it does, ask for it in three lines: the topic, the question, and the options with the one the agent would pick. You should be able to answer in one line.

Then save the answer as a rule, so the next agent reads it before asking the same thing. This is the human in the loop part, kept small.

7. Check it's done, not just merged

Before an agent says a job is shipped, it checks each Done When line against the live product and records how it checked: a test, a URL, a thread. A line it couldn't check stays unchecked, and it says so.

Merged is not deployed, and deployed is not checked. A short checklist with a receipt per line is how you know the difference without reading the code. See definition of done for how to write those lines.

How many agents can one person manage?

There isn't a fixed number. The limit is how many decisions reach you, not how many agents are running. If every agent asks you everything, two is too many. If the list, the plans and the rules carry most of the work, one person can direct several agents and still spend most of the day on the business.

A good sign you've hit the limit: you spend more time answering agents than choosing what to build next. Fix the questions first (step 6), then add agents.

Copy this

Paste this into the plan for a job, or keep it as a template your agents fill in.

A job plan your agents can fill in

# Job: <one-line title, what becomes true>

## Problem
<what the person experiences, 1-2 sentences>

## What to build
<the outcome first, then the direction>

## Files to touch
- <path> (new|modify)

## Done When
- Given <a state>, when <an act>, then <something you can check>.
- Given <a state>, when <an act>, then <something you can check>.

## Holder
<agent and session that has this job>

## Handoff note (fill in if you stop)
- Did:
- Tried and dropped (why):
- Next step:

## Ask me only if
- it changes what's in or out
- it touches customers, money or data that can't come back
- it goes against a rule in this repo
- it's a real choice between options (give me A/B and your pick)

Where Annsa fits

You can do all of this with a shared doc, a board and a few files. Annsa keeps it in one place, and Claude Code, Cursor, Codex and Grok read it over MCP. Step by step:

Your one list of work is Priorities. It ranks what your customers asked for, your roadmap, your ideas and what your agents found, with the reason for each row. Working with priorities
The plan for each job is the spec on its priority: Problem, Evidence and direction, What to build, Files to touch and Done When. You write it, your agent writes it over MCP, or Ask writes it when you ask. Writing a spec
An agent claims a priority before it starts, and the board shows who has it. How the work flows
Your principles and direction reach every agent when it connects, along with Annsa's skills for working with you. Working with Annsa
An agent that stops hands over with what it did, what it tried and the next step, on the priority itself. Claim, hand off and ship
Questions that need you land in Needs You, three lines each, and an answer saved as a principle isn't asked again. Needs You
Every Done When line gets a receipt showing how it was checked. Shipping and receipts

See how it fits together in Direct your agents.

Questions people ask.

How do you manage multiple AI agents?

Give them one list of work, one plan per job and one holder per job. Write the project down once in a file every agent reads, have each agent hand over with a short note when it stops, and let only scope, customer and real either-or decisions reach you.

How many AI agents can one person realistically manage?

There isn't a fixed number. The limit is how many decisions reach you, not how many agents are running. When the list, the plans and your saved rules carry most of the work, one person can direct several agents and still spend most of the day on the business.

What should you do when agents keep asking for clarification or permission?

Tell them which questions they can settle themselves, and ask only about scope, customers, money or data that can't come back, a rule you set, or a real choice between options. Ask for those in three lines with a recommendation, and save each answer as a rule so the question isn't asked again.

How do I manage multiple AI agents without losing track of what each is doing?

Make every agent claim a job from one shared list before it starts, so the list shows who holds what. When an agent stops, it leaves a note on the job: what it did, what it tried and dropped, and the next step.

How do you stop multiple Claude Code agents overwriting each other's work?

Give each agent one job, its own branch and, when they run at the same time, its own working copy of the repo (a git worktree). Most collisions are two agents editing the same files in the same folder.

How do I run multiple coding agents at once?

Start each one on a different job from your list, in its own branch and working copy, with the same project file and a plan for its job. Check each job against its Done When lines before you merge.

Get your agents in a row.

Try Annsa