Handoffs, Not Hellos: Cutting Waste in a Multi-Bot AI Team
By Kay Honig
The short answer: multi-bot AI teams waste most of their budget on coordination and context, not on model quality. In our week, one long build chat was about 63% of our Grok Bot usage and bot-to-bot messages were about 22%. Six rules fixed the habits.
On Monday morning, three days after our weekly usage reset, 67.2% of the weekly limit was gone.
Sunday alone was 55% of the usage so far that week.
I run a team of about 25 persistent AI agents. They are Grok Bots with different jobs: a chief of staff, a CEO bot that coordinates builds, a poster that drafts content, a finance bot, research bots and others. They talk with me in chats. They run scheduled routines. They message each other. They start subagents for smaller jobs.
The uncomfortable part was not the number. It was what we got for it. Looking back at that Sunday, I could not point to much substantial product that shipped relative to what it cost. That is my judgment, not a metric. But it was enough to make me stop and look.
I could have bought a bigger plan. Instead, we measured where the usage went and changed how the team works.
My conclusion: multi-bot teams do not usually fail on model intelligence. They fail on coordination and context. I call that cost the coordination tax: the extra usage a multi-agent team spends on messages, handoffs and re-reading context, rather than on doing the work.
What actually ate the budget
Here is what our usage report showed. It gave percentages, not token counts or prices.
LDK case, Nov 9, 2026
| Item | Share | What it measures |
|---|---|---|
| Weekly limit used | 67.2% | Share of the weekly limit, three days after the Nov 6 reset |
| Grok Bot | 50.3% | Share of that usage from Grok Bot. The rest came from other Grok apps |
| CEO bot, total | 68% | Share of Grok Bot usage |
| Build and QA chats with me on one website pull request | about 63% | Share of Grok Bot usage (part of the CEO bot's 68%) |
| CEO bot messaging other bots | about 5% | Share of Grok Bot usage (part of the CEO bot's 68%) |
| Bot-to-bot messaging, all bots | about 22% | Share of Grok Bot usage |
| Routines (paused) | under about 4% | Share of Grok Bot usage |
| Sunday, Nov 8 | 55% | Share of the usage so far that week |

The biggest cost was not the bots chatting among themselves. It was me.
Most of the usage came from one long working session. I would ask for a change, the bot would build it, we would check it, and I would ask for another change. Then another. Each round felt small. Together, they were most of the bill.
The second cost was bot-to-bot traffic. More than a fifth of Grok Bot usage went to agents messaging each other. Some of that was real work: handoffs, finished results, blockers. Some of it was courtesy. "Got it." "Working on it." "Here is a quick update."
The cheapest item was routines, because they were off. That number matters more than it looks. If your routines are paused and your usage is still high, the problem is somewhere else.
Two inferences, labeled as inferences:
- Long agentic coding chats pay again for growing context on every turn. By the twelfth round, the bot is not only reading my twelfth request. It is carrying the history of the first eleven. I cannot see the internal token counts behind our percentages, so this is a reasoned explanation, not a measurement.
- Polite bot messages look free but are not. A two-word acknowledgement can wake an agent, load its instructions and tools, and start a full turn. The message is short. The turn behind it may not be.
Why multi-agent systems are expensive by design
This is not only our problem. The people building these systems say the same thing in public.
Anthropic wrote about the research system behind Claude's research feature. In their data, agents typically used about 4 times as many tokens as chat interactions. Multi-agent systems used about 15 times as many tokens as chats (Anthropic, How we built our multi-agent research system).
The setup worked. It outperformed a single Claude Opus 4 agent by 90.2% on their internal research evaluation. And in their analysis of the BrowseComp evaluation, token usage alone explained 80% of the variance in performance. More tokens bought better results, for that kind of task. Their point was that multi-agent systems make economic sense when the value of the task is high enough to pay for that spending, and when the work can run in parallel.
OpenAI's guidance on multi-agent workflows makes a similar point from the other direction. Subagents increase token usage. They fit independent, bounded tasks. For ordered work or work that depends on shared state, one agent is often the better choice. The guide suggests starting with a maximum of 3 concurrent subagents and measuring cost from there (OpenAI, multi-agent guide).
Researchers have measured the communication itself. The AgentPrune paper found that multi-agent communication structures can use 2 to 11.8 times as many tokens as a simple chain. Pruning redundant messages cut token use by 28% to 73% in their experiments (AgentPrune, arXiv:2410.02506).
A separate paper on the coordination tax tested planner, coder and reviewer pipelines. On the coding tasks it tested, that pipeline cost about 3.22 times as much as one call to a single strong model, without solving more tasks (arXiv:2610.37700).
Even the setup has a cost. A study of agent protocols found that handshakes and metadata can cost tens of tokens for each capability before any useful work begins (arXiv:2610.30151).
And cheaper models do not automatically save money. One report on OpenAI's Codex repository describes fixed context and tool overhead for each subagent, which can wipe out the savings of a cheaper model when you start many of them (Codex issue #39808). That is a user report, not a study.
The lesson: communication is a first-class cost. Short messages are still work, and you pay for it.
Context is a budget, not a junk drawer
The second idea that changed how I think about this comes from Anthropic's writing on context engineering (Anthropic, Effective context engineering for AI agents).
They describe context as a limited attention budget. As more tokens fill the context window, a model's ability to use that information accurately can decline. They call it context rot. A bigger context is not automatically a better one.
Their practical advice is easy to follow, even for a non-engineer:
- Retrieve just in time. Give the agent a file path or a link, and let it fetch what it needs. Do not paste the whole document into every message.
- Compact and take notes. On long jobs, summarize what matters and keep structured notes outside the conversation, so the next step does not need the entire history.
- Use clean subagents. A subagent can explore a lot of material and hand back a condensed summary. Anthropic mentions summaries of roughly 1,000 to 2,000 tokens after much larger explorations. The parent agent receives the result, not the whole search.
Then there is caching. Anthropic, OpenAI, Google and xAI all document some form of prompt or context caching (Anthropic, OpenAI, Google, xAI). The common pattern is the same. Keep the start of the prompt stable. Put static instructions first. Add new turns to the end instead of rewriting earlier ones.
Now the caveat. Those documents describe raw APIs. We use a subscription with a weekly limit shown as a percentage. I do not know whether, or how, cache hits show up in that percentage. I am not claiming that our subscription usage works like API token pricing, or that any vendor's cache rates apply to us.
My inference is narrower. Stable specs and add-to-the-end habits are unlikely to hurt, and they reduce how often a large, changing block of text has to be processed again. That is reason enough to work this way.
Operating rules we installed, and why
We installed the first three rules before writing this article. The rest come from the research above and are now part of how the team works.
1. Between bots: handoffs, results and blockers only. A bot messages another bot to hand off work with a complete brief, to deliver a finished result, or to flag something that blocks progress. No acknowledgements. No status pings. No courtesy replies. Why: bot-to-bot messaging was about 22% of our Grok Bot usage, and AgentPrune's results show how much redundant communication can cost. What we give up: less live visibility into who is doing what. A short, non-urgent note that does not wake the recipient covers most of that.
2. One complete spec per website change. One QA round per version. Everything I want goes in one message: scope, what done means, what is out of scope, and links. The bot builds a version. We check that version once. Then I decide whether to ship it or start the next version. Why: about 63% of our Grok Bot usage came from long build and QA chats on one pull request. Anthropic and OpenAI both describe the cost of long loops and unnecessary agent turns. What we give up: fewer "also change this" messages in the middle. I wait for the next version instead.

3. Routines stay off unless I approve each one by name. No scheduled job runs because it used to run. Each one needs my approval once. Why: with routines paused, they were under about 4% of Grok Bot usage. Silence is cheap. What we give up: automatic morning briefs and digests until I turn them back on.
4. Subagents only for independent, bounded work. Start a subagent when the work can run in parallel and the result can come back as a short summary. Give it a fresh brief, not the parent's whole conversation. Start with no more than three at once, as OpenAI suggests. Combine small related tasks into one subagent instead of five. Why: OpenAI's guidance, the fixed overhead described in the Codex report, and Anthropic's finding that multi-agent setups use far more tokens. What we give up: some speed on research that truly could run in parallel.
5. Save milestones outside the chat. After each milestone, the bot writes down decisions, open bugs, the version and the next step, in the pull request, in notes or in shared memory. The next step starts from that note, not from a very long transcript. Why: Anthropic's guidance on note-taking and compaction for long tasks. What we give up: a few minutes of discipline every time.
6. Check usage before large jobs. Freeze low-value threads midweek. Before a long build, a large research job or a day that will wake the whole team, we check usage. If the week is already heavy, optional work waits until after the reset. Why: one Sunday was 55% of the usage so far that week. Preventing that is easier than explaining it afterwards. What we give up: optional work moves more slowly.
The tradeoff behind all six rules: less chatter, fewer quick tweaks, more patience. In exchange, the usage goes to the work.
One complete spec beats twelve clever follow-ups.
A practical playbook for founders
If you run more than a handful of AI agents, this is the short version:
- Write one complete spec before a build. Check one version at a time.
- Limit bot-to-bot messages to handoffs, results and blockers.
- Keep routines off unless someone approves each one by name.
- Start a fresh chat when the job changes. One thread, one deliverable.
- Use subagents for independent work only, with clean briefs and three at most.
- Save progress in notes or files. Send a link, not the document.
- Check usage before large jobs. Pause low-value work when the week is heavy.
- Match the model and effort to the task.
Rules only work when someone owns them. In our team at LDK:
- I set the approval gates. Money, legal decisions, external messages, deployments and routines need my explicit yes.
- The chief-of-staff bot enforces the traffic rules. It batches what needs my decision, so several bots do not ask me the same question.
- The CEO bot owns the build loop. One spec, one build, one QA round, then my decision on that version.
Multi-agent is a multiplier on tokens. Spend it where parallel work pays.
How the setup works
If you are new to AI agents, start with this picture. Every bot is like a new employee with amnesia. Each time it gets a message, it reads its notes from scratch, does the work, and forgets everything that was not written down.
So the whole game is what each bot reads every time, and how much. Our setup has four layers, from always read to read only when needed.
- Job description. One per bot. Who it is, what it owns, its hard rules. The bot reads it on every turn.
- Shared memory. One list for all bots. Short facts and rules about me and how I work. For example: no Spanish opening punctuation, no tax ID on websites, and the usage rules from this article. Every bot sees the current list at the start of every turn (older items are looked up only when needed). One line reaches the whole team at once. But every line also costs a little, on every turn, for every bot. Keep it short.
- Skills. How-to recipes, such as "how to publish a blog post". A bot reads a skill only when the job calls for it. Until then, only its one-line description sits in view, so it costs almost nothing.
- Files. The filing cabinet. A single source-of-truth file, a team board, project folders. Opened only when needed.
Why this works: the expensive part of AI is reading. What gets read every time must be tiny. Everything else waits in the cabinet until someone needs it.
It also explains why bot-to-bot chat is costly. Each message makes another bot read its whole setup again before it can answer. That is the coordination tax in one sentence.
This matches the context engineering advice above. Small, high-signal context on every turn. Everything else fetched just in time.
Setting this up in Grok Bot, step by step
If you are starting from zero, this is the order I would follow.
- Start with one main bot, a chief of staff. Talk only to it.
- Write its job description. Click the bot's name in the chat header, then the gear, and paste the prompt below into the description.
- Add specialists only when a job repeats, for example website work or email. Ask the main bot to create them, each owning one area.
- Save house rules once. Tell the main bot: "remember this for all bots: ...". One line per rule.
- Turn repeat jobs into skills. After a task goes well, say "save this as a skill".
- Keep big documents in files, not in chat or memory.
- Add routines last, and only ones you will actually read. Start with one weekday morning brief.
- Check usage weekly. Ask "what used the most this week?" and cut what did not pay off.
Here is the prompt for the main bot's job description. Copy it, then adjust the numbers to your own limits.
You are my Chief of Staff and the only bot I talk to. Your job: plan, delegate to the right specialist bot, and report back.
Rules:
1. Lead with the result. Keep replies under 5 lines unless I ask for more.
2. Decide routine things yourself. Ask me only about money, legal matters, sending or publishing to outside people, deleting data, or steps only I can do. Batch those into one message.
3. Never send, publish, pay or delete without my explicit "yes".
4. Bots message each other only to hand off work, deliver a result or report a blocker. No acknowledgements, thanks or status pings.
5. One complete brief per task. No piecemeal back-and-forth.
6. Keep shared memory short: one-line rules only. Put long material in files or skills.
7. Use helpers only for separate, contained jobs, at most 3 at a time.
8. Before any big job, check usage. If it's over 60% mid-week, pause low-value work and tell me.
9. Never invent numbers or facts. Cite sources and separate facts from guesses.
10. Every Friday, suggest one change that would cut wasted usage.
Rule 7 follows OpenAI's suggested starting point of three concurrent subagents. The 60% threshold in rule 8 is our own choice, not a published number.
What we're still improving
Our own team does not follow all of this yet.
- Shared memory got cluttered. It collected stale facts. We started pruning. One of the first lines to go was an outdated "everything on hold" rule.
- Too many places track status. A source-of-truth file, a team board that was a week out of date, a decisions file and many backups. The plan: one file, and archive the rest.
- Rules live as loose sentences in memory. They would work better as one "team rules" skill, with a one-line pointer in memory.
- We have about 25 bots, and some barely work. Merging the quiet ones cuts setup and chatter.
What we are not claiming
Not that multi-agent systems are useless. Anthropic's research system performed much better than a single agent on breadth-first research. When the work is truly parallel and valuable, more agents can be worth the cost.
Not that cheaper models always save money. If you start five of them and each carries the same fixed overhead, the savings can disappear. The Codex report is one example.
Not that our percentages apply to your team. They are one week, one team of about 25 agents, one subscription, one particular mix of work. Most of our usage came from one long build. Your biggest cost may be somewhere else.
Not that we know how our subscription counts cached tokens. We do not. Our report gave percentages, not token counts.
Not legal, tax or billing advice. This is an operator's notes from one week.
Efficiency is an operating system
I have been in travel for 14 years. Guiding taught me that a good day depends less on any single stop than on how the day is organized. An AI bot team is similar. The model is one part. The rest is how you hand off work, what each agent has to read, and when it is worth running things in parallel.
Before you add another agent, measure two things: your most expensive bot and your most expensive day. Then ask how much of that was real work and how much was coordination.
Ours was mostly one long build chat and a lot of polite messages. We fixed the habits first.
I will keep writing up what works and what does not as we run this team at LDK. If your small team wants to adopt AI practically, without the waste, that is what I teach in my talks and workshops.