At Microsoft's Copilot Studio architecture bootcamp in London, one of the engineers from Microsoft's Copilot Acceleration Team said that instructions are abused by everybody, and developers are the worst. The line went straight into our second AI wave session. If you've built an agent, there's a fair chance you've done it as well.
Someone looks at a process and says "right, let's build an agent". In the session the example is Hartley Hale & Marsh, a property law firm that exists only in our demo. Every contract lands in a shared mailbox and goes through seven checks by hand. The instinct is to point one agent at the lot.
Then come the instructions. Every if-statement goes in, along with every job, every exception and every format, and before long there are six pages. The results are average, so the model gets upgraded to the bigger, better one, and eventually the results are good. It looks finished, but two problems are hiding in it, and now that agents are going into real business processes both of them show up.
Problem one: the credits keep climbing
The newer agents don't answer in one go. They make a plan, do some work, check it, do more and check again, and each of those cycles is a turn. The model is called again on every turn, and the instructions are sent every time. Every step of the work re-reads all six pages, the context compounds from turn to turn, and the credits used per turn rise with it. Then all of that runs on the most expensive model.
The eye-watering per-run bills come from this, and the agent usually isn't doing anything especially hard to earn them. It was built inefficiently.
We're in no position to lecture. In the session, Tony Brooks admitted to burning thousands of dollars' worth of tokens a month on his own flat-rate plan with an AI provider. On a flat plan you never feel it. In the enterprise you now do, because Copilot Credits put a meter on every run, and on the GitHub Copilot harness building consumes credits too. How that meter works has a piece of its own.
Problem two: more context, worse answers
The second problem feels backwards. The premium models now have a context window, the amount you can give an agent at once, of around a million tokens. That's roughly all of The Lord of the Rings, with the film scripts and The Hobbit on top.
The thinking goes that there's plenty of room and everything can go in. Long-context studies keep finding that the advertised window isn't the effective one: as the context fills, reasoning and recall can drop well before the window is anywhere near full. Our rule of thumb with some models is to stay around 20 to 30 per cent full. Past that you risk context rot, where the agent drifts off track, misses things and starts making errors.
Put the two problems together and you get a higher bill and less reliable answers at the same time. The usual fix for average results, a bigger model, only makes the bill worse. We've done this ourselves, and we see it in the organisations we work with.
What to do instead: take things out
The fix is mostly subtraction.
- Keep instructions to what's always true: the agent's role, its limits, its tone and the shape of its reply. Instructions are a soft guardrail that shapes behaviour without enforcing it, so writing more of them doesn't buy more control. A rule that must never be broken doesn't belong in a paragraph the agent might lose track of.
- Pull out the deterministic steps. Whether the lot is already under contract or the buyer is registered for GST are lookups and rules, and in Copilot Studio a workflow carries those steps for a fraction of a credit each. The agent is saved for steps that need thought, such as working out who's really buying, so each step gets the level of intelligence it needs.
- Put repeatable tasks into skills. Drafting a deficiency letter has a right way to do it. As a skill, only its name and a short description travel with every turn, and the agent reads the full instructions when it needs them. Our piece on skills goes further, including how the demo agent's instructions open by limiting it to three jobs and leaving everything else to workflow steps.
A check you can do this week
If you have an agent in a pilot or in production, put it on a diet.
- Open its instructions. If you have to scroll for a while, that's your first clue.
- Go through them line by line and sort each one. If it's true on every run, keep it. If it's a rule or a lookup, move it to a workflow step. If it describes how to do one task, make it a skill.
- If you upgraded the model to get past average results, try stepping it back down once the instructions are lean, and compare the output.
- Measure what a run consumes before and after, so you know the change paid off.
The glossary entries for instructions, turns and context rot are a useful one-page reference to share with whoever maintains the agent.