How Much Do AI Agents Cost to Run? I Metered a Real Session

Every article about AI agent costs gives you the same strategy list: cache your prompts, route to cheaper models, compress your context. What none of them show is a receipt. So here's one.

Last week I asked my own product a research question — the kind of open-ended "compare everything and give me a recommendation" task that agents are supposed to be for. One expensive orchestrator model planned the work, spun up four sub-agents on much cheaper models, and synthesized their findings into a cited answer. Then I pulled the stored token counts and metered the whole thing, message by message.

The session cost about $1.40 in raw model usage. The same session with the flagship model doing everything itself: $5.50–6 with warm caches, up to ~$10 cold. Four to seven times more, for the same answer.

This post is the full breakdown — where agent money actually goes, why delegation beats every caching trick I know, and the one benefit of multi-agent setups that nobody prices in.

The Short Answer

What ran	Cost (API list prices)
Real research session: 1 flagship orchestrator + 4 cheap sub-agents	~$1.40
Same session, flagship model doing everything	~$5.50–10 (4–7× more)
Bigger session (2 turns, 10 sub-agents), as run	~$4.65
Same big session without sub-agents, estimated	~$13–16

The pattern held at every price point I tested: delegating grunt work to cheap sub-agents cuts the bill by roughly 3×, no matter which model sits on top. Stack a cheaper orchestrator on top of cheap sub-agents and the spread grows to ~8.5×.

One scope note before the numbers: model names and per-token prices below are a July 2026 snapshot — the specific digits will drift as pricing changes, but the ratios are structural and they're the durable part.

The Session I Metered

The question was ordinary: research the best small open-source models to run locally on a Mac Studio with 32 GB of RAM. A genuine research task — dozens of sources to check, conflicting benchmark claims, hardware math.

I ran it in izzedo chat with Parallel Agents switched on. That's a toggle in agent mode: the model you picked becomes an orchestrator that can split the work across multiple AI agents running in parallel — each on any model in the workspace, each with full tool access and its own isolated context — then combine their findings. You watch them work in real time:

Look at who's doing what in that screenshot. The orchestrator is the most expensive model in the lineup ($10 per million input tokens, $50 per million output at list). The four sub-agents are an entirely different economic class: two Perplexity Sonar models with web search built in, and two open-weight workhorses — Kimi and GLM — that cost around $0.60 per million tokens, roughly a seventeenth of the flagship's input rate.

Here's the division of labor the meter revealed: across the whole session there were about 33 model round-trips. The flagship made exactly 2 of them — one to plan and dispatch, one to reconcile and write the answer. The other ~31 round-trips — the searching, the fetching, the reading of documentation and forum threads — all ran on the $0.60/M models.

Why Are AI Agents So Expensive?

To see why that division of labor matters so much, you need the one ugly fact of agent economics: loops re-read everything.

A chatbot answer is a single request. An agent step is a request that carries the entire conversation so far — every search result, every tool output, every prior thought — as input tokens. On the next step it sends all of that again, plus the new material. Run a 10-step research loop and you haven't paid for 10 requests' worth of tokens; with the compounding re-reads it's closer to 50. (Industry estimates put agent workloads at 5–30× the tokens per task of a plain chatbot exchange, and that matches what my meter showed.)

In my session, each research sub-agent accumulated roughly 160,000 input tokens of cumulative re-reading across its loop. At $0.60 per million, that's pennies — noise. At the flagship's $10 per million, that same loop is real money, and there were four of them running. Add reasoning tokens — billed as output, at the flagship's $50 per million, on every step — and the loop economics get brutal fast.

That's the whole trick, stated plainly: agent cost lives in the loops, so put the loops on models where tokens are nearly free, and save the expensive model for the two moments that actually need judgment.

The Counterfactual: Same Session, Flagship-Only

What if the flagship had simply done everything itself — the way a single-model agent does by default? Same transcript, re-priced at the flagship's rates:

Component	As it ran	All-flagship
Orchestrator (2 steps, 55.8k in / 9.5k out)	$1.03	$1.03
4 research sub-agents (~31 tool round-trips)	~$0.35	~$4.20–5.00 cached / ~$8.80 cold
Total	~$1.40	~$5.50–6.00 / up to ~$10

Two things blow the flagship version up. First, those 160k-token loops now bill at 17× the input rate, and the thinking tokens at $50/M land on every iteration. Second — subtler — the two Perplexity agents stop being cheap, because Sonar models bundle web search into a single request. One of them delivered a fully cited research report for about seven cents. A flagship model without built-in search has to run a multi-step search loop to produce the same thing, inheriting exactly the loop economics we just described.

The sentence worth internalizing from this table: the delegation decision saved more money on this one session than every caching, pruning, and prompt-compression technique combined would have. I know because I audited those too — the entire remaining $1.40 had maybe $0.30 of optimization headroom in it. The architecture was the whole game.

Is a Multi-Agent Approach More Expensive Than a Single Agent?

That's the question people actually ask — more agents sounds like more cost. So I metered a second, heavier session: two turns, ten sub-agents (five Sonar, two Kimi, three GLM, ~62 web searches between them), a two-part market-research job. Total as run: ~$4.65, about 80% of it the orchestrator's own dispatching and synthesis.

Then I re-priced the identical transcript with different models in the orchestrator seat, with and without delegation:

Orchestrator	$/MTok in / out	Session with sub-agents	Without sub-agents (est.)
Claude Fable 5 (as run)	$10 / $50	~$4.65	~$13–16
Claude Opus 4.8	$5 / $25	~$2.80	~$6.50–8
GPT 5.5	$5 / $30	~$2.90	~$7–9
Claude Sonnet 5	$2 / $10¹	~$1.70	~$2.60–3.50

