Starting four coding agents is the easy part. Then the first one asks to run the tests, the second has a question about the cache, the third says it's done, and the fourth has been waiting on you for ten minutes in a tab you haven't looked at. Run agents in parallel without a plan for your own attention, and it mostly means waiting in parallel.
You are the one part of the setup that doesn't scale, so the work is in asking less of yourself. Here's what does that, in plain tools first, then the same thing in a desktop app.
Where the waiting comes from
Four things, roughly in order of how much time they cost:
- Routine permission prompts. The agent asks to run the test suite for the twentieth time.
- Questions the brief should have answered. Which cache? Which branch? Keep the old API?
- "Done" you can't trust. It says it's finished, and you have to read everything to know.
- Not knowing who's waiting. An agent stopped for you, and nothing told you.
1. Answer the routine asks once
Every agent CLI lets you decide what it may run without asking: allow rules, an approval mode, or a permission mode per session. Use them for the commands you'd approve every time anyway, like the test runner, the linter and the type checker, and keep everything else asking.
-
Allow the boring, repeatable commands:
npm test,yarn lint,cargo check, a formatter. - Keep asking for anything you can't undo: pushing, deploying, deleting, publishing, anything that reads a secret or calls a paid API.
- Prefer a rule for this session over a saved one while you're unsure. A rule saved in the project outlives the task, and you'll forget it's there.
Each allowed command is one fewer interruption, and across four agents in a day that adds up to hours.
2. Write the brief so the agent doesn't have to ask
Most questions an agent asks are decisions the brief left open. A few lines up front save a round trip later:
Goal: rate-limit POST /quotes to 60 requests a minute per customer.
Files: src/quotes/routes.ts, a new src/quotes/limit.ts, their tests.
Decided: in-memory token bucket, keyed by the x-customer-key header. No Redis.
Done means: yarn test src/quotes passes and yarn typecheck is clean.
If something is unclear: pick the simpler option, say which in your summary, and go on.
That last line matters most. "Pick the simpler option and tell me" turns a blocking question into a note you read later.
3. Make "done" something you can check
"Done" from an agent is a claim. Make it a claim you can check in a minute:
- Put the check in the brief. Name the command that must pass, and ask the agent to run it before it says it's finished.
-
Ask for a short handback: the branch, its head commit,
git diff --statagainst the base, what it changed, and the commands it ran with their results. - Read the stat before the diff. Twelve files changed when you expected two tells you where to look before you read a line.
A handback that points at a commit is reproducible. You review exactly what the agent checked, not whatever is in its folder at that moment.
4. One queue for everything waiting on you
Don't react to each agent as it pings. Work through them in rounds, in the order that unblocks the most work:
- Blocked agents first. A question or a permission prompt is usually seconds to answer, and the agent is idle until you do.
- Finished ones next. Check the handback, then review, merge or send it back.
- Running ones last. Leave them alone unless something looks wrong.
For that you need one place that shows which agents are waiting and why, and a notification when one stops for you. With terminals, that means a notification hook per agent and a habit of checking every tab. Without it, an agent that stopped for you can sit idle all afternoon.
5. Keep each agent out of the others' way
Interruptions also come from agents colliding: two of them editing the same file, or one's test run picking up the other's half-finished change. Give each task its own git worktree and branch, and those collisions stop, along with the questions about them.
Doing this in Moontors
I build Moontors, a free desktop app for running Claude Code, Codex, Gemini CLI and Grok Build side by side, so take this part as the maker's view. It's built around that queue:
- One count in the header for every session waiting on you, for an answer to a question, a plan to approve or a permission. Click it to go to the next one. (The header)
- Each card shows why. A waiting session's card shows the question or plan it's asking, so you can see what it needs before you open it. (Questions and plans)
- Done stays blue until you've looked, and a pill in the header counts the finished sessions you haven't seen yet. Click it for the next one. (Done and notifications)
- Notifications on your computer when a session starts waiting for you, hits an error or finishes.
- A permission mode per session, from Manual to Bypass, and Allow for this session, which adds a rule for that session only. You can remove it in Configuration. (Permission modes)
- Answer from your phone. The phone app pairs with your computer to follow your sessions and answer their questions and permissions.
Whatever you run them in, the rule is the same: let the agents work in parallel, and keep yourself to one queue.
AI did the writing, I did the reading, and we both took credit.
Top comments (5)
We collect status updates and questions in one room, so the manager can see who reports being blocked. With the session open and listening, each Claude Code or Codex agent wakes on a message addressed to it (a mention, a card). Waiting doesn't run the model, though the plugin-based agents take a short turn about every 29 min, which uses tokens. Most questions go to a manager agent instead of the human; what only a person can decide comes as one decision per message, with options. Last night our founder went to bed and said "skip what needs me", and the manager planned to continue the tasks that didn't need him. The room is agent-chat, which we build. Do you see the agents' questions in one queue, or per session?
Both. Each question stays in its own session: its card on the board shows it's waiting and what it's asking, and you answer right in its transcript. On top of that, the header counts the sessions waiting for you, and clicking the count takes you to the next one, so it works as one queue without merging everything into one room. A desktop notification comes up when a session needs you, too.
Our own team works a lot like yours: the developers' sessions report to a tech-lead session, which answers most of their questions and holds what only I can decide, like a deploy, until I'm back. How does your manager tell what only a person can decide: a rule you give it, or its own judgement?
We give it explicit rules: decisions about production, new costs, credentials, permissions and the product go to the founder. The manager handles technical coordination within those rules. When two developer sessions change the same code, does your tech-lead session settle the merge order, or does that come back to you?
The tech-lead session settles it. Each developer session works on its own branch in its own git worktree, and when the tech lead hands out a task it names the files the task should touch, so overlaps show up before anyone starts. A task that builds on another one still open starts from that branch. Every task goes through a reviewer session, then the tech lead squash-merges it into main, one at a time. Two tasks touching the same file usually merge cleanly; if they change the same lines, the conflict goes back to that developer to rebase, and the two developer sessions sort it out between them. What comes back to me is only a priority call, if one task has to wait for the other.
The handback format is a practical control because it replaces “done” with a reviewable artifact. I’d add the base SHA and the exact environment used for checks, then have the coordinator reject stale handbacks automatically if main or the branch head moved. That prevents a human from approving a test result that no longer describes the code being merged.