KokoAI Loops — The Whole Series in One Sitting

Koko: Token costs are projected to fall ninety-five percent by 2030. And over that same period, what enterprises actually spend on AI is rising — fast. AI bills tripling while per-token costs decline. That is not a paradox. That is a loop.

Sam: Which sounds like a riddle until you think about it for about thirty seconds, and then it sounds like every utility bill I have ever had. The unit gets cheaper, I use more units, somehow I owe more money.

Koko: Exactly. And the piece we are spending today with — KokoAI Loops, the whole series in one sitting — that is exactly where it starts. Not with the technology. With the bill.

Sam: Because a prompt buys one model call. A loop buys a call per turn, until it decides it is done. And if nobody is watching how many turns that is, nobody can budget it.

Koko: Which gets you to the sentence the whole series is built around. An unobservable loop is an unbudgetable one.

Sam: Great sentence. Slightly uncomfortable to hear if you have already signed a contract.

Koko: So let's make the thesis crisp, because KokoAI Loops — the whole series in one sitting — is doing something specific. It is not a product pitch and it is not a glossary. It traces one actual piece of work, end to end, and shows you every moving part.

Sam: The piece of work being a month-end close. Tuesday, close lands Thursday, three reconciliations still open.

Koko: Right. And the system picks it up. It reads the procedure the controller wrote. It reads the sub-ledger, the bank feed, the journal entries posted since Friday. Two reconciliations clear. The third doesn't.

Sam: Intercompany balance won't tie. Counterparty's ledger already closed.

Koko: And here is the moment the piece wants you to pause on. The system does not stop and wait. It does not force the match to make the number go away. It writes a proposed accrual, attaches the evidence, routes it to a human, and reports back: two cleared, one escalated, still inside the close calendar.

Sam: The plan broke. The process didn't. That line is doing a lot of work.

Koko: Because that is the distinction between a loop and everything else you might call AI. A loop plans, acts, observes, compares against the goal, and goes again — stopping on a condition someone decided in advance. The key question is who runs the retry loop. In a chat box, that's you. In a loop, it's the system.

Sam: And the piece is very pointed that a prompt, an API account, a tool catalog, a fixed workflow — none of those is a loop by itself. Each is real, each is useful, but none of them keeps going until the close is done.

Koko: That one sentence, the piece says, saves a procurement cycle. I believe it.

Koko: Let's walk through the numbers, because this piece is unusually disciplined about sourcing. Every figure is timestamped — taken August eighteenth, twenty-twenty-six — and the Gartner projections run to twenty-thirty. The piece flags when a number moves and records the date. Which is, as it puts it, the same argument in miniature.

Sam: A claim published without the metadata to check it later can only be withdrawn, not graded. I appreciate that. It's a high bar that most AI commentary does not clear.

Koko: So: token costs down ninety-five percent, Gartner, by twenty-thirty. Agent operating costs up fivefold in two years. And separately — from what the piece calls a second independent evidence set — AI bills are tripling while per-token costs decline.

Sam: Those two data points together are the whole cost argument. Cheaper units, more consumption, bigger total bill. And the mechanism is the loop — because a loop multiplies the number of calls per piece of work.

Koko: Then there's a figure on the SaaS side that doesn't get enough attention. Enterprise SaaS prices rose seventeen percent year over year. And unnecessary token consumption — the always-loaded tax, which we should come back to — adds uncontrolled operational spend on top of that.

Sam: The always-loaded tax. So what is that?

Koko: Someone has a valuable procedure — say, a capital-approvals playbook — and they want the agent to always have it available. So they load it on every run. Every routine question now carries that playbook. Not once. On every turn of every run, forever. Used in two percent of the work, paid for in one hundred percent of it, multiplied by the length of the run.

Sam: And nothing errors. Nothing is slow. The bill just comes in higher than the model made it look.

Koko: Which is the most common self-inflicted cost problem in agent design, according to the piece. And it is motivated by entirely reasonable caution — you want the agent to be ready.

Sam: Good intentions, expensive outcome. That is a recurring theme in enterprise technology.

Koko: The piece's own analysis puts it plainly: enterprises without agent context management will see AI ROI erode faster than projected.

Sam: And the fix is what the piece calls progressive disclosure. Skills — packaged procedures — load only when the work matches. Only the cover card sits in front of the model by default. The full procedure loads when needed. A shelf of binders: you read the spines, you pull one down.

Koko: Not because it makes the model smarter. It doesn't. It packages and isolates a procedure you already trust, so the same known-good procedure runs every time.

Sam: Okay, here's where I want to push back a little, because the piece could read as very conservative. Contracts, refusals, materiality gates, value cards, traces before the first run. That's a lot of scaffolding before anything actually happens.

Koko: The piece anticipates exactly that read. And it says clearly: the evidence does not say wait.

Sam: It says a major professional services firm has deployed agents with manager-level autonomy in accounting. Which contradicts the idea that you need governance frameworks to mature before you can move.

