Back to the reconciliation one last time, and this time to the first thing that happened rather than the interesting thing in the middle.
Before it read anything, the loop picked up a procedure: the close checklist. It says which accounts to check, in what order, what counts as tied and what to do when something is not. Your controller wrote it. It is not a clever prompt. It is the same document that has run your close for years.
Now the part worth noticing. Your organization has dozens of procedures like it: revenue recognition, tax provision, capital approvals, supplier onboarding, dispute handling and the rest. The loop picked up one of them. The others were never read, never considered and never paid for.
That is progressive disclosure, and it is the difference between an agent that gets cheaper as you add procedures and one that gets more expensive.
What a skill actually is
A skill is a packaged procedure in its own file. It has two parts:
- a short cover card: a name, and a plain sentence saying when to use it, and
- a body: the full procedure, plus links to whatever reference material it needs.
Only the cover card sits in front of the model by default. The body loads when the work matches the description.
Think of a shelf of binders in a controller's office. You read the spines. You pull one down. You do not read forty binders to find out you needed the close one, and neither should the system, because here reading is not free.
The most common misunderstanding
A skill does not make the model smarter.
This is worth being blunt about, because a lot of enthusiasm around "agent skills" quietly assumes the opposite. A skill packages and isolates a procedure you already trust. It adds no new reasoning ability. What it changes is which proven procedure the system runs, and whether it runs the same one every time.
That is exactly why finance is the strongest ground for this technology, though it is not the reason usually given.
- Finance teams have spent decades writing down how work is done. The procedure exists. It is reviewed. Someone owns it.
- Turning it into a skill is packaging, not writing from scratch.
- The alternative, having a model rebuild your close from general knowledge every time, is both more expensive and much worse.
The always-loaded tax
Here is the mistake that costs real money, and it is made for an entirely reasonable reason.
- A team has a valuable procedure.
- They want the agent to always have it.
- So they put it in the material that loads on every single run: always available, always ready.
Now every routine question the agent handles carries that procedure along. Not once: on every turn of every run, forever. A capital-approvals playbook used in two percent of the work is paid for in one hundred percent of it, and because a loop takes many turns, that cost is multiplied again by the length of the run.
This is the always-loaded tax, and it is the most common self-inflicted cost problem in agent design. It shows up on no dashboard. Nothing errors, nothing is slow enough to notice, and the bill simply comes in higher than the model made it look.
Splitting the description from the body is what avoids it. You pay for the spines and pull the binder you need.
Our own reading of the field puts a number nearby:
- Enterprise SaaS prices rose 17% year over year.
- On top of that, unnecessary token use (an "LLM tax" nobody budgeted) adds operating spend no one controls.
The conclusion we draw is direct: companies without agent context management will see their AI ROI erode faster than projected. Context management is not a technical hygiene topic. It is the cost lever with the least resistance behind it.
Writing the description is the real work
If only the description loads by default, then the description is the trigger. It is how the system decides, in the moment, that this piece of work is the one this procedure was written for.
So a useful description is a very specific thing: it states the case in the words someone would actually use, not the words the procedure would use about itself.
- A trigger: "Month-end close and reconciliation procedure. Use when balances need to tie, sub-ledgers need agreeing, or an intercompany difference needs resolving before a close date."
- Just a title: "Financial period-end operational framework."
Getting this wrong does not produce an error. It produces a skill that quietly never fires, while everyone assumes it works because it exists.
Skill, specialist or fixed pipeline?
The same capability can be packaged three ways, and picking the wrong one is a common and expensive mistake:
- A skill: a procedure loaded on demand when the description matches. Best when the procedure is known, written down and reused across varied situations.
- A specialist: a separate instance you hand work to, with its own context and its own limited tool list. Best when you want isolation and a clean handoff, and when the specialist should be unable to do most things.
- A fixed pipeline: the same steps, in code, every time. Best when you want an identical, auditable path and no judgment at runtime at all.
The third deserves more respect than it gets in agent conversations. If the work has one correct sequence and no real decisions, a fixed pipeline is cheaper, faster, easier to audit and less likely to surprise you. Choosing an agent for something a pipeline handles is not sophistication. It is paying for judgment you did not need.
And a skill does not run anything. It describes and hands off. The running happens in a specialist or a pipeline. Treating the three as interchangeable is how a design conversation runs for an hour without anyone establishing what will actually happen at runtime.
What this means for the close
Put parts one, two and three together and the reconciliation reads as a design rather than an anecdote:
- One loop that keeps going until the work is done.
- One skill, loaded because the work matched it.
- Three read contracts into systems it was allowed to see.
- One proposal, because posting was not its call.
- A record of all of it, which is what lets the run be priced.
Next: the finance team's own library of these. What to name, how to group them, and how to fund a portfolio of loops rather than a pile of pilots.
The starter pack. The ten skills named in the catalog in part four, and the other thirty-seven in the finance registry, ship as real assets:
SKILL.mdfiles with the frontmatter this piece describes,- finance-domain JSON schemas for the objects they read and write, and
- the tool contracts behind them, with the approval posture of each.
There are two tiers, each labeled: ten written as trigger metadata, and thirty-seven derived from the registry and marked for rewriting. Browse or download it at Finance Agents → Skills pack (access code required).
The framing of this series (a harness taken apart into six named parts, a single run traced from start to finish, and a catalog of named skills) is inspired by dadloop, an agent harness built and published by Swami Chandrasekaran, Partner and Global Head of AI & Data Labs at KPMG (LinkedIn · github.com/swamichandra/dadloop). The teaching devices are his; the finance domain, the skill library and every figure here are ours.