Research · v1.0.1

Earned Autonomy: Taking Over the Suggestion Function One Decision Class at a Time

Lars Shakya Buch-Jepsen

v1.0.1Latest stable release: 2026-11-20

Introduction

Systems that make real decisions – what to maintain, what to reorder, how to pace a game, how to change infrastructure – increasingly route those decisions through large language models. Two engineering framings dominate the discussion.

The first treats the model as the decision-maker: prompts and agents are engineered so that a model, locally or remotely hosted, evaluates options and chooses. The second treats the model as a cost center: calls are routed, cached, cascaded, and distilled so that easy cases never reach the expensive model [1]. The second framing has a metric – reduced calls, reduced spend – and systems built under it are judged by that metric.

This article is written from an engineering position: we maintain a continuously-running prediction system (a six-layer linear-recurrent cluster) together with a decision layer whose pattern descends from a long-running code-transformation agent that has operated it in production for an extended period. From that vantage point, the second framing describes what the measured numbers look like from the outside, and it is wrong about the mechanism. The system does not get cheaper at asking a model. The suggestion function is progressively taken over, one decision class at a time, by local mechanisms that earn autonomy from journaled evidence. The measured language-model-call reduction is the evidence metric of that takeover, not its goal.

The distinction is not rhetorical, because the two framings make different predictions and demand different machinery. A system engineered as a call reducer keeps a fixed inventory of models and a router; its locally-handled fraction plateaus when the routing table saturates, and its failure mode is a wrong route. A system engineered as a takeover keeps an inventory of decision classes that grow into local autonomy; its locally-handled fraction rises as classes are earned, and its failure mode – which the machinery must make impossible – would be a class that promotes without evidence. The goal of the takeover is progressive independence from non-local model handling: a self-contained system whose routine decisions are local, journaled, validated, and auditable, with language models only at the edges – novel-case escalation, explanation, and human-in-the-loop drafting.

We specify the takeover as the suggestion ladder, with the mechanism set that makes it honest, and we state three properties that any claimed autonomy must satisfy: it is earned (never trained into existence, never assumed), it is revertible (as a unit, at any time), and it is measured (the independence claim is re-tested continuously, not asserted once).

The suggestion ladder

Autonomy in this design is not a property of a model but a lifecycle stage of a decision class. Every class travels the same ladder.

