The Starvard sealStarvard.
English
EnglishFrançaisEspañolहिन्दीPortuguêsBahasa IndonesiaAll languages →
Starvard University

The Starvard Blog

Notes from the free university

The Real Cost of Running a Team of AI Agents: The Agent Stack, With Receipts

October 20, 2026 · By the Starvard professors
Robot agents at a desk buried under a long curling receipt, with coin stacks and a meter
Illustration by Starvard (AI)

Token prices have collapsed, yet Uber burned through its entire 2026 AI coding budget by April. This post works through the receipts: the real price sheets, the snowball math that makes one agent task cost as much as a thousand chat messages, the caching discount that saves everything and breaks silently, the full agent stack, a line-by-line monthly bill for a five-agent team, and the human review line that costs nine times the machines.

Here is a sentence you have probably heard some version of this year:

“AI is basically free now. Tokens cost fractions of a penny. You can hire a team of AI agents for less than your coffee budget.”

And here is another sentence, which TechCrunch reported in June 2026:

Uber blew through its entire 2026 AI coding budget by April.

Both of these things are true at the same time. That’s weird. It’s like being told that bricks now cost a tenth of a cent each, and then watching someone go bankrupt building a garden shed.

This post is about that weirdness. We’re going to figure out what it actually costs to run AI agents, not one clever chatbot, but a team of them, doing real work, every day. We’ll start from the very bottom (what is a token, and why does anyone charge for it?) and climb all the way up to a line-by-line monthly bill for a five-agent team. Along the way we’ll look at the real price sheets, the real companies, and the real horror stories, and we’ll be honest about which numbers are hard facts, which are estimates, and which are a salesperson smiling at you.

Grab a snack. It’s a long one.

Part 1: The Meter in the Wall

Let’s start with the most basic question. When you “use” an AI model, what are you paying for?

You’re paying for tokens. A token is a chunk of text, roughly three-quarters of a word in English. “Hamburger” might be two or three tokens. A typical page of a novel is somewhere around 400 to 500.

Every time you talk to a model, two streams of tokens flow:

  1. Input tokens: everything you send in. Your question, the instructions, any documents you attached, and (this is the important part, remember it) the entire conversation so far.
  2. Output tokens: everything the model writes back, including, for “thinking” models, all the reasoning it does before answering.

Output is always more expensive than input, usually about five times more, because generating text one token at a time is much harder work for the hardware than reading text in.

So the meter in the wall is simple: (input tokens × input price) + (output tokens × output price). That’s it. That’s the whole business model of every AI lab’s API.

Here’s the thing to hold onto: the meter doesn’t care whether the work was useful. It doesn’t care if the model got the answer right, wrong, or went in circles for an hour. It counts tokens. A plumber at least has to show up to bill you; a token meter bills you for the plumber thinking about showing up.

Part 2: The Price Sheet (October 2026)

Let’s look at the actual menu. These are list prices from the official pricing pages of Anthropic and OpenAI as of mid-October 2026, in dollars per million tokens (written “MTok”).

Anthropic (Claude)

(Haiku 5.5’s prices rise to $0.50 / $2.50 for prompts over 100,000 tokens. Batch processing, meaning “do this whenever, I’m not waiting,” is 50% off across the board.)

OpenAI

Two things jump out.

First, look how similar these are. The cheap tiers match to the penny. The middle tiers match to the penny. The top tiers match on input and output. Whatever else is going on in AI, the frontier labs have arrived at nearly identical prices for nearly identical slots. For you, the buyer, that means the price of a token is mostly not the thing you should be agonizing over. (Hold that thought. It’s the thesis of the whole post.)

Second, look at the spread. The top tier costs 100 times more per token than the bottom tier. That’s not “premium vs. regular gas.” That’s “a bicycle courier vs. a helicopter.” Choosing which model does which job turns out to be one of the biggest levers you have.

