Writing

How to Manage Multiple AI Agents Without Losing Track

By Scott Wilder · October 19, 2026 · 6 min read · All writing

Give every task one owner, keep one shared task file, and cap the number of agents at what you can review in one sitting. Do that and you can say who did what, on which branch, with what result. This post gives you the task line, the log line, the handoff note and a 10-minute weekly check to copy.

Losing track starts when two agents touch the same thing

Launching agents is cheap. Knowing what each one did is the hard part. Verdent's guide to assigning tasks to multiple coding agents puts it plainly: the key is coordination, not just launching more agents. Break the goal into small independent items, give each a clear owner, say which files each agent must avoid, and define a success condition and a test.

The failure that hurts most is quiet. When agents run against the same project folder, one can overwrite a file the other just wrote, and nothing throws an error. You just lose work.

One owner per task, one writer per file

Use these two rules before anything else:

  1. Every task has exactly one owner. Other agents can read and send updates, but they do not write.
  2. Every file or folder has exactly one writer. Count the writers per file in your task file. Any file with two or more is a conflict. Fix it before you run anything.

This matches how project teams assign work: one primary assignee per task, with collaborators who stay informed.

When a task could belong to two agents, split it until each piece has one owner. When two tasks depend on each other, do not run them side by side. Run the independent ones in parallel and hold the rest.

Copy this task line into one shared file

Keep one plain text file in the project. One line per task. If a field is blank, the task does not start.

Task: [what]. Owner: [one agent]. Branch and folder: [name]. May write: [folder]. Avoid: [folders]. Done when: [check]. Verify by: [test or review step]. Status: [todo / running / review / merged / stuck].

The "Done when" and "Verify by" fields do the most work. A task with no test is not ready to hand to an agent, because you cannot tell finished from stopped.

The "review" status is the one most people skip. It shows what is waiting on you, and that queue is your real limit.

Cap your agents at what you can review in one sitting

Your review time is the ceiling, not your laptop. Every parallel agent produces a branch you have to read, test and merge. Superset's guide says that is the practical limit, and suggests 3 or 4 parallel sessions before review and merge become the bottleneck. Open WebUI's docs advise starting with 2 or 3, and warn that scaling to 10 before you can review at speed builds a backlog that slows everything down.

Replace those guesses with your own number:

Example: say you merged 3 branches last Saturday. Your cap is 3. You have 4 branches in "review" on Tuesday night. Start no new task until that drops to 3 or fewer.

Write the cap at the top of the task file. You will ignore it on a busy night unless it is in front of you.

Give each agent its own copy of the project

Separate copies stop overwrites while the agents work. The standard tool is a git worktree, and the pattern is one worktree per task, one workspace per worktree, one agent per workspace. Each agent gets an isolated working copy of the repository.

Try this on a copy of a test project first:

  1. Make a copy for the task, on its own branch: git worktree add ../app-task-12 -b task-12
  2. Start one agent in that folder only.
  3. When it says it is done, read the changes: git diff main...task-12
  4. Run the test from the task line.
  5. Merge that one branch, then remove the copy: git worktree remove ../app-task-12

Isolation does not fix overlap. If two tasks change the same file, each agent works in peace and the clash shows up when you merge. So keep tasks that touch the same files out of the same batch.

Merge one branch at a time. If you merge three at once and something breaks, you cannot tell which one did it.

Write the handoff down before the next agent starts

Most lost work happens at the handoff, where one agent passes work or context to another. Codewave calls the handoff the place where multi-agent AI most often breaks. A bad handoff does not produce an error. It produces a confident, wrong answer.

When one agent's output feeds another, paste this into the log before the next agent starts:

From: [agent]. To: [agent]. Task: [id]. Finished: [list]. Verified: [list]. Not verified: [list]. Files touched: [paths]. Next step: [one line].

Then run the handoff test: if the next agent only saw this note, could it do the job? If not, the note is too thin.

The "Not verified" line matters. Without it, the next agent treats a guess as a fact.

Log every action, including the ones that look fine

An error log is not enough. Wrong but plausible output never shows up as an error, so it ships. An incomplete audit trail leaves no record of which agent decided what, which is why you cannot trace a bad result back.

Append one line per action. Never edit old lines.

[date time] [agent] [task id] [action] [input passed: file or note] [result: done / failed / unknown] [side effect confirmed: yes / no / not applicable]

The last field is for anything that sends, writes, publishes, deletes or charges. "Not done yet" and "done, but the confirmation got lost" have to look different. If they look the same, the next run repeats the action or skips it.

Keep humans on those side-effect steps. I wrote up which five tasks to keep a human on separately. Also read the log for odd lines, because strange instructions in an agent's input can be prompt injection.

Run this 10-minute check once a week

Put it on the calendar. Reading the log only when something breaks means you find the problem after it has spread.

  1. Open the log. Read only the lines marked failed or unknown.
  2. For each unknown, check by hand whether the action happened. Add a line that settles it.
  3. Pick 3 finished tasks at random. Trace each to its owner, its input and a confirmed result.
  4. Anything you cannot trace goes back in the task file as a new task with one owner.
  5. Count it: untraceable tasks divided by finished tasks is your lost-track rate. Pick your own limit. A simple one: any untraceable task gets re-run.

None of this has measured results behind it. The numbers 2, 3 and 4 come from other people's guides, and the cap, the backlog rule and the weekly check are templates to try for two weeks. Keep what works, cut what you ignore.

If you run more than one app, the same file can cover all of them. I describe the bigger picture in how I run a portfolio of small apps with a team of agents. If you have not set up an agent safely yet, start with the Claude Code setup for non-developers.

Do this in the next ten minutes

Open a blank text file. Paste the task line once for each thing your agents are working on right now. Fill in every field. Wherever two tasks list the same file under "May write", fix it before the next run. Then write your cap at the top.

Stuck on a task you want automated?

If there is a manual job eating your hours and you are not sure how to hand it to an agent, tell me what it is. Email me the task, and I will tell you how I would set it up. Reading these guides costs nothing.

Questions

How many AI agents can I run at once?

Start with 2 or 3. Published guides suggest 3 or 4 parallel sessions is where review and merge become the bottleneck. Your real number is how many finished tasks you can read, test and merge in one sitting.

Do I need git worktrees to run agents in parallel?

No, but you need some way to keep each agent in its own copy of the project. A worktree per task is the common way, because it stops one agent overwriting another's files while they work.

How do I know what each AI agent actually did?

Append one line per action to a log: time, agent, task, input, result and whether any side effect was confirmed. Read the failed and unknown lines first, and trace three finished tasks by hand each week.

Why does the output look right but turn out wrong?

Usually a thin handoff. When one agent passes work on without saying what was verified and what was not, the next agent can fill the gap with a detail that looks right. A short handoff note fixes most of it.

Who should merge the work from several agents?

You, or one designated orchestrator, one branch at a time. Never let agents merge into each other, and never merge several branches at once, because you cannot tell which one broke things.

How do I stop an agent repeating an action that already happened?

Record in the log whether each side-effect step finished. Mark 'not done yet' and 'done, confirmation lost' differently, and check the unknown lines by hand before the next run.