How to Run a Team of AIs Without Becoming Their Secretary

PatreonGlobal Watchdog is reader-supported, with no advertisers and no government entity to answer to. If you enjoyed this article, you can help keep it coming with a one-time donation or monthly support: Support on PatreonDonate on Ko-fi
Share this article:

14 min read

Last updated

On a normal morning, my staff meeting lasts about four minutes, and nobody attends it. Not me, and not the staff. There is a digest waiting when I sit down: what finished overnight, what is stuck, and the short list of things that genuinely need my judgment. Everything else already moved without me.

That is the companion film to this article. A second version of it is on the channel too. Watch both if you like, and tell us in the comments which cut works better.

The staff is software. One AI runs as my chief of staff. A second, from a rival company, builds and drafts. A third does the cold, hostile verification work: it takes a finished piece of work it had no hand in, checks it cold against the source documents, and tries to break it. Behind them, a bench of free assistants runs fact checks and market listening in rotation. I am the only mammal on the payroll.

The outfit runs two kinds of work. It runs this news site, the one you are reading. And it runs production work of the kind any one-person business has. Take an example. Say the business is a one-person online shop that repairs and resells vintage radios: 117 sets in the current program, every one graded against a written checklist, every repair verified by somebody other than the one who built it. The shop is the illustration. The machinery is the subject, and the machinery does not care what the shop sells.

Work finishes overnight instead of waiting for you to hand it out. Finished work gets checked by somebody who did not make it, which is where solo operations quietly bleed. And your own hours shrink to the short list of decisions only a human should make. The labs back the shape of it, with the labels on. Anthropic reported that its multi-agent research system beat a single agent by 90.2 percent on Anthropic’s own internal research evaluation, at roughly fifteen times the token cost. Google Research’s scaling study, published in January 2026, found the mirror image: on planning tasks, where each step depends on the last, every multi-agent variant performed worse than a single agent, by 39 to 70 percent, while genuinely independent work gained handsomely, and a central checkpoint held error amplification to 4.4 times against 17.2 for uncoordinated agents. Read together, they are the whole philosophy. Split only what is truly independent, and put a checkpoint where the pieces come back together. The rest of this article is how to build exactly that.

The answer, first
Practitioners running the same one-human, many-AI operations report the identical stall, and the fix they converged on is not a smarter assistant.
1 · Pull, don’t pushNobody gets handed work. When a seat frees up, it pulls the top Ready card for its role, writes its claim on the card before it starts, and works only its own cards.
2 · A watchdog that isn’t youMine is a scheduled job that runs every hour, reads the shared folder, compares what it finds against what it saw last time, moves the board to match reality, and refills any seat whose queue has run thin.
3 · Review is a lane, not a deskThe verdicts are limited to three: pass, revise, block. A pass advances the card on its own. A revise sends findings back as a new card to the original builder. Only blocks, second failures, and anything that leaves the building come to me.

It did not start out working this way. It started with me as the most overworked employee in the building: three or four AI chats open, a draft copied from one chat into a second for critique, the critique carried back by hand. I was the integration layer, the scheduler, and the filing clerk, and the state of every job lived inside conversations that scroll away and die. The collapse came in mid November. The review pile on my chief of staff’s desk reached the low thirties. Finished work sat uncollected. Seats sat idle, not because the machines had stopped, but because every road ran through one desk and that desk was buried. I caught myself asking why it was broken again when I had been told it was fixed. If the human has to ask why nothing moved, the human is the monitoring system, and a monitoring system that sleeps, eats, and occasionally goes to Savannah is not much of a monitoring system. Here is the rebuild, in the order I would do it again.

The build: nine steps

You need no special software for any of this. A shared folder, plain text files, and the AI services you already use will do. Each step names the thing to make, what goes in it, and the test that tells you it is done.

Step 1: Pick your team and give each seat a named job

Write down, in one short file every seat can read, the seats you are running and what each one owns. Mine reads: a chief of staff who runs the board and is the only seat that talks to me by default; a builder, from a rival company, who drafts and builds; a verifier who checks finished work cold and tries to break it; and a bench of free assistants on fact checks and listening duty. Rival companies are deliberate. A verifier from the builder’s own model family inherits the builder’s blind spots.
Done when: every seat has a name, one job, and its limits in writing.

Step 2: Create one shared board where all the work lives

Make one document, in a folder every seat can reach, with six columns: Backlog, Ready, In Progress, In Review, Revision, Done. All work lives on cards in that document, nowhere else. Blocked is a flag on a card, never a column, because a blocked card still occupies space and still counts. The board, not any chat, is the single source of truth. A conversation can be lost, compacted, or abandoned. The board is still there in the morning.

BacklogEverything, unready
ReadyRefilled to depth 3 per role
In Progress≤2 per worker · claimed
In Review≤3 per reviewer · hard cap
RevisionFindings as new cards
DoneBlocked is a flag, not a column

