---
title: "What Running an AI Agent Team Costs, and How I Cut It"
date: 2026-06-29T00:00:00.000Z
description: "Running every agent on the top model burned days of budget fast. Here's how model tiering, lazy loading, and a cost-auditor agent made an AI team affordable."
tags: [AI agents, multi-agent systems, AI cost, Claude, token usage, AI engineering, developer productivity, build in public, agent orchestration, LLM cost]
canonical: https://vatsalshah.ca/blog/what-running-an-ai-agent-team-costs
---
## Introduction

**Nobody tells you that a team of AI agents has a bill. Mine ran the most expensive model on every agent, and it burned a week of usage in a couple of days.** Once I fixed that, the same team kept the speed and cost a fraction of what it did before.

This is the part of [multi-agent work](/blog/from-prompts-to-an-ai-engineering-team) people skip. The agents are not free, and if you run them naively the cost stops you before the quality does. Here is what it actually costs and the three changes that made it affordable.

**What you'll learn:**
- Why a naive multi-agent setup gets expensive fast
- How to match each agent to the cheapest model that can do its job
- Why loading less context is the same as spending less money
- The job of a dedicated cost-auditor agent

## The mistake: the best model on every agent

When I first set up the team, every agent ran on the most capable, most expensive model. It felt right. Better model, better work.

It was the wrong call. I had [one lead agent and a group of specialists](/blog/production-ready-ai-agent-architecture), and every single spawn used the top tier. Running that many expensive calls burned through a week of usage in days. The team was good, but I could not afford to run it.

The realization was simple. Most of the specialists are not doing open-ended hard reasoning. They are pattern-matching against a clear set of rules. The reviewer checks the change against review rules. The test agent follows the testing rules. That work does not need the most expensive model. Only the lead, which plans and makes the judgment calls, does.

## Fix one: model tiering

So I put every agent on a tier. The lead agent keeps the top model, because planning and judgment are where the expensive reasoning earns its cost. The specialists run on a cheaper, faster model, because following a clear set of rules does not need top-tier reasoning.

Most of the team moved to the cheap tier. The rule is strict: every time an agent is started, it has to declare which model it uses, and nothing silently upgrades to the expensive one. If a task genuinely needs the top model, that is a deliberate, approved exception, not the default.

The result was most of the cost gone, with almost no drop in quality, because the cheap model is perfectly good at the rule-following jobs.

## Fix two: lazy load, because context is money

The second cost is quieter. Every instruction you load into an agent is tokens, and tokens are money, on every single call. If every agent reads the whole rulebook and every other agent's full profile every time, you pay for all of it constantly.

So the team reads a lean core first, and pulls in an agent's full profile only when that agent is actually needed. The detailed instructions load on demand, not by default. You are not paying to carry knowledge the current task never uses.

This is easy to miss because it does not look like a cost. It looks like organization. But loading less context is one of the most direct ways to spend less.

## Fix three: an agent whose only job is cost

The last change was to make the cost someone's job. I added an agent, named SCROOGE, whose only role is to watch for waste. When a new skill or agent is added, SCROOGE reviews it for bloat, for instructions that load when they do not need to, and for missing lazy-load gates.

Putting cost in its own agent matters because efficiency is the thing everyone skips when they are focused on the feature. A dedicated reviewer keeps the bill from creeping back up as the system grows.

## What I would tell you

- Do not run the best model on everything. Put each agent on the cheapest model that can do its job, and keep the expensive model for planning and judgment.
- Make the model tier explicit on every agent. Never let a cheap job silently upgrade to the expensive model.
- Treat context as money. Load a lean core and pull in detail on demand, because every token rides on every call.
- Give cost an owner. A dedicated efficiency reviewer keeps the bill from creeping back up.

## Conclusion

A team of AI agents is not a free upgrade. It is a system with a running cost, and the naive version is expensive enough to stop you. The speed was never the hard part. Making the speed affordable was. Tiering the models, loading less, and giving cost its own owner is what turned a team I could not afford into one I run every day.

<FAQSection
  title="Frequently Asked Questions"
  questions={[
    {
      question: "Why is a multi-agent setup expensive?",
      answer:
        "Each agent is a separate set of model calls, and the naive setup runs the most expensive model on every one. With a lead agent and several specialists all on the top tier, the calls add up fast. I burned a week of usage in a couple of days before fixing it.",
    },
    {
      question: "What is model tiering?",
      answer:
        "It means matching each agent to the cheapest model that can do its job. The lead agent keeps the top model for planning and judgment. The specialists, which mostly follow a clear set of rules, run on a cheaper, faster model. Most of the team moved to the cheap tier with almost no drop in quality.",
    },
    {
      question: "Does a cheaper model hurt quality?",
      answer:
        "Not for the rule-following jobs. A reviewer checking a change against review rules, or a test agent following testing rules, does not need top-tier reasoning. The cheap model handles that well. The expensive model is kept for the open-ended planning where it earns its cost.",
    },
    {
      question: "How does loading less context save money?",
      answer:
        "Every instruction loaded into an agent is tokens, and you pay for tokens on every call. If each agent reads the whole rulebook every time, you pay for all of it constantly. Loading a lean core and pulling in detail only when needed cuts that ongoing cost.",
    },
    {
      question: "What does a cost-auditor agent do?",
      answer:
        "It is an agent whose only job is to watch for waste. When a new skill or agent is added, it reviews it for bloat, for instructions that load when they should not, and for missing lazy-load gates. It keeps the bill from creeping back up as the system grows.",
    },
    {
      question: "How do you stop costs from creeping back up?",
      answer:
        "Make the model tier explicit on every agent so nothing silently upgrades to the expensive model, treat context as money by loading on demand, and give cost a dedicated owner that reviews new additions. Cost control has to be a standing rule, not a one-time cleanup.",
    },
    {
      question: "Is a team of agents still worth it after the cost?",
      answer:
        "Yes. Once tiered and trimmed, the team kept its speed at a fraction of the original cost. The point is that the naive version is expensive enough to stop you, so the cost work is what makes the speed usable day to day.",
    },
  ]}
/>

## Further Reading

- [From prompts to an AI engineering team](/blog/from-prompts-to-an-ai-engineering-team)
- [Designing a product AI agents can use](/blog/designing-a-product-ai-agents-can-use)
- [Production-ready AI agent architecture](/blog/production-ready-ai-agent-architecture)