Boss Agents and Worker Agents: How to Cut AI Token Costs by Up to 80%

What are boss agents and worker agents?

A boss agent is an AI agent that plans a job, splits it into small tasks, hands each task to another agent, and checks the results. A worker agent takes one clearly described task and does it.

The money trick is simple: put an expensive, smart model in the boss seat and cheaper models in the worker seats, so the costly model spends its time thinking and reviewing instead of reading every file. This is a straightforward look at what that saves, when it works, when it doesn't, and what it costs across Anthropic, OpenAI and China's open-weight AI labs.

Key findings

1. Most of what you pay an AI agent for is reading, not writing. In our coding and research scenarios, an agent reads 50 to over 100 times more text than it writes, because it re-reads its whole conversation on every step.
2. Splitting work up saves money even with no cheap model involved. In our research scenario, handing sub-questions to separate agents cut the bill by a third, just by stopping one agent from re-reading everything it had ever seen.
3. An expensive boss with cheap workers came out 66% to 92% cheaper than one top model doing everything, across our coding and research scenarios.
4. The reverse setup (cheap boss, expensive workers) saves almost nothing on typical jobs, about 7% in our coding scenario, because the heavy reading lives with the workers. It does win in one narrow but real case: long, boring supervision wrapped around a small hard problem.
5. The biggest lever isn't the worker's price. It's how much the boss reads. Keep the boss to 10% of the reading and you save 72% to 85%. Let it do half the reading and savings fall to 40% to 47%.
6. Cheap tokens aren't free. Review, redos, smaller memory and compatibility quirks are the real costs. The price gap is wide enough to absorb them: in our coding model, cheap workers could redo all their work roughly 5 to 16 times over before the split stopped paying off.

A tiny glossary before we start

• Token: a chunk of text, roughly three quarters of a word. AI providers charge per million tokens.
• Input vs output: input is what the model reads, output is what it writes. Writing usually costs 4 to 8 times more per token than reading.
• Context window: how much text a model can hold in mind at once. Think of it as the size of its desk.
• Boss agent: the agent that plans the work, writes instructions for other agents, and checks their results.
• Worker agent: an agent that takes one clearly described task and does it.
• Open-weight model: a model whose internals are published, so anyone can run it on their own machines. Many of China's best models are open-weight.

Don't pay the senior engineer to read every file

Picture hiring a brilliant senior engineer, then asking them to also do the photocopying, sit on hold with the bank, and read every page of every manual in the building before answering a question. They'd do it well. It would also be the most expensive photocopying in history.

That's how most people use AI agents today. One top model, one long conversation, doing everything from the big architectural decision to renaming a variable on line 412.

We build Granular, a workspace where one agent (the boss) can spin up other agents (workers), hand them tasks, check their work and merge it in. This month we shipped real features this way: a cheaper model doing the hands-on edits, a top model doing the thinking and the review. This piece is what we learned about the money, the tokens and the trade-offs, written up so you can redo the math with your own numbers.

Where the tokens actually go

Here's the part that surprises almost everyone. Agents mostly pay to read.

Every time an agent takes a step (reads a file, runs a check, makes an edit) the model is sent the entire conversation so far. A coding session that grows to 60,000 tokens and takes 40 steps has re-sent that growing pile of text 40 times. That's well over a million tokens of reading to produce maybe 50,000 tokens of actual writing.

Writing costs more per token, but there's so much less of it that reading dominates the bill. Three things follow from that:

• The cheapest token is the one your most expensive model never has to read. This is the real engine of delegation. A worker reads the 3,000-line file; the boss reads a 20-line summary of what it found.
• Prompt caching matters more than most model choices. Providers discount text they've seen recently. On Anthropic and OpenAI, re-reading cached text typically costs around a tenth of the normal input price. Turn it on before you reorganize anything. It cuts every setup's bill, though it doesn't erase the gap between them.
• Thinking costs money too. "Reasoning" models bill their hidden thinking as output, the expensive kind. So a model's effort setting is a price dial: same model, less thinking, smaller bill.

Five ways to set up a boss agent and worker agent team

AI model prices: Claude vs GPT-5 vs DeepSeek, Qwen, Kimi and GLM

Table 1. Representative list prices, US dollars per million tokens. Prices move fast (several of these fell by half or more in the past year), so treat this as a map of tiers, not a quote. Newer generations keep arriving; the gaps between tiers have been far more stable than the exact numbers.

What each camp is good at, in plain terms:

