acribayik synapsis / bosuncadre

How to run a team of AI agents without losing control

One AI agent is a tool. Several of them working together is a team, and a team needs managing. In our experience, how you organize your models matters as much as which models you pick. Running the same frontier model as a team, with the work divided up properly, has let us take on work that model couldn't handle alone. A badly run team does the opposite: it burns through your budget producing work you can't trust.

This guide has two parts. Part 1 works with any setup: Claude Code, Codex, a local model, a shell script and a folder of text files. Part 2 is about our own product, and we'll say so clearly when we get there.


Part 1: Running the team

1. Give every agent one job

The most common mistake is handing one agent a whole feature: plan it, build it, test it, check it, ship it. Split the work into roles instead: someone plans, someone does the work, someone else reviews it, and someone decides whether it lands.

A narrowly scoped agent takes narrowly scoped actions. It's less likely to wander off doing things you didn't ask for while chasing the bigger goal, and it needs less context, so it's less likely to forget what it was told.

2. Match the model to the work

Models aren't interchangeable, and the expensive one isn't always the right one.

  • Strong models for inventing: planning, breaking down a problem, and reviewing work.
  • Smaller models for carrying out a clear plan. Local models in particular are weak at inventing a solution and surprisingly good at following one.

Two different limits are hiding here. Size is how much work there is, and it can be split: a big job becomes many small ones. Complexity is how hard the hardest piece is, and it can't be split. Every model has a ceiling. No amount of orchestration raises it; good planning keeps each piece under it.

3. The coordinator keeps the work moving, and does nothing else

If one agent manages the others, keep its job small. It shouldn't write the code, and it shouldn't check the code. It holds the plan, hands out work and keeps things moving. That agent has more reach than the rest, so it's the last one you want making changes.

Coordinating is also the hardest job to give an AI. A common failure: it notices something is wrong, notes it, and then does nothing. Say plainly in its instructions that its job is to act, not just to observe.

4. Use a queue

Don't have a person, or an agent, hand tasks to specific workers. Put the work in a queue and let each worker take the next job it can do. A worker that's busy, switched off or out of credits simply doesn't take anything, and nothing breaks.

It doesn't have to be fancy. Our first version, back in July, was a file in the git repo listing the work, plus a cron job that woke each agent up to check it.

5. Structure every handoff

Handoffs are where teams of agents fall apart. Give each stage a strict format for what it passes on: what was done, what was checked, what's left, and anything the next agent must know. Too much freedom in the output is what makes the next agent guess.

6. Write everything down outside the context

An agent forgets whatever isn't saved somewhere it can read. Keep the plan, the decisions and the briefs in files next to the work, not in a long chat. Then any agent can pick up a task cold, and you can clear a context that has filled up with old work without losing anything that mattered.

7. Keep agents out of each other's files

Separate branches keep the code apart, but shared files still collide. Have each agent claim the files it's about to touch before it starts, and have the others check for claims first.

8. The author never approves its own work

An agent reviewing its own work checks what it meant, not what it wrote. Send every result to a different agent, and ideally a stronger model, for review. And make sure the reviewer can actually say no: a reviewer that never rejects anything isn't reviewing.

9. Keep a person at the front and at the gate

The most valuable place for a person isn't reading every diff. It's at the front, deciding what gets built and how, and at the end, deciding what lands. AI can recommend; it shouldn't be the one making those calls.

How much you approve in between is up to you, from every change to only the plan.

10. Track what every task costs

Log the cost of each task, not just your monthly bill. That's how you find out which kinds of work are expensive, which ones a cheaper model handles fine, and where the strong model is actually earning its price.

11. Cap the turns, and tune the cap

Agents get stuck. Give every task a limit on how many turns it can take. Set it too high and stuck runs waste hours; set it too low and agents can't finish real work, especially fixes in an existing codebase, where a lot of reading has to happen before any code changes. Watch where tasks hit the cap and adjust.

The short version

  1. One agent, one job.
  2. Strong models invent and review; smaller models carry out.
  3. The coordinator coordinates and nothing else.
  4. Use a queue; workers pull.
  5. Give every handoff a strict format.
  6. Write everything down outside the context.
  7. Claim files before editing.
  8. Never let the author approve its own work.
  9. People decide at the front and at the gate.
  10. Track cost per task.
  11. Cap turns, and tune the cap.

Part 2: How BosunCadre handles this

Full disclosure: this part is about our product. Everything in Part 1 works without it.

BosunCadre is a self-hosted control plane for AI work. It grew out of coordinating our own agents across several machines, and it handles most of Part 1 for you.

  • One queue, workers pull. A coordinator holds the queue. Each machine runs a small runner that says what it can do and claims only the jobs that fit. Adding hardware is just starting a runner.
  • Tasks go where they can run. A task can require capabilities, such as a GPU or the ability to run your tests, and only machines that have them will pick it up.
  • Hard tasks go to strong models. Give each model a strength rating and tag a hard task with the strength it needs. BosunCadre offers it first to a model that clears the bar. If none takes it within a short wait, another available model can pick it up. Mark it strict and it waits for a strong enough model instead.
  • Roles are stages in a workflow. You choose the stages a job goes through, such as plan, execute, review and land, and what happens when one fails. Ready-made workflows ship with it.
  • Review is a separate stage, not a promise. You set the review chain: a stronger model, an AI session, or several in a row. A rejection with a reason sends the work back for a fresh draft.
  • By default, nothing merges by itself. Approved work waits at a land gate for a person to land it.
  • Agents claim files. An agent claims the files it's about to touch, and one reaching for a file someone else has claimed gets warned.
  • Every task's cost is logged, including what it would have cost on a paid model.
  • Built to scale both ways. The same design runs on a single PC or a small home lab, and it's built on principles meant to keep scaling up to data-center size. To be clear, we've only run it at home-lab scale; the large end is a design goal, not something we've measured.
  • The models you already have. Local models through Ollama, llama.cpp or any backend with an OpenAI-compatible API, plus API keys for Anthropic or any OpenAI-compatible provider.

BosunCadre is in public beta. If you try it, we'd like to hear which of these rules you'd add to.