What's the best way to run a software team where everyone uses AI agents?
By Soumen Sarkar · October 2026
Short answer: Run it so nothing waits on a person: every agent starts knowing what's changing around it, states its assumptions instead of stopping to ask, and leaves its work explained when it stops. Your job as a lead becomes keeping context moving, not handing out permission.
Why is waiting the thing to design out?
When each person runs several agents, the team's output is no longer limited by typing. It's limited by how often work stops for someone. An agent that pauses to ask a question waits for a human, and that human may be in a meeting, asleep or deep in their own sessions. Meanwhile dozens of other changes land. So the first rule is that the work keeps moving, and the context moves with it.
What are the habits that make it work?
Four habits cover most of it, and none of them needs a new meeting.
- Context before code. Before an agent edits a part of the codebase, it should know what's changing there now, what was decided and what was tried and dropped. Without that, parallel agents build in different directions.
- Say what you're building. Each piece of work in progress carries a one-line goal and a plan, visible to the team, so others build on it instead of around it.
- Assume, don't ask. When an agent hits an unknown, it states an assumption in one sentence and keeps going. Whoever knows better corrects it later, and the agent changes course.
- Leave the work explained. Every time a session stops, it leaves a handoff, and every change carries its reasons for the reviewer.
Put these in the agent instructions everyone shares. The team agent instructions template is a starting point.
What does a lead actually do differently?
A lead stops being the person everyone waits for and becomes the person who settles calls quickly. Instead of answering questions as they arrive, you look through the assumptions your team's agents made and confirm or correct the ones in your areas. Instead of checking status, you read what landed and what's still open.
Take a hypothetical four-person team running twelve agents between them. One agent, working in Search · lib/search, assumes that results should hide archived projects. It doesn't stop to ask. The lead sees the assumption mid-morning, knows that archived projects should still appear for admins, and corrects it in a sentence. The agent picks that up at its next turn and adjusts. The fix is small because it was caught early, and nobody sat idle in between.
How do you know it's working?
Count the things that slow a team at this pace: waiting time (how long work sits on a person), rework (work done twice), and pick-up time (how long a handoff sits before someone continues it). If a practice doesn't move one of those, drop it. The playbook for leading a team of agent runners goes further.
Where does Campfyrr fit?
Campfyrr makes the four habits automatic in Claude Code: a brief at the start of each session, an area brief the first time an agent touches a folder, assumptions routed to whoever is best placed to settle them, and handoffs written when a session stops. Codex, Cursor and other MCP clients call the same tools by following the server's instructions.
Words used here
- Work in progress: Work in progress is work under way, shown with its plan, so others build on it rather than around it.
- Assumption: An assumption is the best available answer to an unknown, stated and acted on, kept visible so anyone can correct it.
- Handoff: A handoff is what unfinished work carries for whoever continues it: what's done, what's left, the next step, and what to watch out for.
- Waiting time: Waiting time is the time work spends stopped for a person: from the moment a question, assumption or handoff needs someone until they act on it.
The principle behind this: Keep moving: The work never waits, and neither do we.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).