Past the Good-Agent Plateau: An Investment Map for Compounding AI

A team ships a genuinely clever agent. It drafts the code, summarizes the ticket, answers the customer. The demo lands, the budget renews, and then the next twelve months go like this: a better prompt here, a sharper system message there, a model swap that buys a few points. Twelve months, maybe five percent. The agent is fine. The program is stuck — and it’s stuck because the org has been measuring the agent, when the only thing that compounds is the organization wrapped around it.

This is the plateau, and almost every AI program hits it. The question this paper answers is not “how do we get a better agent?” Within thirty seconds you should already feel the reframe: a good agent is a one-time purchase, and you can always buy a bigger one. A program that gets better at getting better is a different kind of asset — it earns interest. The board-level decision is which one you are funding, and most boards are funding the first while expecting the returns of the second.

The plateau is a measurement error

The plateau has a single root cause: you are pointed at the wrong unit. “How good is the agent?” feels like the question because the agent is what you can see, demo, and benchmark. So that’s what gets optimized — prompt by prompt, eval by eval — and it improves on a curve that flattens fast, because raw task quality was never the binding constraint.

The binding constraint is organizational. A program can accumulate a thousand “lessons” from a thousand runs and still learn nothing, because storage is not learning. If those lessons are never compressed into a reusable rule, if nobody ever measures which way of working actually raised the pass rate, if the next task starts cold instead of pre-briefed — then you have an archive, not a capability. The agent is being asked to carry weight the organization should carry. That is why a better model doesn’t fix it: you are bolting more horsepower to a vehicle with no transmission.

So the executive move is to change the scoreboard. The metric that predicts whether your AI spend compounds is not benchmark quality. It is the rate at which the program improves its own agents — and that rate is observable, fundable, and the rest of this paper is about reading and raising it.

Reading the tier you’re actually on

There are four tiers, and a program sits on exactly one of them per capability — not because of how smart its agents are, but because of what its organization does with experience.

1. 01Tool-useragents run; nothing is remembered between them
2. 02Learning orgruns are captured, classified, distilled into principles
3. 03Self-improvingmeasures which interventions move the metric; trains on them — under approval
4. 04Self-directedpicks its own next improvement by risk-adjusted return — still gated

A tool-user runs good agents that forget everything the moment they finish; every task starts from zero. A learning org captures each run, classifies it, and compresses clusters of runs into reusable principles — experience stops evaporating. A self-improving program goes further: it runs experiments on its own working methods, learns which intervention actually raised the pass rate, and trains its weakest agents on the intervention that works — but every training move waits for approval. A self-directed program adds one thing: it chooses which weakness to fix next by expected payoff, and proposes that to a human rather than just executing it.

Notice what the tiers are not about: none of them is “a smarter model.” You can drop a frontier model into a tool-user and it stays a tool-user. The climb is about what the organization does between tasks, which is precisely why money spent on the model axis stalls and money spent on the organizational axis compounds.

The three faculties that actually compound

What separates the upper tiers from the plateau is the mechanization of three things skilled humans do without thinking. Each one is a concrete mechanism you can build, audit, and put a metric on — not a metaphor.

One — distill experience into principles. A senior engineer doesn’t remember every bug; they hold a handful of rules abstracted from hundreds. The fleet does the same mechanically: near-duplicate lessons are merged (text-similarity clustering, the validated lesson wins), and when a cluster of lessons under one skill grows past a threshold, they are generalized into a single principle. Weak lessons — low effectiveness, low confidence with no validation, or outright failures — are retired. The archive shrinks while the signal grows. That curation step is the whole difference between a learning org and a hoarder.

Two — know which way of working pays. Most programs can’t tell you whether their last quarter of “improvements” helped, because they never ran the comparison. A self-improving fleet treats its own working methods as experiments: each intervention (a research pass, an adversarial review, a different orchestration order) is logged with its win rate, and the methods are ranked by what actually moved the number. You stop guessing which practice helps and start measuring it.

Three — walk in pre-briefed. The most underrated human edge is starting a task already knowing the relevant context. The fleet brings the distilled principles to the front of each task: before an agent acts, it is briefed from the accumulated, curated experience for that skill. The briefing is the compounding asset — it’s what makes task N+1 cheaper and sharper than task N, and it’s the thing a competitor can’t acquire by renting the same model you did.

Put together, these three close a loop: runs produce lessons, lessons distill to principles, experiments reveal which interventions pay, and the next run starts briefed by what worked. That loop — not the model — is the engine. Its coverage is measurable: the share of tasks that actually feed the loop is the single number that separates a program that compounds from one that merely runs.

Self-direction, on a leash

The top tier sounds alarming until you see the mechanism. A self-directed fleet decides what to improve next — but “decides” here means proposes under a hard approval gate, every time.