And these prices have been falling fast. Epoch AI, a research group that tracks this stuff, found that the price of getting a fixed level of capability has been dropping somewhere between 9x and 900x per year depending on the benchmark, with a median around 50x, and the decline sped up after January 2024. A separate MIT analysis (“The Price of Progress”) put the decline for frontier-level performance at a more modest 5x to 10x per year, and estimated that about 3x per year of that comes from pure algorithmic efficiency. Either way: the bricks keep getting cheaper.

So how is anyone going broke?

Part 3: Why an Agent Is Not a Chatbot

Let’s define our terms, because “agent” has become one of those words that means everything and nothing.

A chatbot is a vending machine. You put in a question, it drops out an answer. One transaction. Done.

An agent, in the definition Anthropic’s Barry Zhang uses in his well-known talk, is just a model using tools in a loop. That’s it. The model looks at the situation, decides to do something (search the web, read a file, run some code, click a button), sees the result, and then decides what to do next. Over and over until the job is done, or until it gives up, or until something stops it.

That loop is the entire story of agent costs. Let me show you why with a little thought experiment.

The snowball

Imagine you hire an assistant with a very strange disability: they have no memory at all between sentences. Every time they want to say something, you have to hand them a written transcript of everything that has happened so far in the job, and they have to read the whole thing before speaking.

On turn 1, the transcript is short. On turn 10, it’s long. On turn 40, it’s a novella. And you pay them by the word for both the reading and the talking.

That is exactly how language models work. They are stateless. Each step of an agent’s loop sends the full history back in as input. Every file the agent read, every search result, every error message, every one of its own previous thoughts, all of it gets re-read, and re-billed, on every single subsequent step.

So the cost of each step grows, and the total cost of a task grows faster than the number of steps. Engineers describe this as quadratic growth: double the steps, and you roughly quadruple the input bill, not double it.

Let me put numbers on this, using Sonnet 5.5’s list price. These are my own illustrative assumptions, not measurements from any particular product, but they’re in a realistic range for a coding agent:

Run the arithmetic and you get:

Now for comparison, a simple chat exchange (2,000 tokens in, 500 out) on the same model costs less than a penny. The agent task is nearly a thousand times more expensive than a chat message, while using the exact same price per token.

And if the agent flails and takes 80 steps instead of 40? The bill doesn’t double to $15. It goes to about $26.50.

This is why the “tokens are nearly free” crowd and the “we blew our budget” crowd are both right. The price per token fell. The number of tokens per task exploded. Anthropic, in its engineering write-up on its multi-agent Research feature, reported that in its data, agents typically use about 4x more tokens than chat interactions. And that’s just one agent. We haven’t built a team yet.

Gartner, in an analysis from March 2026 (as summarized by Cockroach Labs), put the range at 5 to 30 times more tokens per task than a standard chatbot. EY has made a similar point from the other direction: by its estimate, a customer-service chat cost around 4 cents in 2023, while an orchestrated agent workflow in 2026 runs around $1.20, about 30 times more, because the “answer” now involves tools, reasoning, sub-agents, and retries. (Those are EY’s estimates, not invoices, but the direction is consistent with everything else here.)

Part 4: The Discount That Saves Everything (And How It Breaks)

If the story ended there, agents would be economically doomed. But there’s a hero in this story, and its name is prompt caching.

Remember that most of what an agent sends each step is the same stuff it sent last step, plus a little new material on the end. The labs noticed this. So they let you cache the repeated part: the first time, you pay a bit extra to store it, and after that, re-reading it costs a tiny fraction of the normal price.

Look back at the price table. Sonnet 5.5 input is $2 per million tokens. A cache read is $0.10. That’s 95% off.

Rerun our 40-step task with caching working properly, and the bill drops from $7.66 to about $1.33. Here’s how the same task looks across the model lineup (cost of the 40-step task, without caching versus with caching):

*Haiku figures are a floor: I priced them at the under-100K rate, and the later steps of this task cross that line.

Caching turns agents from “absurd” into “plausible.” It is the single biggest reason the economics work at all. Which makes it all the more painful that caching is fragile.