A glass wall covered in color coded task cards arranged in columns, the shared board a team of AI agents works from

A homelab operator named Christian Anderson runs one agent in six roles, and his summary of why it works deserves quoting whole:

The profiles don’t call each other. They share a Kanban board, and that indirection is what makes it a team instead of a pile of prompts.Christian Anderson, homelab operator: one agent, six roles, one board

When his builder finishes, it does not message the security profile. It moves the card to Review, and the reviewer picks it up on its own schedule. Findings come back as new cards.

Done when: the board exists, every live job is a card on it, and nothing real lives only in a chat.

Step 3: Write the standing rules

Write a second file, the standing orders, that says who may do what without asking you. Mine grants reading freely, drafting freely, and internal filing freely. It reserves everything that leaves the building (sending, publishing, paying, deleting) for a human yes. It also states the quality bar in plain words: in the radio shop, no set ships until a non-builder has verified the repair against the factory service manual. Every seat loads this file at the start of every session. Vague orders are how you get three agents researching the same question, and they outrank any instruction a seat picks up along the way.

Done when: the rules file exists and names what is free, what is gated, and what “right” means for your work.

Step 4: Turn every job into a card

Give every job a card with five things on it: the objective in one sentence; the output, the exact file or artifact that exists when the job is done, and its format; the named sources the work must come from; the boundaries it may not cross; and the seat that owns it. A radio shop card reads: “Restore the 1958 Hallicrafters receiver. Output: a graded repair file in the program folder. Sources: the factory service manual and the parts ledger. Boundary: no parts order over the cap without a gate.” A card missing a field stays in Backlog. If a job cannot be written as a card, it is not ready to hand to anyone, human or otherwise.

Done when: every card in Ready carries all five fields.

Step 5: Set the pull rule, so seats take work instead of waiting

Write into the standing orders that nobody gets handed work. When a seat frees up, it pulls the top Ready card for its role, writes its claim on the card, its name and the time, before it starts, and works only its own cards. Cap work in progress at two cards per seat. Keep Ready refilled to a depth of three per role, so a seat that finishes always finds the next job waiting. This one rule demotes you from dispatcher to owner, and it is the step most people skip, because handing out work feels like managing. It is not managing. It is courier work with a title.

A solo operator at an ultrawide monitor and a laptop, directing AI agents from a home desk

Done when: a seat can start its next job at 3 a.m. without you touching anything.

Step 6: Build the review lane

Route every finished card to In Review, where a different seat checks it. The builder never reviews his own work; the whole operation stands on that sentence. Verdicts are limited to three. Pass: the card advances on its own. Revise: the findings go back to the original builder as a new card. Block: the card stops and comes to you, along with second failures and anything headed out of the building. The reviewer checks against ground truth, a test, a primary document, the service manual, never against the builder’s say-so, because reviewers can be confidently, unanimously wrong: in one 2026 study, more than eighty agents, adversarial reviewers included, endorsed an OpenSSL security vulnerability that did not exist, and a single empirical test caught what the debate missed. Cap the lane at three cards waiting on any one reviewer. Past that, refills pause until the pile drains. Why the cap matters, in one operator’s numbers:

109 → 0Drafts finished in Seatbelt’s early run vs. published as written. Two went out after a human rewrite, and the gate had quietly become a rewrite desk instead of a checkpoint.
23More drafts archived unposted in the same run, because the queue had drifted stale while it waited at the gate.
≤3Cards allowed to wait on my review desk. If more than three are waiting, production refills pause until the pile drains.
2h / 24hStale claims get flagged at two hours and reclaimed at twenty-four, but only after checking for partial work, which is preserved rather than thrown away.

Seatbelt Labs, whose fleet of roughly eighteen agents coordinates entirely through shared logs, watched its gate quietly become a rewrite desk instead of a checkpoint. Adding a sixth worker to a saturated reviewer does not produce throughput. It produces inventory, and inventory of half-checked radios is just a more organized kind of mess.

Done when: no card reaches Done without a verdict from a seat that did not build it.

Step 7: Add the watchdog

Set up a scheduled job, hourly is fine, that is not one of the workers and does no work. Its whole job: read the shared folder, compare what it finds against what it saw last time, move the board to match reality, flag any claim untouched for two hours as stale, reclaim claims untouched for twenty-four, but only after checking for partial work, which is preserved rather than thrown away, and refill any seat whose Ready queue has run thin. Judge it by output, never by liveness. A developer named Shinjae Kang learned why the hard way: his cron-driven content pipeline reported complete health while publishing nothing, every agent picking up an empty input, writing nothing, and reporting success. His line for it: “Four agents, four clean exits, one intact chain of nothing.” His fix is now my rule:

A task counts as done only when the expected file exists, in the expected format, with real content in it, verified by something that does not report to the worker.