• Anthropic has the cleanest three-rung ladder (Opus, Sonnet, Haiku), which makes same-family teams easy. It's strong at long sessions that use lots of tools. Haiku 4.5 is a genuinely capable worker when the task is small and well described.
• OpenAI has the widest ladder, from nano up to full GPT-5, plus a second dial: reasoning effort. GPT-5 mini is one of the best-value workers on paper.
• China's open-weight labs (DeepSeek, Alibaba's Qwen, Moonshot's Kimi, Zhipu's GLM) price far below Western frontier models, with coding ability that punches well above the price tag, and you can run many of them yourself. Three things to check before you rely on them: their context windows are usually smaller (commonly 128,000 to 256,000 tokens), tool use can be more or less reliable depending on which company hosts the model, and you need to know where your data gets processed. That last check is the same diligence you'd do for any vendor, not a special rule for China.

Across this table, the budget tier is roughly 5 to 60 times cheaper than the frontier tier, depending on the provider and on whether you're reading or writing. That gap is the whole opportunity.

How we modeled this

This is a modeled study, not a lab benchmark. We want to be upfront about that.

• Token budgets follow the shape of real agent sessions we run every day: lots of re-reading, modest writing.
• Prices come from Table 1. For the scenarios we use four round tiers: Frontier at $5 in and $25 out (Opus-class), Haiku-class at $1 and $5, GPT-5 mini at $0.25 and $2, and Open-weight budget at $0.30 and $1.20, a round stand-in for the DeepSeek, Qwen, Kimi and GLM range.
• No caching unless stated, so the setups are compared like for like.
• Team setups pay a coordination tax. Briefs, reports and duplicated context add about 5% more total tokens than a solo agent would use.
• The qualitative findings (the bugs, the failures, the surprises) come from our own boss and worker builds this month. The dollar figures are arithmetic you can redo with your own prices.

Cost scenarios: coding, research, writing and everyday tasks

Vibe coding a real feature

"Make the app's window resize gracefully: hide the side panels when it gets narrow and bring them back when it widens." We built exactly this last week with a boss and workers.

Token budget. Solo: 4.0M tokens read, 80,000 written. As a team: the boss reads 0.6M and writes 20,000 (planning, briefs, review); the workers read 3.6M and write 70,000.

Table 2. Coding a feature.

What this tells us: savings follow the tokens, not the job titles. Nearly all the reading happens in the hands-on work, so that's where the cheap model has to sit.

What about mistakes? Cheap workers get things wrong. Say one in five worker tasks needs a complete redo. The Haiku-class team goes from $7.45 to $8.24, still 63% cheaper. For the team setup to lose outright, Haiku-class workers would have to redo all their work about 4.7 times over, and open-weight workers about 16 times. The price gap buys a lot of forgiveness.

Deep research

"Scan the market for tools like ours: pricing, features, who they're for." The boss splits this into 10 sub-questions. Each worker reads about 150,000 tokens of sources and writes a short brief. The boss reads the briefs and writes the final report.

Token budget. Solo: 5.0M read (the conversation balloons as sources pile up and get re-read), 40,000 written. As a team: the boss reads 0.2M and writes 15,000; ten workers read 3.0M in total and write 40,000.

Table 3. A 10-question research report.

Look at the second row. Same expensive model everywhere, and it's still a third cheaper. Nothing got cheaper per token. Each worker just starts with a clean, small desk instead of one agent dragging every source it ever read through every later step.

It's also faster. Ten workers researching side by side finish in a fraction of the time one agent takes working through the list.

Watch out for confident summaries. A cheap summarizer can miss nuance or state something wrong with a straight face. Budget for the boss to spot-check the claims your decision actually rests on.

Writing

Writing flips the economics. It's heavy on output, and quality is the whole point.

Table 4. One flagship long-form article with revisions.

Honestly? For one important piece, don't bother. You'd be saving the price of a coffee and risking the voice.

Volume is a different story. Take 500 product descriptions: solo top model costs $15.00. Open-weight drafts ($0.84) plus a top-model check on 10% of them ($1.50) comes to $2.34, 84% cheaper.

Drafts are cheap. Taste is expensive. Spend your money on taste.

Everyday ops: inbox triage and routine tasks

1,000 emails a month: sort, tag, draft replies where it's easy. Each email is about 3,000 tokens read and 300 written.

Table 5. Monthly inbox triage.

This is the cascade, and it's the cheap-boss idea done right: a cheap front door with an expensive specialist on call. It only works with a clear rule for when to pass something up ("anything legal, anything angry, anything the cheap model marks as unsure").

When the cheap boss actually wins

The reverse setup has one real sweet spot: long, boring supervision wrapped around a small, hard problem.

We lived a small version of this cutting our own release this week. Building, signing, then waiting on Apple's approval servers meant a lot of "is it done yet?" and very little thinking. Scale that up to a six-hour job that needs checking 60 times, re-reading about 40,000 tokens of context each time, plus one genuinely hard fix when a build breaks.

