GitHub Copilot Agent Mode Cost: What Four Coding Agents Cost Me

A few weeks ago I noticed my GitHub Copilot usage had quietly turned into a problem. I'd built a little assembly line of AI agents to chew through Jira tickets (a Planner, a Researcher, an Implementer, and a Reviewer, each handing off to the next), and it worked. It also seemed to be eating my monthly budget alive.

So I did the thing most of us skip: I actually measured it. What I found surprised me enough that I rebuilt the whole thing. Here's the story, with the real numbers.

First, the billing rug-pull

On June 1, 2026, Copilot moved to usage-based billing. Instead of fuzzy "premium requests," you now pay AI Credits: 1 credit = $0.01, billed on the actual input, output, and cached tokens at each model's rate. My plan gives me a fixed pool per month, and suddenly every token had a price tag.

The rate card matters, so here it is (USD per 1M tokens):

Stare at that last row. The default model is the most expensive thing on the menu, and output costs 6× input. Keep that in your head: it explains almost everything that follows.

The number that reframed everything

I ran the same planning task across different models. Same prompt, same work, just a different brain doing it:

A ~17× spread, from model choice alone. Not prompt engineering. Not context trimming. Just which model you point at the task. Once I saw this, I stopped obsessing over shaving tokens and started obsessing over putting the right model on the right job.

The real culprit wasn't the model, it was the handoff

Here's the part I didn't expect. In VS Code, when one custom agent "hands off" to the next, it does so inside the same chat thread. The new agent inherits the entire prior conversation.

Play that forward across four agents. By the time my Reviewer ran, its context contained the Planner's full reasoning, the Researcher's file exploration, and the Implementer's edit transcript, and it re-sent all of it on every single turn. The Reviewer was paying to re-read three agents' worth of chatter it didn't need.

The fix was almost embarrassingly simple: stop sharing the thread. I gave the agents a "blackboard": a folder of tiny handoff files:

.copilot-work/<TICKET>/
  ticket.md     # acceptance criteria   (Planner writes)
  plan.md       # the approach          (Planner writes)
  handoff.md    # exact files + how     (Researcher writes)
  changes.md    # what changed          (Implementer writes)
  review.md     # verdict + findings    (Reviewer writes)

Now each agent runs in a fresh chat and reads only the one file it needs. The Reviewer sees the acceptance criteria and a git diff, and nothing else. The agents live once in a shared repo and get symlinked into each project, so there's a single source of truth.

Then I measured a real ticket, end to end

This is where assumptions go to die. I instrumented the whole run by parsing VS Code's own logs and pricing each model call. A few things jumped out hard.

Agents make way more model calls than you'd guess. Agent mode fires one model request per tool iteration. A single planning run wasn't one call: it was 13. The Researcher made ~20. The Implementer (reading files, editing, running tests) made 14. My back-of-envelope math had assumed ~5 each. I was off by 3–4×.

So per-step costs were higher than the napkin said. My Planner run on GPT-5.4 mini: 13 calls ≈ 12 credits, and the billing dashboard confirmed it almost to the credit. A full ticket through all four agents came in around 46 credits (I watched my balance drop from 382 to 336).

A useful gut-check: a credit is a cent, so a ~46-credit ticket is about 46¢ of model spend. Cheap in absolute terms, but at hundreds of tickets a month, on a fixed pool, it's the difference between coasting and running dry.

Four lessons I didn't expect

1. "Free" local models weren't free. I'd put the Researcher and Reviewer on a local model to dodge the cost entirely. The Researcher promptly failed: it wouldn't reliably open the exact file I told it to, went searching instead, found nothing, and then hallucinated a plausible-looking but empty handoff. A free run that produces garbage isn't free; it costs you a re-run and your attention. I moved it to a cheap cloud model (~1 credit) and it just worked.

2. Match the cheapest reliable model to each job, not the smartest. The Implementer writes code, so it's tempting to give it the best model. But it's also the most iterative and output-heavy agent, which makes it the most expensive place to run a premium model. Meanwhile the Reviewer has a tiny footprint (small input, a few lines of output), so a top-tier model there costs almost nothing and its judgment is exactly where quality matters. The intuition is backwards from where I started.

3. Terse artifacts are a false economy. To save tokens, I'd made the handoff files extremely compact. Two things broke. The Planner dropped a responsive design requirement that lived in the Figma but never made it into the terse criteria, so it shipped unimplemented. And the thin handoff let the Implementer guess, and it duplicated ~70 lines of a component instead of sharing them. Once the budget wasn't the constraint, richer instructions paid for themselves immediately.

4. Make the agent verify its own work. I added one rule to the Implementer: run the tests and the linter before you finish. The very next run exposed a test that the old, no-verification pipeline had silently shipped broken. The cheapest QA is the agent checking itself before a human ever looks.

The meta-lesson: instrument, or you're flying blind

Every wrong assumption I had ("the handoffs are cheap," "local is free," "the planner is ~3 credits," "more concise is better") survived right up until I put a number on it. The logs don't even contain token counts, so I built a rough estimator (request count × assumed tokens × the rate card) and reconciled it against the billing dashboard. The estimate isn't exact, and that's fine: it's good enough to compare options, which is all I needed to make decisions.

If you take one thing from this: the model you pick per task dwarfs every clever token-trimming trick, and you won't know where your spend actually goes until you measure a real run. My agents weren't expensive because AI is expensive. They were expensive because I'd never looked.

Setup: GitHub Copilot custom agents in VS Code, four-stage Jira workflow, models mixed per-agent (cheap-but-reliable for retrieval, a strong model reserved for judgment). All numbers above are from a real ticket on my own machine in June 2026; per-call costs are estimated from VS Code logs and the published rate card, totals reconciled against the Copilot billing dashboard.