Done when: the watchdog has run a full day and the board matches reality without you opening it.

Step 8: Set the gates

List in the standing orders the actions no seat may take without a human yes: sending, publishing, paying, deleting. Then put the budgets outside the agents entirely: a spending cap and a step limit that stop work cold without asking a model’s permission. Replit’s Missions, launched November 17, 2026, lets you state an outcome, set a hard spending cap, and draw the approval lines while a swarm works inside them; their showcase build ran inside a 3,000 dollar capped budget, and note Replit’s own careful wording: a cap is a ceiling, not a receipt. Perplexity launched Multiagent the same day, and the practitioner reaction was the instructive part: the praise went to the control patterns, not the swarm counts. The budget is the only control that does not depend on a model behaving.

Done when: you can point to the written list of gated actions, and every cap lives where no agent can edit it.

Step 9: Run one real project for a week, then fix the rules

Pick one real, bounded project, the 117 radios in the illustration, a month of this site’s production in my building, and run it on the board for seven days. Do not rebuild the system midweek. When something jams, and something will, write down where it jammed. At the end of the week, fix the rule that caused the jam, not the seat that hit it. A Berkeley-led failure study, built from 1,642 annotated traces across seven frameworks, found the failures mostly trace to system design: vague specifications, drifting agents, weak verification. Grimly familiar to anyone who has run a human department, and good news for you, because rules are cheap to fix and models are not yours to fix at all.

Done when: a full week ran on the board, and every jam has a rule change written next to it.

What goes wrong, briefly

Two failures from my own operation. The chain of nothing: a pipeline in perfect reported health that produced nothing, because nobody verified the deliverable existed. That is the failure step 7 exists to catch. The clogged gate: my review pile reached the low thirties because finished work had nowhere mechanical to go, and approval quietly turned into re-authoring. That is the failure steps 5 and 6 exist to prevent. Both failures looked like machine problems. Both were management problems, and both were fixed with rules.

The rules, if you want to steal them

Everything above compresses into the standing orders my operation actually runs on. They fit on an index card, which is roughly what they deserve.

  • One board is the only source of truth. If it is not on the board, it is not happening.
  • Workers pull work; nobody waits to be assigned, and nobody starts without claiming the card.
  • Every job is ordered with an objective, an output format, named sources, and boundaries. Vague orders are how you get three agents researching the same question.
  • The builder never reviews his own work. Review is a separate lane with three verdicts: pass, revise, block.
  • A watchdog that is not a worker checks output, not liveness, on a schedule, and refills queues to a fixed depth.
  • Stale work gets flagged fast and reclaimed carefully, with partial work preserved.
  • Authority is granted per action, not per agent. Reading is cheap. Anything that leaves the building gets a gate.
  • Budgets and step limits live outside the agents, and they stop work without asking a model’s permission.
  • The human sees a digest: completions, stalls, and decisions. Not a live feed, and never a courier route.
  • One writer per artifact. Everyone else contributes intelligence.

A year ago I would have told you the hard part of this was the technology, and I would have been wrong in the way that costs the most time. The models were never the constraint. The constraint was management: who owns what, where the truth lives, who checks, and what happens when something stalls at 3 a.m. Those are old problems. They were solved on factory floors and in kanban books long before anybody prompted anything, and the solutions are boring, mechanical, and completely indifferent to how smart the workers are.

The engine has twelve cylinders. It fires on all of them now, most days. Not because the cylinders got smarter, but because somebody finally built the transmission.

Keep the watchdog independent

If this article saved you money, time, or a headache, if you enjoyed it, or if you want to support local investigative journalism, you can buy me a coffee by card. No account needed, and Ko-fi takes no cut, so it all goes to the work.

Buy me a coffee

Prefer steady support? Join the Patreon for monthly backing.

Dr. Alan Wood
Dr. Alan Wood

Musings of an unabashed and unapologetic truth-seeker. Crusader against obscurantism. Optimistic curmudgeon, snark jockey, lovably opinionated purveyor of wisdom and truth. Multilingual world traveler and part-time irreverent philosopher who dabbles in writing, political analysis, and social commentary. Attempting to provide some sanity and clarity to complex issues with a dash of sardonic wit and humor. Thanks for visiting!

My byline rests on 24 years in the classroom: three years teaching in Japanese junior and senior high schools, ten years as an associate professor at Japanese universities, and eleven years teaching Spanish in Georgia public schools. I hold a PhD in Linguistics, and my EduLingo line of Spanish, ESOL, and French teaching resources is on Teachers Pay Teachers.

Enjoying Global Watchdog? Become a monthly supporter on Patreon and help keep independent journalism free for everyone — no paywall, no intrusive ads. Winston approves.

Articles: 601

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

© 2026 Global Watchdog Media And Commentary. All rights reserved.