Table 6. A six-hour supervision job with one hard fix.

Don't pay a senior engineer to watch a progress bar.

Where the cheap boss fails: anything open-ended. A cheap boss writes vaguer instructions and misses subtler mistakes in review, and those are exactly the two jobs where a boss earns its keep. If the hard part is deciding what to do, keep your best model in charge.

The one number that matters: how much the boss reads

Everything above hinges on one ratio: what share of all the reading lands on the expensive boss.

Table 7. Savings vs. solo top model, by the boss's share of the reading (coding scenario, ignoring the coordination tax).

A confession from our own logs: on tricky bugs, our boss often did a lot of the reading itself. That's how it found the exact broken line before handing off a tidy fix. That puts those sessions closer to the 25% to 50% rows than the 10% one.

The fix isn't to make the boss think less. It's to send workers to do the heavy reading and report back, so the boss thinks over summaries instead of whole files.

That's why we describe the saving as "up to 80% cheaper": it sits in the honest middle of this range, not at the best case.

What the price tag hides: notes from our own builds

These are real things that happened while building Granular with a top-model boss and cheaper workers this month.

• Review isn't overhead. It's the product. Cheaper workers handed back code with real bugs, and every one was caught in the boss's review before it shipped: a call to a feature that doesn't exist, which would have crashed on first use; a styling rule that hit the last cell of a table instead of the last row; a keyboard shortcut that fired twice, so full screen could never be exited; and a subtle one, where shrinking the window would have quietly and permanently overwritten the user's own layout choice. None of them showed up in the workers' own "all done, tests pass" reports.
• Clear delegation really does work. For one regression, the boss traced the problem to the exact function and line, wrote a tightly scoped brief, and handed it to a Haiku 4.5 worker. The worker's fix came back correct and merged after a single review. The worker's job was small because the thinking was already done.
• Small desks bite. A Haiku 4.5 worker (200,000-token window) got stuck in a loop: every time it compressed its memory to make room, one oversized file refilled it within three steps, three times running, until it gave up. Separately, a hosted open-weight model with a 131,072-token window flatly refused a request of about 176,000 tokens, 139,000 of which were tool results. Cheap models often have smaller context windows, so give them small tasks and have them read big files in sections.
• Instructions have limits, and that's healthy. One brief was too long to send in one go. Splitting it into two tasks, reviewing the first before sending the second, turned out better anyway.
• Workers can hit a step limit and pause. Small tasks, plus "save your progress as soon as it works," mean a pause never loses anything.
• Mixing providers has a small compatibility tax. One provider rejected a connected tool's definitions outright, because the format didn't fit its rules. Cross-vendor teams are worth it, but budget a little time for friction.
• Speed is often the bigger win. Workers run side by side. On a busy day, finishing three tasks at once can matter more than the dollars.

Clarity is a cost lever

The brief, meaning the instructions a boss gives a worker, is where a top model's intelligence gets passed on at a cheap model's price. A fuzzy brief turns into a redo, and redos are where the savings leak away.

What worked for us, every time:

1. The goal, in one sentence.
2. The exact files and lines, if the boss already knows them.
3. What not to touch. In security-sensitive code especially, name what must stay as it is.
4. How to check it worked, a short list of pass/fail checks.
5. "Save your work as soon as it works", so a pause loses nothing.
6. One job per worker. Small tasks fail small.

Clarity for people matters too. If you can't see what each agent spent, you can't tell whether your team setup is actually saving anything. That's the next thing we're building into our own tooling.

Which AI team setup to use for each job

Table 8. What we'd pick, by job.

Limitations, and what we'll measure next

• These are models, not measurements. Real token use varies wildly with the task, the codebase and the prompts.
• Prices change constantly. Redo the tables with today's prices before you quote them.
• Dollars don't capture quality. A cheap setup that ships a subtle bug can cost more than the entire token bill.
• Caching shrinks everyone's bill. It changes the dollar amounts more than the percentages, but it changes them.

Next, we want to log spend per agent in real sessions, so the next version of this piece runs on measured numbers instead of modeled ones.

The short version

Hire the senior engineer for judgment: planning, clear instructions, and a sharp review. Let the eager, cheap coworkers do the reading and the typing. Keep tasks small, keep briefs clear, and check everything before it ships.

Done that way, the math says a team costs a fraction of one genius doing it all. In our own experience, it also catches more mistakes.

Try it yourself: in Granular, any session can become a boss that spins up worker agents on the models you choose, including Claude, GPT and open-weight models, then reviews and merges their work. Keep your favorite model; give it a team.