Koko: Right. And it also says enterprises scaling fastest are accumulating the most unmitigated exposure before governance exists. Both true simultaneously.

Sam: So the thesis is not go slow. It is — control is what lets you move. It is not what delays you.

Koko: And the organizations getting hurt are not the ones who governed too early. They are the ones who scaled with no contract, no trace, no value card — and then could not say what anything cost, what it touched, or whether it worked.

Sam: I'll grant that. But there's a softer caveat buried in the piece that I think deserves airtime. The productivity gains from this technology are, on the piece's own reading, accruing to a small vanguard rather than the median employee.

Koko: It's honest about that. Nothing in the piece is an argument that a finance function stands up a portfolio of loops in a quarter.

Sam: Which is the kind of thing that is easy to lose in the excitement of a fivefold cost projection and manager-level autonomy in accounting.

Koko: And here is the nuance on tools that I think is genuinely reframing. The word tool sounds like something the model possesses. The piece says it's the opposite. A tool is a bounded promise about a system you own. Your organization issued it, the way it issues a key card.

Sam: So the question is not what can the agent do — that's a vendor question. It's what have we agreed it may do. That's yours.

Koko: And there are four categories of action that cannot carry a materiality gate — no dollar threshold makes them routine. Submitting a filing outside the enterprise. Changing master data. Changing an agent's own registry state. And enforcing a governance decision — blocking or containing an agent.

Sam: That last one. An agent that can lift its own quarantine is not governed. It is supervised by something it controls.

Koko: The piece's version: nobody reconciles their own account. Every controller already holds that principle. It just has a new application.

Sam: And an approval gate, by the way, is also a cost decision — not just a control decision. Route to a human and the item waits. Machine time becomes calendar time. Often the right trade. Never a free one.

Koko: So if you are a CFO or a controller and you have been nodding along, here is what the piece actually wants you to do. And it is more concrete than most things in this space.

Sam: Five steps. Second one is the slow one.

Koko: Name three loops in your own process vocabulary. Not the AP bot — invoice control. Not the reconciliation AI — account reconciliation, intercompany matching, accruals and estimates. Three names because they are three different pieces of work with three different owners and three different ways of going wrong.

Sam: The rule being: if you cannot say what a loop is for in one sentence without the word 'and,' it is two loops.

Koko: Then write one skill — the procedure for the first loop, as it is actually performed, not as the policy document says. Write the contract: what may it read, what may it change, what needs a named human regardless of amount. Insist on the trace before the first run. And write one value card.

Sam: The value card being one lever — revenue, margin, working capital, productivity, risk — one baseline, and one anti-double-count key.

Koko: That last piece is the one that gets skipped and destroys credibility fastest. A collections loop and a receivables-forecast loop can both plausibly claim the same days of working capital. Add them up and your portfolio reports a benefit larger than the balance sheet has room for.

Sam: At which point every number it ever produced becomes suspect. Not just the double-counted one. All of them.

Koko: The unit of measurement, by the way, is not cost per token, not cost per seat, not number of agents deployed. It is cost per accepted outcome, per loop. A loop that takes twenty turns and produces a reconciliation a controller signs is cheaper than one that takes four and produces something reworked by hand.

Sam: Token accounting flatters the second. That line deserves a Post-it on someone's monitor.

Koko: And the piece ends with a point I want to highlight, because it's genuinely useful regardless of whether you ever run an agent. The artifact you produce along the way — the written-down procedure — is useful whether or not an agent ever runs it. It is the one input no vendor can supply.

Sam: Which is a quietly radical thing to say in a piece about AI. The most durable output might be the document.

Koko: The piece credits its conceptual framing to dadloop, an agent harness built and published by Swami Chandrasekaran at KPMG — Partner and Global Head of AI and Data Labs. He explained a harness through Dad. The piece explains one through the close. It is generous about that attribution in a space where that generosity is rare.

Sam: And the finance domain, the loop library, every figure — those are the piece's own. The teaching device is borrowed; the substance is not.

Koko: So here is the question I keep coming back to. The piece makes a strong case that record to report is where to start — not because it is the most valuable, but because the procedures are most written down and the controls most mature. You find out fastest whether this works in your organization.

Sam: But the honest forward question is: as the vanguard captures the early advantage, what does the second mover actually have access to that the first mover didn't? Is the gap a quarter? A year? Permanent?

Koko: The piece doesn't answer that. I don't think anyone can yet. What it does say is that the organizations who will answer it well are the ones who can read their own trace — who can say what a loop cost, what it touched, and whether it worked.

Sam: Which requires having built the trace. Which requires having insisted on it before the first run.

Koko: The full, source-verified piece — KokoAI Loops, the whole series in one sitting — is on Koko Knows. Every figure, every source, every date it changed. That's the version worth reading slowly.

Sam: Or in one sitting, apparently.

Koko: That's what it says on the tin.