The suggestion ladder. The direction of travel is upward; decay makes it a cycle rather than a ratchet. {#tbl:ladder}
Stage Meaning Evidence held
Advised A suggestion is produced (by a model, a rule, or a human) but never acts None yet
Journaled Suggestions and their outcomes are recorded as fingerprinted decision records Outcome pairs accumulate
Validated A candidate class passes deterministic replay of recorded outcomes on fixtures A validation report
Automated A signed promotion batch moves the class to local execution, behind a switch Batch hash, journal chain
Decayed A stale class demotes itself to journaled or advised and re-earns Drift statistics

Three features of the ladder deserve emphasis before the mechanism is described.

Classes, not models. The unit of takeover is a decision class: a named, bounded kind of decision (schedule this inspection, reorder this item, pace this scene, render this repeated transformation) with a defined context and a defined action space. The inventory of classes is the system’s real asset; models are interchangeable underneath it.

One at a time. Only one class per batch is new; the expansion gate is deliberately serial. This keeps the causal attribution of promotion effects clean: if quality moves, there is exactly one newly-promoted candidate to interrogate. It costs throughput and buys auditability – a trade this design makes without hesitation.

Cycles, not a ratchet. Non-stationarity is assumed, not handled as an exception. Classes decay toward the bottom of the ladder on a schedule and must re-earn their place, so the inventory is periodically re-proven against the world as it is now, not as it was when the class first promoted.

The mechanism set

The fingerprinted decision journal

The ladder’s foundation is a decision journal whose records are small by construction: decision class, context fingerprint, candidate action fingerprint, outcome, confidence, environment, timestamps, and a schema version. Raw text, prompts, and latent representations are never journaled. The discipline serves three purposes at once. Records are small enough to accumulate for years; they are privacy-safe enough to survive products that are resold to customers who must not have their data leave the product boundary; and they make provenance structural rather than aspirational – every automated decision traces to a journal chain and a promotion batch.

Journal writes are fire-and-forget from the consumer’s perspective: a failure in journaling must never break the host system’s main path. A suggestion system that can take down its host by remembering is not a suggestion system; it is a liability.

Conservative class statistics

Each class accumulates outcome statistics, and the numbers that matter are lower bounds, not point estimates. The workhorse is the Wilson interval [2]: with \(n\) decision points and \(\hat{p}\) successes, the promotion-relevant quantity is the lower bound

\[p_{\mathrm{lb}} = \frac{\hat{p} + \frac{z^2}{2n} - z\sqrt{\frac{\hat{p}(1-\hat{p})}{n} + \frac{z^2}{4n^2}}}{1 + \frac{z^2}{n}}\]

The design rule is that a class is a candidate for validation only with at least a minimum count of decision points (default 20) and only if the Wilson lower bound on precision clears a floor (default 0.97 in the reference system). Both numbers are policy configuration, not constants of nature – but the principle that a small-sample class must wait is treated as a constant. Sequential decision-making under uncertainty has a long statistical lineage [3], [4]; the ladder differs from bandit practice in that it does not optimize an arm online. It accumulates audited decisions offline and promotes or refuses on evidence thresholds.

Replay validation

Before any class promotes, its recorded outcomes are replayed against fixtures: recorded corpora (incidents, sessions, replays) where the correct outcome is known. The gate is deliberately unforgiving – the validation must pass 100% of its constraint checks, not a high percentage – because the class is about to run without supervision. The validation report is stored with the candidate, so a promotion can always be traced to the evidence that justified it. Validation runs offline, on the consumer’s schedule, which is also what makes the gate cheap: replaying a journal is embarrassingly parallel and touches nothing in production.

Hashed promotion batches

Promotion is the unit of change, and it is a batch: a signed, content-hashed set of class promotions and demotions. The batch is append-only in the promotion store; reverting is not an edit but a new event that atomically demotes every class in a batch. This gives the takeover its most important operational property: autonomy is revertible as a unit, in one step, at any time, with the revert itself journaled. Engineering cultures that operate production systems will recognize the pattern – it is the release, not the commit, that one rolls back – but here the release is autonomy.

The escalation router

At decision time, the router assigns each case to one of three routes. Local, promoted: a class with an earned, active promotion answers locally. Local, verify: a class in the middle of its ladder answers locally but is flagged for outcome checking. Escalate: novel or low-confidence cases go to a language model or a human, with the escalation journaled like any other route.

The router also carries the property that keeps the whole structure honest: a fraction of otherwise-promotable traffic is deliberately escalated anyway, in the \(\epsilon\)-greedy pattern. The escalation is not waste; it is the control condition. Without persistent escalation traffic, the system’s independence claim is unfalsifiable – promoted classes could be silently degrading with nothing to compare against. With it, drift shows up as a widening gap between promoted-route and escalated-route outcomes on the same classes, which is precisely what decay responds to.

Safety: kill switch, decay, re-earning

Every class carries a kill switch whose state changes are journaled; a killed class routes to escalation immediately and re-enters the ladder only by re-earning. Decay demotes classes whose statistics have aged or drifted – the takeover is thus periodically re-purchased rather than granted once. Irreversible actions (production infrastructure changes, destructive operations, irreversible campaign events) never route to the automated path at all: they require human approval per occurrence, permanently, regardless of how much evidence a class has accumulated. Autonomy over the reversible; accountability for the irreversible.

Independence, not reduction

The section this article exists to write.

Call-reduction engineering and the suggestion ladder share machinery: both route decisions, both measure how often the expensive resource is used, and both can point at the same descending call-count graph. The difference is what the system is for. Under the reducer framing, the descending graph is the product; under the takeover framing, the descending graph is the receipt.

Three consequences follow from taking the takeover framing seriously.

The inventory grows; the router shrinks in importance. A call reducer has strong incentives to stop once the frequent cases are cached or routed. A takeover has structural pressure to keep expanding the class inventory, because each earned class permanently widens the system’s locally-governed ground. The measured steady state in the reference system – more than 60% of relevant decisions handled locally, with per-class local-answer reduction of at least 40% at precision of at least 97% – is a snapshot of that growth, not a terminal condition.

The endpoint is a self-contained product. The takeover framing ends somewhere the reducer framing does not: a product that carries no runtime dependency on hosted or cloud inference at all, in which the presence of a language model is a per-product licensing decision rather than an operational assumption. This is not cost engineering; it is a statement about where the decision function lives – inside the shipped system, auditable by its owner – and it changes what can be sold, deployed, and trusted.

The honesty boundaries are load-bearing. Because the framing claims a system property (independence), the machinery must make the claim continuously testable: earned (promotions trace to journals and validation reports, never to training runs or vibes), revertible (batch-level, atomic, journaled), measured (\(\epsilon\)-escalation keeps the control condition alive). Remove any one and the takeover framing collapses back into the reducer framing it was supposed to correct – a cheaper router with an inflated self-description.

Relation to prior work

The statistical spine is classical: conservative small-sample intervals [2] and sequential design of experiments [3], [4]. The closest modern cousin is conservative offline policy learning, which likewise refuses to act on an unproven policy learned from logged data [5], [6]. The ladder differs in that it promotes discrete, named action classes under audit rather than a policy, and in that its promotion unit is designed for operational revertibility rather than purely for safe offline improvement.

Model routing and cascading is an active practice, with cost as the stated objective [1]. We adopt the routing mechanics and reject the objective: the same graph that a cascade reads as savings, this design reads as a takeover metric. The distinction matters because objectives leak into architecture – a cost objective optimizes the router and stops; an autonomy objective grows the class inventory and keeps its evidence current.

The machine-learning-systems-debt literature warns that the glue around models silently accumulates into the system’s real control flow [7]. The journal is the countermeasure here: it is the declared, inspected boundary where decisions and outcomes are recorded, so that what the system learned to do on its own is always enumerable. Governance frameworks ask for exactly this – traceable provenance, measurable behavior, human accountability [8]; the ladder’s mechanics are how those properties are delivered rather than promised.

Human-in-the-loop decision support is the advisor tradition: systems that suggest and humans who decide. The ladder is not an advisor that got confident. It is the deliberate identification of the routine decision ground where the system can be made accountable without a human in the loop – while permanently relocating the irreversible to the human. The replacement is bounded by evidence, not by ambition.

Implementation notes

The reference implementation behind this design is the six-layer linear-recurrent cluster mentioned earlier, with a decision layer whose pattern was developed and measured in a long-running code-transformation agent: journal, offline mining with Wilson lower bounds, fixture-replay validation, signed hashed promotion batches, a three-route escalation router with persistent \(\epsilon\)-escalation, kill switch, decay, and re-earning. Its measured gates – per-class precision of at least 97%, per-class local-answer reduction of at least 40%, a minimum of 20 decision points per class, and a steady state above 60% locally-handled decisions – are the defaults inherited by the extraction described next. These are measurements of that system, not constants; other domains must re-earn their own numbers.

The mechanism set has been extracted into a reusable kernel – six components (journal, mining, validation, promotion, routing, safety) exposed as interfaces in the prediction system’s public package, behind a master switch that defaults to off, with journal and promotion schemas versioned independently of package releases so consumers can journal before the kernel ships and migrate without rewrites. The kernel is in implementation per its specification. Two pilot consumers (a predictive-maintenance product and a demand-forecasting product) are specified to consume it without divergence; consumer rollouts across a game-opponent abstraction, a game-mastering abstraction, an operations agent built on deterministic chains, and several further products are specified and tracked. As of this draft the kernel and consumers are in implementation; the reference agent’s numbers above are the measured evidence that the pattern works where it was developed.

The article deliberately does not name the implementations, their repositories, or their deployments: it is written at the pattern level, and its claims are scoped to what the Evaluation status section can support.

Evaluation status

This draft separates claims into three tiers, per the collection’s honesty discipline.

Measured. The reference code-transformation agent has operated the full ladder in production, and its per-class gates (precision, local-answer reduction, decision-point minimums, steady-state share) are measured quantities in that system. They are quoted above as the defaults of the extraction, and they are measurements of one system in one domain.

Implemented. The ladder machinery itself (journal, mining, validation, promotion, routing, safety) is implemented and shipped in the reference system. The kernel extraction is implemented to its specification and in active integration; consumer rollouts are specified.

Not measured. No cross-domain claims are made. Whether the reference gates transfer to maintenance scheduling, demand forecasting, game pacing, or operations chains is precisely what the pilot consumers will measure, and this article claims nothing about it. The framing prediction – that locally-handled share keeps growing with the class inventory rather than plateauing like a saturated router – is a design claim supported by one system’s trajectory, not a law.

Limitations

First, the ladder inherits the honesty of its journals: outcome attribution is a design obligation of each consumer, and a consumer that journals outcomes dishonestly will earn autonomy dishonestly. The 100% replay gate catches some of this; it cannot catch all of it.

Second, the class taxonomy is a human design decision. One-at-a-time expansion keeps promotion effects attributable, but nothing in the mechanism guarantees that a taxonomy is good – that its classes are the right granularity for the domain. The design accepts this: taxonomies are code, reviewed like code, and decay gives wrong classes a graceful exit.

Third, decay handles drift but not regime change. A domain whose statistics break discontinuously will produce a batch of simultaneous decays – the system degrades to escalation, which is safe but loud – and rebuilding is manual work.

Fourth, the evidence base is one system. The number 40% is what the reference agent measured per class; it is reported because it is real, and it should be re-earned elsewhere rather than cited.

Fifth, the novelty claim – that autonomy should be earned per class through journaled evidence rather than trained or routed – is argued from design and reading, not from a comparison against trained alternatives; the planned consumer A/B programs are what would eventually support it.

Conclusion

Systems that route decisions through language models are usually described, and usually engineered, as either trusting the model or paying less for it. This article has argued for the third description, the one our production systems have been converging on: the decision function is taken over, one earned class at a time, by local mechanisms that journal their evidence, validate by replay, promote in revertible signed batches, and keep testing their own independence. The descending call-count graph is the receipt, not the product. The endpoint is a self-contained system whose owner can enumerate everything it learned to decide on its own, prove where each promotion came from, and revert any of it in one step – with language models, local or licensed, working only at the edges where novelty and explanation live. Autonomy that is earned, revertible, and measured is not a cheaper way to ask a model. It is a different way to own a system.

References

[1]
L. Chen, M. Zaharia, and J. Zou, “FrugalGPT: How to use large language models while reducing cost and improving performance,” arXiv preprint arXiv:2305.05176, 2023.
[2]
E. B. Wilson, “Probable inference, the law of succession, and statistical inference,” Journal of the American Statistical Association, vol. 22, no. 158, pp. 209–212, 1927.
[3]
W. R. Thompson, “On the likelihood that one unknown probability exceeds another in view of the evidence of two samples,” Biometrika, vol. 25, no. 3/4, pp. 285–294, 1933.
[4]
H. Robbins, “Some aspects of the sequential design of experiments,” Bulletin of the American Mathematical Society, vol. 58, no. 5, pp. 527–535, 1952.
[5]
S. Levine, A. Kumar, G. Tucker, and J. Fu, “Offline reinforcement learning: Tutorial, review, and perspectives on recent results,” arXiv preprint arXiv:2005.01643, 2020.
[6]
A. Kumar, A. Zhou, G. Tucker, and S. Levine, “Conservative q-learning for offline reinforcement learning,” in Advances in neural information processing systems, 2020, pp. 1179–1189.
[7]
D. Sculley et al., “Hidden technical debt in machine learning systems,” in Advances in neural information processing systems, 2015, pp. 2503–2511.
[8]
National Institute of Standards and Technology, “Artificial intelligence risk management framework (AI RMF 1.0),” National Institute of Standards; Technology, NIST AI 100-1, 2023.