¹ Introductory pricing through August 2026; list is $3/$15. "Without sub-agents" means the orchestrator model runs all ten research tasks itself as inline search loops, warm caches assumed.

Read the columns, not the rows. Delegation is worth roughly 3× at every single price point. It's not a flagship-specific trick — moving the token volume off the orchestrator's meter saves the same proportion whether that meter charges $2 or $10 per million. And the two choices compound: a budget orchestrator with cheap sub-agents versus a flagship without them is a spread of about 8.5× for the same research session.

So the honest answer to the question: a multi-agent approach is more expensive only if you staff every agent with the expensive model. Staff the grunt work with cheap models and it's the cheapest way to run agents that exists.

The Benefit Nobody Prices: A Clean Context

There's a second finding in that big session that matters more than the dollars.

Ten research tasks produce ten transcripts of search results and reasoning — well over 200,000 tokens of accumulated material. Not long ago that number ended the conversation: it simply wouldn't fit. That era is over. Today's flagship models carry 500,000 to 1,000,000-token context windows, and the orchestrator I ran this on holds a million. The whole pile would have fit.

Fitting and working well turn out to be different things, for two reasons.

You don't read a big context once — you re-read it on every step. This is the same loop tax from earlier, except now the thing being re-sent is ten research transcripts instead of a scratchpad. A million-token window doesn't make that cheap; it just removes the error message that used to stop you. That re-reading is the "without sub-agents" column in the table above — the 3× isn't a separate penalty, it's the price of carrying everything yourself.

Signal gets diluted. Every model gets worse at finding the relevant detail as the haystack grows — the effect is well documented, and it's why "it fits" was never the same claim as "it works." A context holding 200k tokens of raw search results, dead ends, and duplicate sources is a worse thinking environment than one holding four distilled findings, no matter how much headroom the window has left.

And there's a version where the old wall is still standing: the cheap and search-native models you'd actually want for a budget single-agent run mostly cap at 128k–200k. The flagship can carry the whole pile if you insist. The $0.60-per-million workhorse can't — which quietly means the cheapest single-agent version of this session isn't just expensive, it's unavailable.

Sub-agents sidestep all of it structurally. Each one works in its own isolated context and returns only its distilled findings — the ~160k tokens of raw searching never enter the main conversation at all. The orchestrator gets to reason over a clean summary of ten investigations instead of the transcript of ten investigations. That's not just cheaper. It's a better place to think from.

The Cheapest Way to Run AI Agents: Match the Model to the Job

Everything above collapses into one practical rule: stop thinking "which model should I use?" and start thinking "which model should do which part?" What the metering showed:

• Orchestration is a judgment job. Decomposing the question, writing precise sub-agent briefs, catching that two sub-agents returned contradictory claims and reconciling them — in my first session the flagship orchestrator did exactly that, spotting a benchmark conflict its sub-agents missed. This is the seat where the expensive model earns its rate. (Though the table above makes a strong case for trying a mid-tier model here too when the task is routine.)
• Web research is a volume job. Search-native models like Perplexity's Sonar family deliver a cited answer in a single request — no loop at all. That seven-cent research report is the single best cost-per-insight I've ever metered.
• High-volume digging is a workhorse job. Open-weight models like Kimi and GLM will happily grind through 15+ tool calls of fetching and extracting for pennies. Their loops are exactly as long as the flagship's would be — the tokens just cost 17× less.

The catch is that no single vendor sells you this lineup. The flagship reasoner, the search-native specialist, and the open-weight workhorses come from four different companies. That's the quiet reason this works in izzedo chat: every one of those models already sits in the same workspace, so the orchestrator can hire across vendors the way you'd staff an actual team — and the same multi-model picker you use for switching models mid-conversation is what the orchestrator draws its staff from:

The Honest Caveats

Metering your own product invites motivated reasoning, so here's what these numbers are not:

• They're arithmetic, not invoices. I priced real token counts at published list prices. Caching moves the real bill 15–25% in either direction, and I've marked estimates as estimates throughout.
• The re-pricing table is the same transcript re-metered, not re-run. A different orchestrator would tokenize differently, think at different lengths, maybe dispatch a different number of sub-agents entirely. Treat the table as a floor-to-ceiling map, not a prediction.
• Cheap isn't free of tradeoffs. The dollars can't measure whether a budget orchestrator reconciles contradictory findings as well as the flagship did. That's a quality question, and it's the honest argument for keeping an expensive model in the top seat even when a spreadsheet says otherwise.

What This Means If You're Not Running Your Own Agents

If you're calling model APIs directly, the playbook writes itself: expensive model for dispatch and synthesis, cheap models for every loop, search-native models wherever a built-in search collapses a loop into one request.

If you'd rather not build any of that: this exact architecture is what the Parallel Agents toggle in izzedo chat's agent mode does. You ask the question; the orchestrator you picked staffs the research across the workspace's whole multi-vendor lineup and hands you the synthesized, cited answer — like the session in the first screenshot. And because izzedo plans are a flat bill with fair use running quietly in the background (no token math, no credit ledger — plan details live on the pricing page), the economics above work for you: a session that costs several times less to serve leaves several times more room in your usage for the next one.

One expensive brain, four cheap ones. It's how you'd staff a real team — it turns out it's also how you should staff an AI one.

---

Want to see a Parallel Agents session run on your own question — with the whole multi-vendor lineup one toggle away? Try izzedo chat free — no credit card required.