5 min readBy JJ Eaton

Why configured AI agents still beat one smart model

Smarter models don't kill configured agents. They cut token waste, let you update one role everywhere, and let project captains run the work.

Dark dashboard with two project captain cards in progress, showing running agents, waiting work, and open pull requests

People keep saying that once models are smart enough, you won't need named agents, roles, or a kitchen of specialised prompts. Just give one model everything and let it cook.

I don't buy it. A model's intelligence is not why configured agents are a good idea. Even as the frontier models get better, the setup still wins on cost, control, and how much work you can leave running without babysitting it.

Three reasons configured agents still win

1. Reduced usage. If every agent carries every system prompt and every skill, you bloat the context on every turn. That is money and latency you burn before the model has done anything useful. Skills should only apply to the agents that need them. Different roles get different system prompts. Each role can call different subagents. The model stays focused, and the token bill stays sane.

2. Central control. When your agent setup lives as files, you change one agent in one place and it propagates across every machine and harness you use. I don't want to edit 53 configs every time a new model drops. Literally all I have to do is open that specific agent's settings on any one of my machines, pick the new model or harness, and every future thread across my devices picks it up.

3. Autonomy. I talk to project captains. They manage the team doing the work based on the knowledge I have already set them up with. That is the difference between "chat with a smart model" and "run a software kitchen while you are on a beach." Captains know the project, the skills, and the limits. You steer the direction; they run the day-to-day.

None of those three depends on the model being dumb. They get more valuable as models get smarter, because smarter models with bloated context still waste tokens, and smarter models with no central config still drift every time you change tools.

Why I keep the agents in files

I will die on this hill: file-based agents are the best agent architecture for anyone running more than one role.

Nobody wants to rebuild their whole agent setup every time a new model drops. File-based agents mean:

  • No moving agents around harnesses
  • No moving agents around computers
  • No managing the same skills in multiple places
  • Skills only load for the agents that need them, which keeps context smaller
  • Custom system prompts per task or role
  • Each role can use different subagents

The point is portability and focus. Your "review" agent is not your "captain" agent. Your bookkeeping agent does not need your image-editing skills. When the next model lands, you swap the model on the agents that should use it and leave the rest alone.

How I actually use a review agent

I also think adversarial reviews are usually a waste of tokens. A second agent arguing with the first for sport burns money and often lands on nitpicks.

My review agent focuses on security and performance. It is allowed at most three review passes, so it knows it is limited on corrections. That cap matters. Without it, review loops keep spending tokens long after the useful feedback is done.

Where I do like adversarial work is ground-breaking ideation and new concepts. Most of my big innovations have come from rubber-duck time with the model, not from making two agents fight over a pull request.

So the pattern for a business team is simple:

  • Build roles with a job. Captain, reviewer, specialist — each with a clear brief and only the skills they need.
  • Cap the expensive loops. Reviews, research, and rewrites should have a hard stop.
  • Save the open-ended debate for ideas, not for every line of production code.
  • Keep the config in files so one person can update a role once and every machine follows.

What this means for a business

If your team is paying for AI coding tools, or you are about to, here is the practical take:

  • One mega-prompt is a cost centre. Stuffing every instruction into every call looks simple and gets expensive fast.
  • Roles cut waste. A review agent that only checks security and performance, with a three-pass limit, is cheaper and more useful than an unbounded "argue with the author" loop.
  • Central config is operational hygiene. When a model, tool, or policy changes, you want one place to update it — not a scavenger hunt across laptops and chat threads.
  • Autonomy needs structure. Project captains only work if they already know the project, the standards, and who does what. That knowledge belongs in the agent files, not in your head for every session.
  • Smarter models don't remove the need for this. They make the cost of a messy setup more obvious.

You do not need my exact fork or my exact kitchen to get the benefit. You need named roles, small skill sets, a file-based source of truth, and hard limits on the loops that burn tokens for little gain.

Where to start

If your team is adopting AI coding agents and the bill, the chaos, or the review quality feels off, it is worth a proper look at how the work is actually structured. That is part of what we cover in a Build Things AI readiness audit: which workflows to automate first, how to keep costs under control, and how to set up agents so a smarter model makes you faster — not just more expensive.

Sources