A cache only works if the beginning of the prompt is exactly identical to last time. Change one character near the top and everything after it is a “miss,” billed at full price. Here’s a real example: in a GitHub bug report filed against the open-source agent OpenClaw in February 2026 (issue #19534, as described by Cockroach Labs), a user discovered that their 170,000-token context was being fully reprocessed on every single request. The culprit? A “current date and time” field in the system prompt that changed every turn, which broke the cache every turn. Their costs were running about 10x higher than expected. One tiny clock, ten times the bill.

Caches also expire. Anthropic’s default cache lasts five minutes on the API (an hour on subscriptions, or longer if you pay for it). Claude Code’s own documentation explains that if you walk away for a coffee and come back after the cache lifetime, your next message reprocesses your entire context at full price. Arena, the model-evaluation group, calls this the “$1 to say hi” problem in one of their videos: a long-running session, a long lunch, and a one-word message that costs a dollar.

So the first lesson of agent economics is: you are not really paying for tokens. You are paying for context. And whoever manages context best wins.

Part 5: From One Agent to a Team

Now let’s do the thing in the title. What happens when you go from one agent to a team of agents?

The popular image is an org chart: a “manager” agent that breaks down a job and hands pieces to “worker” agents, who go off and do their parts in parallel and report back. This is real, and it can work beautifully. It’s also where costs go from “noticeable” to “eye-watering.”

Here’s why. Each agent on the team has its own context window, its own snowball. Five agents means five snowballs rolling at once, plus the manager’s snowball, which grows as the reports come in.

The best public receipt we have comes from Anthropic itself. In its write-up on building the Research feature, Anthropic reported:

Anthropic’s Claude Code documentation gives a similar number for its “agent teams” feature: approximately 7x more tokens than a standard session when teammates run in plan mode, and the docs plainly say token usage is roughly proportional to team size.

So a team isn’t free leverage. It’s a deliberate trade: spend 7x to 15x more, and in exchange get work done in parallel, faster, and (for the right tasks) better.

“For the right tasks” is doing a lot of work in that sentence. Anthropic’s own post is candid that tasks where all the agents need to share the same context, or that have lots of dependencies between steps, aren’t a good fit for multi-agent systems today. Research is a good fit: ten sub-agents can each investigate a different source without needing to talk to each other. Many coding tasks are a bad fit: if Agent A changes a function that Agent B is also editing, you get chaos, rework, and more tokens. The team only pays off when the work genuinely splits into independent pieces.

The honest rule of thumb: a team of agents is a way of buying speed and breadth with money. If you don’t need the speed or the breadth, you’re just buying the money’s absence.

Part 6: The Rest of the Stack (Tokens Aren’t the Whole Bill)

So far we’ve only talked about the model. But a working agent isn’t just a brain in a jar. It needs hands, eyes, a desk, and someone watching over its shoulder. Each of those is a separate bill from a separate vendor. Let’s walk through the stack, layer by layer, with real price tags.

Layer 1: The brain (model API)

Covered above. This is usually the biggest line item for the machinery itself.

Layer 2: The desk (a sandbox to run code)

If your agent writes code, it needs somewhere safe to run that code, an isolated computer that it can’t use to wreck anything real. This is called a sandbox.

Compared with tokens, sandbox compute is usually small change. The catch is that it’s billed while the sandbox is alive, not while it’s busy. An agent that leaves sandboxes idling is paying rent on empty rooms.

Layer 3: The eyes (a browser)

Agents that need to use websites (fill out forms, check a dashboard, scrape a page) need a real browser running somewhere.

Layer 4: The library card (web search)

Layer 5: The security camera (observability)

When an agent goes wrong, and it will, you need to see what it did, step by step. These step-by-step records are called traces. Anthropic noted in its Research write-up that standard logging wasn’t enough and it had to build custom tooling to understand agent behavior.

Layer 6: The office manager (orchestration and hosting)

Something has to start agents, keep them running, restart them when they crash, and shut them down. You can build this yourself, or rent it.

Here’s the whole stack in one picture:

Notice something: every layer except the brain is cheap per unit. It’s the brain, and specifically the brain re-reading its own snowball, that dominates the machine bill.

Part 7: How Vendors Package It (Seats, Quotas, and Outcomes)

Most people don’t build their own stack. They buy an agent product. And here the pricing gets interesting, because vendors have to decide who eats the risk of the snowball.

There are basically three models.

Model 1: The subscription (vendor eats some risk, you eat the limits)

Pay a flat monthly fee, get a usage allowance.

The flat fee is the bait; the quota is the hook. Heavy agent users blow through allowances fast, and that’s where “usage credits” come in.

Model 2: Pay-as-you-go (you eat all the risk)

Pay API rates for every token. This is how most businesses run coding agents at scale. Anthropic publishes unusually concrete numbers here. According to Claude Code’s cost documentation, across enterprise deployments:

That last stat is the one to stare at. The average is moderate. But the distribution has a long tail, and a long tail is where budgets go to die.

Model 3: Pay for outcomes (the vendor eats the risk)

This is the newest and, honestly, the most interesting model. You don’t pay for tokens or seats. You pay when the agent succeeds.

Outcome pricing is a fascinating signal. A vendor willing to charge per resolution is betting it can make the snowball cheap enough to profit. It shifts the risk of a flailing agent from you to them. If you’re buying agents for a well-defined, high-volume job like support tickets, this is often the least scary way to start, because a failure costs you nothing (except the annoyed customer).

Part 8: Let’s Build the Bill, A Five-Agent Team, Line by Line

Enough theory. Let’s actually price out a team. I’ll be very explicit about my assumptions so you can swap in your own. Every number in this section is an estimate I made using the list prices above. It is not a measurement of any real company.

The scenario: a small software team runs five coding agents. Each agent handles about 20 tasks per working day (bug fixes, small features, test-writing), over 22 working days. That’s 2,200 tasks a month. Each task looks like our 40-step example, on Sonnet 5.5, with caching working well.

Line by line:

So: about four thousand dollars a month for five agents doing 2,200 tasks. That’s roughly $1.85 per task, all-in on the machinery. Note that tokens are about 70% of it, and the retry line, the cost of the agents being wrong, is the second-biggest item.

Now let’s play with the dials, because this is where it gets dramatic:

The same five agents, doing the same 2,200 tasks, can cost anywhere from under $3,000 to over $20,000 a month, purely depending on engineering decisions that have nothing to do with the sticker price of a token. That is the receipt. That is the whole post in one paragraph.

Part 9: The Line Item Nobody Puts in the Spreadsheet

But wait. We forgot someone.

Who checks the agents’ work?

Agents produce output. Someone has to review the pull requests, approve the refunds, read the research summary and decide whether it’s true. In almost every serious deployment today, that someone is a human. And humans are, by a wide margin, the most expensive part of the stack.

Let’s add one more line to our five-agent team. Suppose each of the 2,200 tasks needs just 10 minutes of human review, by an engineer whose fully loaded cost (salary, benefits, overhead) is around $100 an hour. (That’s a rough assumption; plug in your own.)

2,200 tasks × 10 minutes × $100/hour = about $36,700 a month.

The machine bill was about $4,100. The human review bill is nine times larger.

This changes how you should think about everything. The most important cost-saving feature in an agent isn’t a cheaper model. It’s output that’s easy and fast for a human to verify. An agent that costs $3 a task but produces clean, well-tested, obviously-correct work is far cheaper than one that costs $0.50 a task but produces plausible-looking work that takes a human 30 minutes to untangle.

And here’s the uncomfortable part: we’re not even sure the humans are being sped up.

In July 2025, METR, a nonprofit AI research group, published a randomized controlled trial with 16 experienced open-source developers working on 246 real tasks in codebases they knew well. Before starting, the developers predicted AI tools would make them 24% faster. When measured, they were 19% slower. Even afterward, they still believed AI had sped them up. METR was careful to say this applied most to experts working on large, mature codebases, and that the tools were early-2025 tools.

METR’s attempted follow-up in 2026 ran into a revealing problem: many developers, especially the ones who’d benefit most, didn’t want to accept a “no AI allowed” condition, which wrecked the experimental design. According to a write-up of that work, METR’s own view is that AI tools probably do make developers faster in early 2026 than they did in early 2025, but the measurement is genuinely hard. A separate METR survey of 349 technical workers found people reporting large gains, but self-reports are exactly what the original study showed you can’t fully trust.

Other data from TechCrunch’s June 2026 reporting points the same murky direction. Faros AI’s two-year study of 20,000 developers found output rising, but also bugs and rewrites. Jellyfish found that the engineers who used the most tokens were about twice as productive as lighter users, but burned about 10x as many tokens getting there. Jellyfish’s head of research, Nicholas Arcolano, put the conclusion plainly: the best return comes from moving the broad middle of engineers from low to moderate usage, not from pushing heavy users even higher.

Read that twice. 2x the output for 10x the spend. Whether that’s a good deal depends entirely on what the output is worth, which, as Arcolano also noted, most companies still can’t measure.

Part 10: When It Goes Wrong, The Horror Story Wing

Every new technology gets a museum of expensive mistakes. Here’s agents’ wing so far, with a reliability label on each exhibit.

Exhibit A: The budget that lasted four months. (Well reported.) Per TechCrunch, citing The Information and Bloomberg, Uber encouraged employees to use AI as much as possible, even ranking usage on internal leaderboards, then blew through its annual AI budget in about four months. It responded by capping spending at $1,500 per employee per month, per agentic coding tool (like Claude Code or Cursor), with exceptions by permission.

Exhibit B: The industry-wide hangover. (Well reported.) In the same June 2026 TechCrunch piece: Microsoft revoked its developers’ Claude Code licenses months after enabling them; a Priceline employee said a routine Cursor contract renewal came back 4-5x more expensive; and J.R. Storment of the FinOps Foundation said companies were telling him in April and May that they were 3x over their entire 2026 token budget. Jellyfish measured per-developer consumption rising about 18.6x in nine months. The Linux Foundation responded by announcing a “Tokenomics Foundation” to create cost-accounting standards for tokens, the way FinOps did for cloud spending.

Exhibit C: The $40,000 engineer. (Single-source anecdote.) Faros AI’s CEO Vitaly Gordon told TechCrunch that a CTO confided one engineer had spent $40,000 on tokens in a month, and the CTO genuinely didn’t know whether to stop him or tell everyone else to copy him. That indecision is the real story.

Exhibit D: The half-billion-dollar bill. (Unverified.) Axios reported, and TechCrunch repeated, that one unnamed company ended up with a $500 million Claude bill after forgetting to set employee usage limits. No company was named, and I couldn’t find confirmation. Treat it as a cautionary tale, not a data point.

Exhibit E: The infinite loop. (Widely shared, single account.) A Hacker News post described a team whose four agents got stuck passing work back and forth in a loop for 11 days, running up about $47,000 before anyone noticed. It’s been retold endlessly as the canonical “runaway agent” story. It’s one team’s account, but it illustrates the mechanism perfectly: nobody had a hard budget ceiling, only dashboards that someone had to look at.

Exhibit F: The hobbyist’s cloud bill. (Single account.) In June 2026, a highly upvoted Hacker News post described an agent tasked with joining and scanning a hobbyist network that ran up a $6,531 AWS bill. Note that this cost wasn’t tokens at all; it was the actions the agent took in the world. Agents don’t just spend money thinking. They can spend money doing.

The common thread in every exhibit: alerts are not limits. A dashboard tells you after the fact. A hard cap stops the bleeding. Barry Zhang listed “budget-aware agents” (ones that know and respect their own time, token, and money limits) as one of the big open problems in his talk. It’s still open.

Part 11: The Hype vs. Reality Ledger

Let’s step back and tally it up honestly.

What’s real:

What’s hype:

The big paradox. Economists have a name for what’s happening: the Jevons paradox. When steam engines got more efficient in the 1800s, Britain didn’t use less coal; it used vastly more, because coal-powered work became worth doing in more places. Tokens are the coal. As they get cheaper, we don’t spend less. We build agents that use a thousand times more of them. Goldman Sachs projects global token usage will multiply about 24x by 2030 (per TechCrunch). Falling prices and rising bills are not a contradiction. They’re the same phenomenon.

Part 12: A Field Guide to Running Agents Without Lighting Money on Fire

If you take nothing else from this post, take these. They’re roughly in order of how much money they save.

  1. Measure cost per completed task, not cost per token. This is the only number that matters. A cheap model that takes three tries is more expensive than a pricier one that gets it right once. Track tokens, retries, and human review time per task.
  2. Set hard caps, not alerts. Put a ceiling on tokens or dollars per session, per agent, per day. Cap the number of loop steps. When an agent hits the limit, it stops and hands off to a human. Uber’s $1,500 cap is a blunt instrument, but it’s an instrument.
  3. Protect your cache like it’s your rent money. Keep the start of your prompts stable. No timestamps, random IDs, or reshuffled tool lists at the top. Watch your cache-hit rate. (Claude Code’s /usage command now shows the share of input served from cache and names likely causes of misses.)
  4. Keep context small. Start fresh between unrelated tasks. Summarize (“compact”) long histories. Have tools return only what matters: a test runner that returns 3 failing lines instead of 3,000 passing ones saves money on every step afterward. Claude Code’s docs give a nice example of a hook that filters test output down to just failures.
  5. Route by difficulty. Use the cheapest model that does the job. A 100x price spread between tiers means even a crude router pays for itself. Use Haiku-class models for simple sub-tasks, Sonnet-class for most work, and reach for the top tier only when the cheaper one measurably fails.
  6. Use batch when you can wait. Both major labs give 50% off for asynchronous batch jobs. Overnight report generation doesn’t need real-time pricing.
  7. Only use a team when the work genuinely splits. Parallel research? Great. Five agents editing the same files? You’re paying 7-15x for a traffic jam.
  8. Optimize for verifiability. The human reviewer is your most expensive component. Make agents write tests, show their sources, and keep changes small. Easy-to-check output is the biggest saving of all.
  9. Consider outcome pricing for well-defined jobs. If you’re buying a support agent, paying per resolution moves the snowball risk onto the vendor.
  10. Remember that agents spend money doing, not just thinking. Any agent with access to cloud accounts, payment methods, or external APIs needs spending limits on those, too.

The Bottom Line

Let’s go back to where we started: bricks are almost free, and people are still going bankrupt building sheds.

Now we know why. The brick, the token, really is cheap and getting cheaper. But an agent doesn’t use a few bricks. It rebuilds the whole shed from scratch every time it wants to add one more plank, because it can’t remember the shed is there. A team of agents is several builders all doing that at once. The labor watching the builders costs more than all the bricks combined. And if nobody puts a fence around the job site, the builders will happily keep building until the money runs out.

None of this means agents aren’t worth it. For the right work, big, repetitive, parallel, easy to verify, they can be astonishingly cheap compared with the alternative. But “the right work” and “a well-engineered stack” are doing all the heavy lifting. The companies getting good value out of agents in late 2026 aren’t the ones who found the cheapest tokens. They’re the ones who know, for every task, what it cost, whether it worked, and who had to check it.

The meter in the wall only counts tokens. You have to count everything else.

Why this belongs at Starvard

Starvard is a free university, and free matters most when the meter is running. Nobody needs a corporate budget to learn here, but everyone who builds with AI agents needs to know what the work actually costs before the bill arrives, which is why this post lives at Starvard. Start with AI Agents on a Budget, which turns this post’s levers (protect the cache, route by difficulty, set hard caps) into a step-by-step playbook for running agents on very little money. Then take AI Agents: Your First $10,000 for what to build and sell once the costs are under control, and keep The Money Index Card: All of Personal Finance on One Card nearby for the personal version of the same skill: knowing where every dollar goes, and why.

Watch

Sources

Tagged: Technology · Business · AI Agents · AI Agents Making Money · AI Entrepreneurship

Back to the blog

A note on accuracy: Much of what you read at Starvard was created with help from AI agents, working alongside people. We check what we can, but we cannot guarantee that everything here is true, current, or complete. If something really matters, your health, your money, a grade, a job, please verify it with a trusted source before you rely on it.