Concretely, the fleet’s strategist combines two signals it already has: where its agents are weakest, and which intervention has the best measured win rate. It computes a risk-adjusted return for each candidate improvement and recommends the highest one. Then it stops. It does not start the training run. The recommendation carries approval_required: true as an invariant — the strategist can read the fleet, rank the options, and make the case, but a human or a policy approves before anything touches the agents.

{
  "recommendation": {
    "address_skill": "sql",
    "using_intervention": "research",
    "roi_score": 0.72,
    "rationale": "sql is weakest (pass-rate 0.2, severity 0.9); research has the best measured win-rate (0.8) -> train sql with research",
    "approval_required": true
  },
  "alternatives": [
    { "address_skill": "css", "using_intervention": "research", "roi_score": 0.40 },
    { "address_skill": "async", "using_intervention": "research", "roi_score": 0.32 }
  ],
  "evidence": { "weakest": ["sql", "css", "async"], "best_intervention": "research", "intervention_spread": 0.5 }
}

This is what makes self-direction fundable. The fleet earns reach the same way a person earns it: a reversible, cheap-to-undo step (run the test suite, lint a diff) can execute on its own, while anything that changes the agents themselves or ships to a customer waits at propose. The gate moves outward one action-class at a time, only as the evidence for that class holds up. The cost of a held-back good proposal is a few minutes; the cost of an un-gated bad one is a regression baked into every future task. You set each gate to that imbalance, not to a model’s accuracy number. Autonomy is something the fleet is granted in slices, after it has shown the receipts — never switched on wholesale.

Compounding versus accumulating — what the CFO sees

The economic distinction is sharp, and it shows up on the per-task line. An accumulating program spends to run agents and spends again, every quarter, to keep them current; its archive of “lessons” grows but its cost-per-task is flat or rising, because nothing in the archive is reused and the model keeps getting more expensive work. A compounding program inverts this. Each curated principle makes the next task start further along, so cost-per-task falls as the loop matures.

There’s a second structural saving the mature programs share: they push the bulk generation to cheap local models and reserve expensive frontier reasoning for the small slice where judgment actually matters — orchestration and verification. An immature program does the opposite, paying frontier rates to generate boilerplate it will never reuse. So the mature program is cheaper on two axes at once: it reuses more, and it pays less for each unit of work.

• Tasks that feed the learning loop5–15%→85–95%Compounding
• Lessons compressed into reusable principles~0→clustered & retired on cadenceSignal density
• Improvements chosen by measured win-rateguessed→ranked by ROIDirection
• Generation routed to local vs. frontiermostly frontier→local-first, escalate rarelyUnit cost

The line that matters to a CFO is the first one. A program where 90% of tasks feed the loop is buying interest on every run. A program at 12% is buying a subscription. Two programs can demo identically and sit on opposite sides of that line — which is exactly why the demo is the wrong thing to fund against.

Where most programs sit — and the next dollar

Be honest about the starting point: most AI programs today are tool-users with a learning-org veneer. They’ve stood up named agents and maybe a memory store, but the loop isn’t closed — lessons pile up uncompressed, no one measures which intervention pays, and tasks start cold. The diagnostic is brutal and quick: of last week’s tasks, what share produced a principle you’ve reused since? If you can’t answer, you’re below tier 2 no matter what the roadmap slide claims.

Treat the program as a set of capabilities at different tiers, not one blended grade, and fund the climb where the next rung returns the most.

CapabilitySits atNext rungPosture Code review & refactorself-improving→ self-directedearn the gate Test generationlearning org→ self-improvingfund next Incident triagetool-user→ learning orgclose the loop Contract draftingtool-userhold Customer-facing copylearning orgwatch

The next dollar almost never buys a bigger model. For a tool-user capability it buys the closed loop — capture, classify, distill. For a learning-org capability it buys the experiment layer that tells you which intervention actually works. For a self-improving one it buys the governed strategist and the audit trail that let it earn the gate. Each is a small, specific build that raises the compounding rate — and the compounding rate, not the benchmark, is the return you are underwriting.

The board’s scorecard and the bet

The bet is not “will AI work.” It’s whether you fund the axis that compounds. Four numbers tell a board which axis it’s on, and a demo can fool none of them: the tier each capability sits on, the share of tasks that feed the learning loop, the cost per task as the loop matures, and the share of fleet-altering actions that are gated and reversible. A program that can recite those four is climbing. A program that answers with a demo is on the plateau and doesn’t yet know it.

At each funding gate, ask four things: Which capability moved up a tier, and on what evidence? Did loop coverage rise toward reuse? Did cost per task fall as principles accumulated? Is every move that touches the agents themselves gated and reversible? Release the next tranche only when those answers hold. That is how you buy a capability that earns interest instead of a clever agent that depreciates.

The program worth funding is not the one with the most impressive agent in the room. It’s the one whose agents are measurably sharper than they were last quarter — because the organization around them learned how to make them so, and can prove it at the gate.

---

References: NIST AI RMF · NIST CSF 2.0 · capability maturity model (CMMI lineage) · local-first / frugal-inference architecture · propose-only agent governance patterns.