What Running an AI Agent Team Costs, and How I Cut It

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 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, 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.

Further Reading

• From prompts to an AI engineering team
• Designing a product AI agents can use
• Production-ready AI agent architecture