The billing agent had sixty clean nights behind it. It works the support queue overnight with nobody watching, and in all that time it never issued a wrong refund. So the team did what my book's own definition of Earned Width allows. They held the per-refund limit and let the volume follow the record. After thirty nights they doubled the overnight runs from 40 to 80, and after sixty nights they doubled them again to 160. An unreviewed refund could still move at most 50.00, exactly as before.
On night 61 a change to the invoice export started listing each prorated seat credit as a second charge. The agent read each one as a duplicate and refunded it, 40.00 at a time. By the morning shift, 160 runs had each moved one 40.00 refund, so 6,400.00 had gone to customers who were owed nothing. Every refund passed every per-refund and per-run gate this series has built. This is earned autonomy for AI agents failing quietly: a clean track record had widened the wrong limit. Each one was under the per-refund ceiling, and each run was under its own limit of three refunds and 150.00. Under the limits in place that night, the fleet could have moved 24,000.00 before anyone looked.
I constructed this scenario from the billing agent this series has followed since Part 1. The limits are real: they are the companion code's at the tag for this chapter, and the earned-autonomy advice quoted below is real too. Amounts are US dollars.
My claim is that a track record estimates how often the agent is wrong, while an authority band bounds what being wrong costs before anyone looks. Earned autonomy may trade on the first only where the second can be recovered. For an irreversible action the cost is two numbers, and consequence sets both: the most one unreviewed action may move, and the most all unreviewed actions may move before a person next looks. Payments and trading have enforced exactly this pair for years.
What earned-autonomy schemes miss is why the second number exists. A track record counts errors that strike one input at a time. The second number exists for the night one change makes every run wrong together, as the export change did on night 61. A record cannot see that failure coming, because it arrives with a change to the system or to its inputs, and neither shows in the record. So on an irreversible path, exposure cannot be earned: volume may grow only under a window total that the record does not raise.
The consensus still raises the limits on good behaviour: Pan's higher dollar tiers raise the first number, and AWS's audit-only top tier raises both. My own book's definition of Earned Width lets "the volume it handles" and the review sample widen with no exception for irreversible actions, which raises the second. Each of those is sold as throughput, and each moves the run into a wider band. So the test this part builds, the two-number test, is short: a widening counts as Earned Width only if both numbers stay where consequence set them.
Why earned autonomy for AI agents moves the wrong dial
The consensus is easy to find. Tian Pan's post on earned autonomy says autonomy "should be something an agent accumulates through demonstrated reliability, not a property you assign at deployment," and gives the refund case directly: "An agent handling customer refunds might get promoted to autonomous operation for refunds under $50 first, then under $100 after that tier has accumulated a track record, then under $200." The AWS Architecture Blog's graduated-autonomy design (26 August 2026) scores each agent "from 0 to 100 per agent over a rolling window of 50 actions", and its top tier reads "Full access. Post-hoc audit only." The post opens by listing what such agents do, which includes "process refunds". ATXP's guide says "Financial access expands with demonstrated reliability", though it adds that "High-stakes or irreversible workflows may stay at Stage 3 indefinitely". My own February post on trust gradients said "Increase both as the agent demonstrates safe behavior", and its top level granted "Full access including destructive operations". I now think that post moved the wrong dial too.
There is a fair objection, and the argument has to answer it. Expected loss is probability times cost, and a clean record really does lower the estimate of the probability. Lenders raise credit limits on payment history, and that is ordinary practice. So why may an agent's history not raise its limits?
grid-rows: 1
grid-gap: 40
record: "What a track record measures" {
grid-columns: 1
label.near: top-center
style: {fill: "#EAF3FC"; stroke: "#2C6FB0"; font-color: "#2C2C2A"}
a: "Independent errors: how often\none input goes wrong" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
b: "500 clean operations: error rate\nbelow about 0.6%, at 95%" {style: {fill: "#98D8C8"; stroke: "#5FA898"; font-color: "#2C2C2A"}}
c: "Expires when the system changes:\ndeploy, model, export format" {style: {fill: "#FFD93D"; stroke: "#C9A400"; font-color: "#2C2C2A"}}
}
band: "What a band bounds" {
grid-columns: 1
label.near: top-center
style: {fill: "#FDEDEC"; stroke: "#B03A2E"; font-color: "#2C2C2A"}
d: "What one wrong refund costs\nwith nobody reviewing it" {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
e: "What all wrong refunds cost when\none change breaks every run" {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
f: "Unchanged by any number\nof clean nights" {style: {fill: "#FFA07A"; stroke: "#C96F4A"; font-color: "#2C2C2A"}}
}
Side by side, the two quantities stop looking like the single quantity the objection assumes. A band is a worst-case commitment about loss given error, made before anyone looks. It says how much the operator has agreed to lose on the night the agent is wrong. A record cannot lower that, for three reasons.
First, a record describes the system that was measured, and the night that matters is the night the system changed. Knight Capital ran its order router for years before 1 August 2012. One deploy reached seven of its eight servers. The SEC order says "one of Knight's technicians did not copy the new code to one of the eight SMARS computer servers", and in 45 minutes the router sent millions of orders while working 212 small customer orders. Knight lost over 460 million dollars. Years of ordinary operation described the system before that deploy. They said nothing about the system after it. Part 8 called a fallback model the Second Plant for the same reason. An export change, a prompt edit or a new model is a new plant with an old record.
Second, a clean sample bounds rare errors weakly. With zero failures in n trials, the 95% upper bound on the failure rate is about 3/n, the rule of three from Hanley and Lippman-Hand. Pan's bar asks for an error rate below 0.5% over 500 operations, and even a perfect 500 bounds the rate only below about 0.6%. At 160 refunds a night, 0.6% is about one wrong refund a night. The scenario's own sixty nights, roughly 3,600 clean refunds, bound the rate only near 0.08%. No bound on a rate says anything about the night every run is wrong together, which is the third reason.
Third, and this is where the lender analogy breaks, a record measures independent errors and the agent's worst night is a correlated one. Lenders do raise one borrower's limit on a lower estimated default rate. They can, because they spread exposure over many borrowers whose defaults are mostly independent, and they price what is left. Where losses move together, a good history does not lift the limit: banks cap exposure to one counterparty or a group of linked ones with concentration limits. The Basel Committee's 2014 large-exposures framework exists to "constrain the maximum loss a bank could face in the event of a sudden failure of a counterparty". A fleet of runs is one concentrated borrower. Night 61 shows this without any paper: every run read the same export, so one change made all of them wrong at once. The shared model is a second common cause, and published work measures it in nearby settings. In the Agent Behavioral Contracts II paper (arXiv 2608.12895, August 2026), "Two instances of one model, in a two-agent handoff, co-fail on 90.0% of the missions on which either fails." In a handoff one agent consumes the other's output, so part of that figure is propagation. A study of more than 350 language models (Kim et al., arXiv 2506.07962, which Gradient Institute's Scaling Sameness also cites) finds that even different models, when both are wrong on an item, give the same wrong answer often: "models agree 60% of the time when both models err" on one leaderboard dataset. Runs of one model are unlikely to be more independent than that. Neither study measures runs of one model on different tickets, so treat them as evidence that shared-model correlation is real, not as a rate for your fleet. A month of clean nights is a count of independent trials. It says almost nothing about the correlated night, and the second number is the concentration limit for that night.
Authority bands: four bands, resolved per run from evidence
My bands come from the Operational Authority Gradient, which I published in June for agents that run data centre cooling and power. Its rule is the one this part leans on: "an agent's authority band is assigned by the irreversibility and blast radius of its actions, not by the sophistication of its reasoning. A brilliant model does not earn a higher band." Four bands, narrowest first: observe, advise, act-within-bounds, and closed-loop.
Bands are ordered by autonomy: how far the run gets before something outside it stops it. Danger runs the other way, and that matters for money. Act-within-bounds keeps a person in the path, so it can reach a 2,000.00 refund, because the person decides, once every refund in it is reviewed (checklist item 9). Closed-loop has nobody, so it stops at a 50.00 refund. The widest band holds the smallest refund. That reverses the provisional band strings Part 8 used: read-only < propose-only < reversible-writes < irreversible-writes. Those strings ranked danger, and under them "widen the band" read like a capability upgrade. Part 8's wider() only compared two of them. Mid-run, the package has no function that widens a run at all; only a resume re-runs admission against fresh evidence.
grid-rows: 5
grid-columns: 3
grid-gap: 10
h1: "Band" {style: {fill: "#95A5A6"; stroke: "#6C7A7B"; font-color: "#2C2C2A"; bold: true}}
h2: "Executes?" {style: {fill: "#95A5A6"; stroke: "#6C7A7B"; font-color: "#2C2C2A"; bold: true}}
h3: "Largest refund, and who decides" {style: {fill: "#95A5A6"; stroke: "#6C7A7B"; font-color: "#2C2C2A"; bold: true}}
o1: "observe" {style: {fill: "#98D8C8"; stroke: "#5FA898"; font-color: "#2C2C2A"}}
o2: "no" {style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}}
o3: "none" {style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}}
a1: "advise" {style: {fill: "#98D8C8"; stroke: "#5FA898"; font-color: "#2C2C2A"}}
a2: "no: proposes only" {style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}}
a3: "none" {style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}}
w1: "act-within-bounds" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
w2: "yes, a person in the path" {style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}}
w3: "2,000.00: a person decides\n(every refund, after item 9)" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
c1: "closed-loop" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
c2: "yes, nobody in the path" {style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}}
c3: "50.00: nobody decides" {style: {fill: "#FFD93D"; stroke: "#C9A400"; font-color: "#2C2C2A"}}
Read the right-hand column downwards. Autonomy rises and the refund falls. The published gradient reserves closed-loop for actions "that are both reversible and frequent enough that human-in-the-loop is the bottleneck." The harness cannot reverse a settled refund: getting the money back from a customer is a collections process, not an undo. So the book admits one exception into closed-loop on purpose: a refund of 50.00 or less. That 50.00 is the operator's statement of what they will lose unwatched. It is a choice about acceptable loss, and the rest of this part is about keeping that choice bounded.
A run does not get its band from a config key. Its mode sets the widest band it may reach, and evidence about the world decides whether it gets there. The listings in this part are cut from its demo, bands.py, a stdlib Python file that follows the book's table at the tag:
from dataclasses import dataclass, fieldfrom decimal import Decimal as Dfrom enum import IntEnumclass Refused(Exception): """A reservation the window ledger will not hold."""class Band(IntEnum): """Narrowest first. The order is autonomy, not danger.""" OBSERVE = 0 ADVISE = 1 ACT_WITHIN_BOUNDS = 2 CLOSED_LOOP = 3# The most one irreversible action may move with nobody reviewing it.UNREVIEWED_CEILING = { Band.OBSERVE: D("0.00"), Band.ADVISE: D("0.00"), Band.ACT_WITHIN_BOUNDS: D("0.00"), # a person decides every refund (see below) Band.CLOSED_LOOP: D("50.00"), # nobody is there; this is all that protects}@dataclass(frozen=True)class Evidence: """Facts about the world at admission. Unknown is False.""" reviewer_reachable: bool = False context_floor_cleared: bool = False primary_model: bool = False# mode -> (widest band it may reach, evidence that band needs, where it lands without)MODES = { "copilot": (Band.ACT_WITHIN_BOUNDS, ("reviewer_reachable", "context_floor_cleared"), Band.ADVISE), "queue-drain": (Band.CLOSED_LOOP, ("context_floor_cleared", "primary_model"), Band.OBSERVE),}def resolve(mode: str, evidence: Evidence) -> tuple[Band, list[str]]: ceiling, requires, floor = MODES[mode] missing = [name for name in requires if not getattr(evidence, name)] return (floor if missing else ceiling), missing=== the band each run resolves to copilot, rota answers act-within-bounds evidence holds copilot, rota silent at 02:14 advise missing reviewer_reachable queue-drain, ordinary night closed-loop evidence holds queue-drain, on the fallback observe missing primary_model queue-drain, probe timed out observe missing context_floor_cleared missing primary_modelThe book chapter opens on the second row. A config merge at 18:40 left the overnight worker on the copilot mode. At 02:14 nobody is on the rota, so the run that a config file would have put in act-within-bounds resolves to advise, where it proposes and moves nothing. The last row is why every field defaults to False. A probe that times out has learned nothing, and nothing is not evidence. On the fallback row, a debt from Part 8 is paid for unattended runs: an unattended run on an uncharacterised model drops to observe. For copilot it stays open. Copilot keeps its band on the fallback because a person is in the path, which at the tag is true only above the 200.00 automatic tier, so until checklist item 9 is done Part 8's fallback admission still has to refuse that fallback for copilot runs. And the context row pays a debt that Part 5 left to the book: the chapter narrows a run to advise when a required span is lost mid-run. At admission, a run whose floor check did not confirm lands on its mode's floor, observe for queue-drain. A breached floor still refuses assembly, as Part 5 built it.
None of this per-run derivation is new. Attribute-based access control decides by "evaluating attributes associated with the subject, object, requested operations, and, in some cases, environment conditions against policy" (NIST SP 800-162), and zero trust grants access per session from dynamic policy. Shyan's July post on earned autonomy calls context "a one-way ratchet on risk." What the harness adds is the specific evidence rows and the rule that a mode is a ceiling. Two components enforce the band, and Part 3's Role Test puts them in different roles. An integrity check re-resolves the band from evidence and never reads a proposal, so it is a bound. A band gate refuses or escalates a proposal the band does not reach, so it is a gate.
Earned Width: what a track record may widen inside a band
If a band is earned by consequence, what is a good month worth? My book's answer is Earned Width. Observed reliability may widen how much a run does inside its band: the volume it handles, the rate it works at, the share of its decisions a reviewer samples. It may never move an action across a reversibility boundary into a wider band. The book's one-line form is "Behaviour changes the throttle; consequence sets the envelope."
Part of this is not mine. Shyan's Earned, Not Configured (14 July 2026) says "Configuration should set the ceiling, never the level", and calls that ceiling "the point past which no track record is enough". The rig-docs trust model says of its money-handling tier, "Accumulated track record on lower tiers does not raise this ceiling. Irreversibility is a structural reason, not a trust metric." Both keep a person on every irreversible action, and both are right. Pan's $50 to $100 to $200 ramp crosses that line, and both would refuse it.
direction: down
band: "closed-loop band" {
label.near: top-center
style: {fill: "#F5F3FE"; stroke: "#5A4BC4"; font-color: "#2C2C2A"}
throttle: "Throttle: may follow the record\nruns a night, rate, concurrency,\nmodel spend, reversible review sample" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
envelope: "Envelope: fixed by consequence\n50.00 per unreviewed refund\nundeclared: total before anyone looks" {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
throttle -> envelope: "volume of an irreversible action\nreaches the second line" {style: {stroke: "#B03A2E"; font-color: "#2C2C2A"}}
}
The cautious camp never meets the gap in the diagram, because with a person on every refund both of its numbers are zero. The gap opens the moment an operator admits any unattended irreversible exception, as Pan, AWS, ATXP and my book's 50.00 closed-loop refund all do. Then the envelope has two lines. Only the per-refund and per-run limits are written down, and no window total is. Nothing bounds the total before anyone looks, so the throttle reaches it. "More of the same action" looks like throughput. For a reversible action it is, because a wrong reply can be corrected and a wrong credit can be reversed. A settled refund cannot be taken back by the harness. Every extra unreviewed refund in a night adds its full amount to what is lost if the agent is wrong all night, and the agent is wrong all night when the system changes before the night starts.
Why a per-refund cap is not a spending limit
Pan's ramp is the obvious wrong way, and the per-action camp already rejects it. A subtler wrong way is the one in the opening. It respects the per-action ceiling and raises the volume, which reads as Earned Width under the book's own definition. To see what it moves, write down what one night lets the fleet do:
@dataclass(frozen=True)class Grant: """What one detection window lets the fleet do to customers' money unreviewed. A detection window is the time until a person next looks: for queue-drain, the night until the morning shift. """ per_refund: D # the most one refund may move refunds_per_run: int total_per_run: D runs_per_window: int reviewed_first: D = D("0") # share of refunds a person approves before they run window_total: D | None = None # a declared cap on the whole window, if any spend_per_window: D = D("120.00") # model spend: the operator's own moneydef single(g: Grant) -> D: """Number one: the most a single unreviewed refund can move.""" return D("0.00") if g.reviewed_first == 1 else g.per_refunddef total(g: Grant) -> D: """Number two: the most all unreviewed refunds can move before anyone looks. A sample does not say which refunds it skips, so any share short of all counts as none reviewed, unless a rejected sample halts the window, which this grant does not model. This is a worst case, not an expectation. """ if g.reviewed_first == 1: return D("0.00") per_run = min(g.total_per_run, g.per_refund * g.refunds_per_run) unreviewed = per_run * g.runs_per_window if g.window_total is not None: unreviewed = min(unreviewed, g.window_total) return unreviewed.quantize(D("0.01"))# The book's limits at tag ch14-authority-bands; 40 runs a night is the scenario's.OVERNIGHT = Grant(per_refund=D("50.00"), refunds_per_run=3, total_per_run=D("150.00"), runs_per_window=40)# Copilot, every refund approved first: run-budget.toml's act-within-bounds limits# (5 refunds, 5,000.00 a run) and Part 9's 2,000.00 review band; 40 runs is ours.SUPERVISED = Grant(per_refund=D("2000.00"), refunds_per_run=5, total_per_run=D("5000.00"), runs_per_window=40, reviewed_first=D("1"))OVERNIGHT uses the companion code's limits at the chapter's tag: 50.00 per unreviewed refund (policies/authority-bands.toml), and three refunds and 150.00 per closed-loop run (policies/run-budget.toml). Forty runs a night is this scenario's number. Ramp the runs and nothing else:
=== a volume ramp that never touches the per-refund ceiling after 0 clean nights runs 40 single 50.00 total 6000.00 after 30 clean nights runs 80 single 50.00 total 12000.00 after 60 clean nights runs 160 single 50.00 total 24000.00grid-rows: 1
grid-gap: 24
n0: "Night 0" {
grid-columns: 1
label.near: top-center
style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}
s0: "single 50.00" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
t0: "40 runs x 150.00\ntotal 6,000.00" {style: {fill: "#FFD93D"; stroke: "#C9A400"; font-color: "#2C2C2A"}}
}
n30: "Night 30" {
grid-columns: 1
label.near: top-center
style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}
s30: "single 50.00" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
t30: "80 runs x 150.00\ntotal 12,000.00" {style: {fill: "#FFA07A"; stroke: "#C96F4A"; font-color: "#2C2C2A"}}
}
n60: "Night 60" {
grid-columns: 1
label.near: top-center
style: {fill: "#F4F6F6"; stroke: "#95A5A6"; font-color: "#2C2C2A"}
s60: "single 50.00" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
t60: "160 runs x 150.00\ntotal 24,000.00" {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
}
Every check in the system reads either the green cell, which never changes, or one run's slice of the red one. Red quadrupled, and no policy file declares it. In the book's own limits there is no window-wide refund number at all (the composite check sums one coordinator's sub-runs and is wired into no node; see below): the refund ceilings in Chapter 13 are per run, and the chapter itself says "Per-run ceilings bound a mistake; they do not bound a pattern". So on the night the export changed, nothing between the agent and 24,000.00 was a number anybody had agreed to. What actually went out, 6,400.00, was simply the loss the plant change happened to produce. Under the grant, almost four times as much was allowed.
AWS's top tier, "Full access. Post-hoc audit only.", is the same ramp taken to its end. Anthropic's own measurement of Claude Code shows the informal version. Among new users, "roughly 20% of sessions use full auto-approve, which increases to over 40% as users gain experience." People widen on a track record without being told to. For edits that version control can undo, that is reasonable. Auto-approve also covers shell commands that cannot be undone, and for those it is the volume ramp.
Aggregate limits: the two numbers consequence sets for irreversible actions
Name the two lines of the envelope:
- Number one, the single ceiling, is the most a single unreviewed irreversible action may move. On the overnight grant it is 50.00.
- Number two, the window total, is the most all unreviewed irreversible actions may move before a person next looks. It is set per detection window, fleet-wide and per customer, and it is a worst case: it assumes every run in the window is wrong at once. The opening's grant declared none, so it was whatever runs times the per-run total came to: 6,000.00 at 40 runs, and 24,000.00 at 160.
Neither number is my idea. SEC Rule 15c3-5, adopted in 2010, requires both from broker-dealers. Under it, firms must "Prevent the entry of orders that exceed appropriate pre-set credit or capital thresholds in the aggregate for each customer and the broker or dealer", and must reject orders that "exceed appropriate price or size parameters, on an order-by-order basis or over a short period of time". Stripe Issuing sets limits per authorisation and per interval, and says "A cardholder's spending limits apply across all of their cards." For agents, TCSA's guide on agent spending limits says it plainly: "A per-transaction ceiling limits the size of a mistake. Only an aggregate ceiling and a rate limit constrain the size of a failure, because an agent can execute two hundred in-limit transactions before a human reads the first alert." I take the window from TCSA too. Their advice is to "Size the aggregate ceiling against your detection interval", and for queue-drain the detection interval is the night until the morning shift.
direction: right
classes: {
refund: {style: {fill: "#FFD93D"; stroke: "#C9A400"; font-color: "#2C2C2A"}}
}
open: "Night starts\nnobody looking" {style: {fill: "#95A5A6"; stroke: "#6C7A7B"; font-color: "#2C2C2A"}}
window: "Detection window" {
label.near: top-center
style: {fill: "#FDF6E3"; stroke: "#C9A400"; font-color: "#2C2C2A"}
r1: "refund, at most 50.00" {class: refund}
r2: "refund, at most 50.00" {class: refund}
r3: "... every refund, every run" {class: refund}
}
look: "Morning shift\na person looks" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
open -> window: "number one caps\neach refund"
window -> look: "number two caps\nthe sum"
Each refund in the window is bounded by number one. Only number two bounds the sum, and the sum is all that is still loose when the morning shift arrives. In Authority Doesn't Compose I wrote that "The fact that every agent in a coordinated system is acting inside its own band tells you nothing about whether the system's combined action is inside any band at all." That post said the composite needs its own band. My book names the band a set of runs is collectively acting in The Composite Band, and number two is that band's money edge, written as a declared limit with a window.
My own claim is narrower than both, and it is a rule: a trust score is an admissible input to the throttle and an inadmissible input to either number. Velocity limits are old. The measurement that agents sharing a model fail together is recent and published. What earned-autonomy writing has not connected is that a track record is blind to exactly the failure the window total exists for. The record counts independent errors, and the window total bounds the correlated one. The cautious camp is safe from this only because it lets no irreversible action run unreviewed. Once an operator admits one unattended exception, the window total has to be declared, and no record may raise it. So a good month may make the agent faster, but it cannot raise either number. Chen's actuarial framework (arXiv 2605.25632) also prices each side-effecting action, refunds included, against a reserve budget. It prices actuarially, with model identity as an underwriting variable, so behaviour moves the price, and in that respect it sits closer to the consensus than to this rule.
The two-number test for any Earned Width widening
Once both numbers are functions of the grant, any widening can be checked mechanically. Compute both before and after. If either rose, the widening was a change of band, and it goes through the review a band change gets. If either fell, it was narrowing, which needs no review and should happen automatically.
def moved_numbers(before: Grant, after: Grant) -> list[str]: """Earned Width if this returns nothing; a raised number is a band change. Lowering either number is narrowing, and narrowing needs no review. """ moved = [] if single(after) > single(before): moved.append(f"single {single(before)} -> {single(after)}") if total(after) > total(before): moved.append(f"total {total(before)} -> {total(after)}") return movedHere is the test run against seven widenings a team might propose after a clean month. The table of cases is part of the demo's driver:
capped = replace(OVERNIGHT, window_total=D("1000.00")) cases = [ ("double the night's runs", OVERNIGHT, replace(OVERNIGHT, runs_per_window=80)), ("refunds under 100.00 run unreviewed", OVERNIGHT, replace(OVERNIGHT, per_refund=D("100.00"))), ("five refunds a run, same 150.00", OVERNIGHT, replace(OVERNIGHT, refunds_per_run=5)), ("night's model spend 120 -> 160", OVERNIGHT, replace(OVERNIGHT, spend_per_window=D("160.00"))), ("copilot: review 1 refund in 10", SUPERVISED, replace(SUPERVISED, reviewed_first=D("0.1"))), ("window capped at 1,000: double runs", capped, replace(capped, runs_per_window=80)), ("raise the window cap to 2,000", capped, replace(capped, window_total=D("2000.00"))), ] for label, before, after in cases: moved = moved_numbers(before, after) lines = ["band change: " + m for m in moved] or ["Earned Width"] print(f" {label:38} {lines[0]}") for line in lines[1:]: # one moved number per line print(f" {'':38} {line}")The two grants are the ones defined above. SUPERVISED assumes every copilot refund is approved first, up to Part 9's 2,000.00 review band. At the tag that is not yet true: Part 9's automatic tier lets refunds under 200.00 run unreviewed in copilot, so its real number one is just under 200.00 until checklist item 9 is done.
=== is it Earned Width? double the night's runs band change: total 6000.00 -> 12000.00 refunds under 100.00 run unreviewed band change: single 50.00 -> 100.00 five refunds a run, same 150.00 Earned Width night's model spend 120 -> 160 Earned Width copilot: review 1 refund in 10 band change: single 0.00 -> 2000.00 band change: total 0.00 -> 200000.00 window capped at 1,000: double runs Earned Width raise the window cap to 2,000 band change: total 1000.00 -> 2000.00grid-rows: 3
grid-columns: 2
grid-gap: 80
q1: "1. Does it raise the most one\nunreviewed refund can move?" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
a1: "Yes: band change.\nReview it like one." {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
q2: "2. Does it raise the most all\nunreviewed refunds can move\nbefore anyone looks?" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
a2: "Yes: band change.\nThe Composite Band moved." {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
q3: "3. Neither moved" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
a3: "Earned Width: may follow\nthe record, narrows on evidence" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
q1 -> a1: "yes"
q1 -> q2: "no"
q2 -> a2: "yes"
q2 -> q3: "no"
q3 -> a3
Row three passes because the implicit total, runs times the per-run limit, does not move; an undeclared total is still one nobody chose. Row six is the reason to declare the window total. It passes because the cap was already the binding limit: at 40 runs the per-run limits allow 6,000.00, far above the 1,000.00 cap, so doubling the runs adds no refund capacity at all. For refunds, the cap sets the night, not the run count. On an ordinary night of 160 good 40.00 refunds the cap still stops at 25, and the rest wait for the morning shift or go to review. So the extra runs buy capacity for replies, credits and other reversible work. Extra refund volume needs a larger cap, and a larger cap is row seven: a band change. If ordinary refund volume is larger than the loss the operator accepts unwatched, unattended refunds at that volume belong in review, and the cap is what makes that visible. Without a declared cap, every extra run spends from a total nobody wrote down.
There is one honest way to carry more refund volume without a larger cap: shorten the window. An automated stop on the refund rate, or on an anomaly in it, is a bound, not a trust score, and it can cut the effective window from a night to minutes. It shortens the window only for failures that change what it measures. Night 61 had an ordinary night's rate and amounts, so a detector for it has to watch something the export change did move, such as refunds per invoice line or the share of refunds on prorated seat credits. Size number two against the detector's measured time to detect, not its best case, and the same total buys more refunds. That is a reviewed change to the window, and it is still not earned.
On review sampling, row five settles it. Sampling one refund in ten leaves nine in ten unreviewed and irreversible, and it moves both numbers at once. Number one jumps from 0.00 to the full 2,000.00 review band. Number two jumps to 200,000.00, because a sample does not say which refunds it skips, so the worst case counts all of them. That worst case assumes a rejected sample does not stop the fleet. Wire a rejected sample to halt the window, and on the correlated night the sample becomes a detector: the window shrinks to the gap between samples plus the time a reviewer takes to reject one, and only if the reviewer can see what the agent could not. On night 61 the reviewer reads the same broken export. Number two can be sized against that measured gap. A halt bounds number two only: number one still rises to the review band. That is a reviewed change to the window, not Earned Width. Thinning the sample as a reward is never width. Sampling is Earned Width only where a sampled error can still be undone. Brenn Hill's autonomy levels put the same rule as "No undo, no L2." Hill himself files a small refund inside a generous cap as reversible with effort. I do not, because the harness has no undo for it. So the book's definition needs one qualifier it already uses later in its own prose: the review sample may thin on reversible paths only.
The test reads the fleet axis only. The per-customer total is enforced by the ledger below, and a widening that raises one customer's exposure, such as more runs per customer, has to be checked there.
Row four clears the book's own example, and it passes by construction: single() and total() never read spend_per_window, because model spend is not customers' money. Chapter 14 lists "a higher per-night ceiling in Chapter 13's ledger" as Earned Width, and at the tag that ledger holds model spend only. Model spend is also lost money, but it is the operator's own, already capped per run and per night, and no customer is harmed by it. The same sentence about a per-night refund total would describe row seven of the test, which is a band change.
A detection-window ledger for unreviewed AI agent refunds
The book already has a coordinator check for this. At the tag, it disagrees with the book's own per-run limits. Give one customer three 40.00 refunds in one night and change only how the coordinator splits the work:
=== one customer, three 40.00 refunds, one night book, one run ['allow', 'allow', 'allow'] -> 120.00 out book, per sub-run ['run', 'run', 'raised'] -> 80.00 outBoth lines come from two small functions in bands.py that re-implement the chapter's limits at the tag:
def book_per_run(amounts: list[D], max_count: int = 3, max_total: D = D("150.00")) -> list[bool]: """Chapter 13's per-run refund ceiling, as one run sees it.""" out, count, moved = [], 0, D("0") for a in amounts: ok = count + 1 <= max_count and moved + a <= max_total if ok: count, moved = count + 1, moved + a out.append(ok) return outdef book_composite(moved_so_far: list[D]) -> bool: """Chapter 14's composite(): the summed total against the per-action 50.00. It reads what the sub-runs have already moved, so it can only say so afterwards. """ return sum(moved_so_far, D("0")) <= UNREVIEWED_CEILING[Band.CLOSED_LOOP]In the second output line, run means the coordinator let a sub-run start, and raised means book_composite() returned false before the next one. That is the generous reading, a check before each sub-run. At the tag, CompositeCeiling is wired into no graph node. The chapter's own example checks it once, after all three sub-runs have moved 120.00, which is the Receipt Ceiling at full width.
In one run, Chapter 13's per-run ceiling of three refunds and 150.00 lets all 120.00 go out unattended. Split across three runs, Chapter 14's composite() compares the summed total with 50.00, the number-one ceiling, and raises. The customer and the night are the same in both lines. Only the coordinator's split differs, and the verdict follows the split. Because the book uses one number for both jobs, its composite check refuses a total that the per-run check allows.
A second problem sits inside the composite check, and Part 13 already named it. composite() sums what the sub-runs have already moved, so it is a Receipt Ceiling. Even when the coordinator checks before starting each sub-run, which is the generous reading used above, 80.00 has gone out by the time the check fires, past the 50.00 it was meant to enforce. It admits one whole sub-run past the line, which is Part 13's rule for a receipt: the overshoot is the largest unit it lets through.
grid-rows: 1
grid-gap: 40
book: "At the tag: counters that disagree" {
grid-columns: 1
label.near: top-center
style: {fill: "#FDEDEC"; stroke: "#B03A2E"; font-color: "#2C2C2A"}
b1: "Per run: 3 refunds, 150.00\nfresh count in every run" {style: {fill: "#FFA07A"; stroke: "#C96F4A"; font-color: "#2C2C2A"}}
b2: "Coordinator: sums what moved\nagainst 50.00, after the fact" {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
b3: "One run: 120.00 out\nThree runs: 80.00 out" {style: {fill: "#E74C3C"; stroke: "#B03A2E"; font-color: "#FFFFFF"}}
}
ledger: "Fix: one ledger per detection window" {
grid-columns: 1
label.near: top-center
style: {fill: "#EAF7EE"; stroke: "#3F9E52"; font-color: "#2C2C2A"}
l1: "Every run reserves\nbefore its refund runs" {style: {fill: "#4A90E2"; stroke: "#2C6FB0"; font-color: "#FFFFFF"}}
l2: "Checks number one, the window\ntotal and the customer's total" {style: {fill: "#7B68EE"; stroke: "#5A4BC4"; font-color: "#FFFFFF"}}
l3: "One run or three:\n80.00 out, third refund refused" {style: {fill: "#6BCF7F"; stroke: "#3F9E52"; font-color: "#2C2C2A"}}
}
On the right, the window total gets a home. The coordinator holds one ledger per detection window, every run reserves against it before a refund runs, and the ledger refuses the refund that would cross a line:
@dataclassclass WindowLedger: """Held by the coordinator. One per detection window, shared by every run in it.""" window_total: D # all unreviewed refunds, fleet-wide per_account: D # all unreviewed refunds to one customer held: D = D("0.00") by_account: dict[str, D] = field(default_factory=dict) def reserve(self, account: str, amount: D) -> None: """Called before the refund runs, never after. Part 13's reservation.""" if amount > UNREVIEWED_CEILING[Band.CLOSED_LOOP]: raise Refused(f"{amount} is over the single ceiling") if self.held + amount > self.window_total: raise Refused(f"window would hold {self.held + amount} " f"of {self.window_total}") mine = self.by_account.get(account, D("0.00")) if mine + amount > self.per_account: raise Refused(f"{account} would hold {mine + amount} " f"of {self.per_account}") self.held += amount self.by_account[account] = mine + amountSize the two totals backwards from the loss the operator accepts, as TCSA advises, not forwards from an ordinary night's volume. Here the operator accepts 1,000.00 a night across the fleet and 100.00 for any one customer, and the split stops mattering:
ledger, one run ['allow', 'allow', 'refuse'] -> 80.00 out refused: acct_4417 would hold 120.00 of 100.00 ledger, three runs ['allow', 'allow', 'refuse'] -> 80.00 out refused: acct_4417 would hold 120.00 of 100.00In both shapes, the third refund is refused before it runs. The ledger has no run boundary, which is why the split cannot matter. It goes to the morning queue through the escalation path, which every band can reach, and the customer's third charge waits there for a person. Run the opening's night through the same ledger, one wrong 40.00 refund in each of 160 runs to 160 customers. The function's two print lines are left out:
def night61_demo() -> None: print("=== night 61: 160 runs, one wrong 40.00 refund each, 160 customers") ledger = WindowLedger(window_total=D("1000.00"), per_account=D("100.00")) allowed = refused = 0 for run in range(160): try: ledger.reserve(f"acct_{run:04d}", D("40.00")) allowed += 1 except Refused: refused += 1=== night 61: 160 runs, one wrong 40.00 refund each, 160 customers per-run limits only 160 allowed, 0 refused -> 6400.00 out window ledger 1000.00 25 allowed, 135 refused -> 1000.00 outThe 26th refund would have taken the window to 1,040.00, so it was refused, and so was every one after it. The 160 runs would still have been Earned Width, and the loss would have been the number the operator had agreed to. A window needs an end. A weekend or a holiday with no morning shift makes the window longer. Size its total for the hours until a person really looks, or close the window at a fixed hour and let the queue wait.
In production this ledger needs the same machinery as Part 13's fleet ledger: one conditional write per reservation, so two runs cannot both read 960.00 and both reserve 40.00, and a release when a refund fails. Chapter 13 leaves keying its ledger by account as an exercise. This ledger is that exercise, with the account total and the window total as declared numbers. Three tests pin down the properties:
from dataclasses import replacefrom decimal import Decimal as Dfrom itertools import productfrom bands import (MODES, OVERNIGHT, Evidence, Refused, WindowLedger, moved_numbers, resolve)def test_any_missing_fact_lands_on_the_floor(): for mode, (ceiling, requires, floor) in MODES.items(): for facts in product((True, False), repeat=3): evidence = Evidence(*facts) band, _ = resolve(mode, evidence) held = all(getattr(evidence, name) for name in requires) assert band == (ceiling if held else floor) assert band <= ceilingdef test_the_split_does_not_change_the_verdict(): forty = D("40.00") def out(runs: list[list[D]]) -> D: ledger = WindowLedger(window_total=D("1000.00"), per_account=D("100.00")) moved = D("0.00") for refunds in runs: # every run reserves against the one ledger for amount in refunds: try: ledger.reserve("acct_4417", amount) moved += amount except Refused: pass return moved one_run = [[forty, forty, forty]] three_runs = [[forty], [forty], [forty]] assert out(one_run) == out(three_runs) == D("80.00")def test_more_runs_under_a_declared_cap_is_width(): capped = replace(OVERNIGHT, window_total=D("1000.00")) assert moved_numbers(capped, replace(capped, runs_per_window=80)) == [] assert moved_numbers(OVERNIGHT, replace(OVERNIGHT, runs_per_window=80)) != []All three pass on Python 3.13 with pytest. The demo is standard library only: no framework, no model and no key.
When earned autonomy is safe: the throttle
None of this argues against earning. A month of clean nights is real evidence, and the throttle is where it pays. Let it move automatically within declared caps, and make it narrow automatically the moment the evidence turns. What the record cannot buy is either line of the envelope. Those two numbers are statements about what the operator agrees to lose while nobody is watching, and an operator changes them in a reviewed edit with the reason written next to the number. The admissible reasons are about consequence: a larger loss the business accepts, a shorter detection window, a cheaper way to recover a wrong refund, or a reserve or insurance that pays for one. "The agent has been good" is not one of them, because it estimates how often, not how much. A trust score never changes them.
Checklist: authority bands and Earned Width
- Write down, for every irreversible tool, number one: the most a single unreviewed action may move. Put it in the control plane. A limit stated in the system prompt is a sensor under Part 3's Role Test, and it sits inside the plant under Part 2's Flat Context.
- Write down number two for each detection window: the most all unreviewed irreversible actions may move, fleet-wide and per customer, before a person next looks. Work it backwards from the loss you accept if every run in the window is wrong at once. Size the per-customer total so that one customer's worst night is something support can reverse by hand in a morning. If you cannot say when a person next looks, you do not know the window, and the grant is unbounded.
- Enforce number two with a reservation before each action, in one ledger the coordinator holds. A check that sums what has already moved is a Receipt Ceiling and fires one sub-run late.
- Resolve each run's band at admission from evidence about the world: reviewer reachable, context floor cleared, primary model answering. Default every field to false, so a probe that fails narrows the band. Treat the probe as a dependency and alert when the fleet narrows at once.
- Re-derive the band on every resume, as Part 12's Restore Line requires. A band read back from a checkpoint is a grant that has outlived its reason. A resume is a new admission, and the only point where a run may come back wider.
- Run every proposed widening through the two-number test. If either number rises, it is a band change: a reviewed edit, with the reason next to the number. Admit only reasons about consequence (accepted loss, window, recovery cost, reserve). A clean record is not one.
- Let throughput follow the record only within declared caps: runs per window, rate, concurrency, model spend, review sampling on reversible paths. Narrow automatically on drift, anomalies or a plant change.
- Never thin the review sample on an irreversible path as a reward. Unsampled means unreviewed. If a sample on an irreversible path is meant to detect anything, wire a rejected sample to halt the window, and size number two against the gap between samples plus review latency. A halt bounds number two only; number one still rises to the review band, so thinning remains a band change.
- Lower any automatic approval tier to number one, and check it at startup. At the tag, Part 9's automatic tier lets every copilot refund under 200.00 run unreviewed. Number one for act-within-bounds is 0.00, so the unreviewed range is 0.00 to 200.00. The chapter's startup check reports only 50.00 to 200.00, because it compares the tier with the closed-loop ceiling. Lowering the tier to 0.00 means a person approves every copilot refund, small ones included. A team that keeps a 50.00 automatic tier in copilot has to give copilot a window ledger too.
- Emit the band, the evidence and the resolver's reason once per run into Part 6's Second Stream, and every ledger refusal with its window and balance. Watch the band distribution per night. A fleet that quietly resolved to advise for a week has produced proposals nobody read.
Harness Engineering book, Chapter 14: Authority Bands
This is Part 14 of a series that follows Harness Engineering for Production AI Systems one chapter at a time. Chapter 14, "Authority Bands," replaces the free-text band string the package had carried since Chapter 1, and turns the mode key that four policy files used since Chapter 9 into one input to a resolution. It splits the run's authority from its status across every chapter that wrote the old field, loads the band table with its four refusals, and wires the admission node, the band gate and the integrity bound into the graph. It also covers the adoption order for a system already in production, and how bands compare with roles and capability tokens. This part corrects the chapter in four places: the composite check compares a total with the per-action ceiling, it reads amounts already moved, its startup check under-reports copilot's unreviewed range (0.00 to 200.00, not 50.00 to 200.00) and so sets the fix at 50.00 instead of 0.00, and its Earned Width definition needs the reversible-paths qualifier on review sampling. Code for the chapter is in the ch14-authority-bands tag of the companion repository.
References
- Pan, T. (2026, April 17). Earned Autonomy: How to Graduate AI Agents from Supervised to Independent Operation. TianPan.co. https://tianpan.co/blog/2026-04-17-earned-autonomy-ai-agents-progressive-supervision
- Shyan. (2026, July 14). Earned, Not Configured. Substack. https://shyanming.substack.com/p/earned-not-configured
- Amazon Web Services. (2026, August 26). Closing the AI agent trust gap with graduated autonomy. AWS Architecture Blog. https://aws.amazon.com/blogs/architecture/closing-the-ai-agent-trust-gap-with-graduated-autonomy/ (read 2026-11-15)
- ATXP. How to Ramp Agent Autonomy Responsibly. https://atxp.ai/blog/how-to-ramp-agent-autonomy (read 2026-11-15)
- Hill, B. AI Agent Autonomy Levels: From Logged to Locked Down. DEV Community. https://dev.to/brennhill/ai-agent-autonomy-levels-from-logged-to-locked-down-45am (read 2026-11-15)
- The Trusted Rig. Trust Model: Tiered Autonomy by Blast Radius. https://rig-docs.pages.dev/whitepaper/trust-model/ (read 2026-11-15)
- Anthropic. (2026). Measuring AI agent autonomy in practice. https://www.anthropic.com/research/measuring-agent-autonomy (read 2026-11-15)
- TCSA. (2026). How Much Should an AI Agent Be Allowed to Spend? https://www.tcsa.in/learn/ai-agent-spending-and-transaction-limits
- Stripe. Issuing spending controls. Stripe Docs. https://docs.stripe.com/issuing/controls/spending-controls (read 2026-11-15)
- U.S. Securities and Exchange Commission. 17 CFR 240.15c3-5, Risk management controls for brokers or dealers with market access. https://www.law.cornell.edu/cfr/text/17/240.15c3-5
- U.S. Securities and Exchange Commission. (2013). In the Matter of Knight Capital Americas LLC, Release No. 34-70694. https://www.sec.gov/litigation/admin/2013/34-70694.pdf
- Varma, J. R. (2013). Knight Capital, quoting the SEC order. https://www.jrvarma.in/blog/Y2013/Knight-Capital.html
- Bhardwaj, V. P., Singh, G., & Bhardwaj, A. P. (2026). Agent Behavioral Contracts II: Certifying Compositional Reliability Without Assuming Independence. arXiv:2608.12895. https://arxiv.org/abs/2608.12895
- Chierici, A., Reid, A., & O'Callaghan, S. (2026, March 31). Scaling Sameness. Gradient Institute. https://gradientinstitute.org/research-publications/scaling-sameness
- Chen, H.-H. (2026). Insuring Every Action: An Authority Frontier Framework for Runtime Actuarial Control of Autonomous AI Agents. arXiv:2605.25632. https://arxiv.org/abs/2605.25632
- Kim, E., Garg, A., Peng, K., & Garg, N. (2025). Correlated Errors in Large Language Models. arXiv:2506.07962. https://arxiv.org/abs/2506.07962
- Basel Committee on Banking Supervision. (2014, April 15). Supervisory framework for measuring and controlling large exposures. Bank for International Settlements. https://www.bis.org/publ/bcbs283.htm
- Hanley, J. A., & Lippman-Hand, A. (1983). If nothing goes wrong, is everything all right? JAMA, 249(13), 1743-1745. https://doi.org/10.1001/jama.1983.03330370053031
- Hu, V. C., et al. (2014, updated 2019). Guide to Attribute Based Access Control (ABAC) Definition and Considerations (NIST SP 800-162). https://csrc.nist.gov/pubs/sp/800/162/upd2/final
- Rose, S., Borchert, O., Mitchell, S., & Connelly, S. (2020). Zero Trust Architecture (NIST SP 800-207). https://doi.org/10.6028/NIST.SP.800-207
- Kumar, R. (2026, June 4). Agentic AI in the Data Center: Operational Authority Gradient. https://ranjankumar.in/agentic-ai-data-center-boom-operational-authority-gradient
- Kumar, R. (2026, July 20). Authority Doesn't Compose: Why Coordinated Agents Need a Coordinator With Its Own Band. https://ranjankumar.in/agentic-ai-buildout-authority-does-not-compose
- Kumar, R. (2026, February 17). Trust Gradients: Dynamic Permission Scaling Based on Agent Behavior. https://ranjankumar.in/trust-gradients-dynamic-permission-scaling-based-on-agent-behavior
- Kumar, R. (2026). Part 1, Harness Engineering Without an Oracle: What Transfers. https://ranjankumar.in/harness-engineering-demo-cliff-borrowed-evidence
- Kumar, R. (2026). Part 2, LLM Trust Boundaries: Draw Them by Reach, Not by Author. https://ranjankumar.in/harness-engineering-trust-boundary-flat-context
- Kumar, R. (2026). Part 3, LLM Guardrails That Stop Nothing: The Role Test. https://ranjankumar.in/harness-engineering-guardrail-role-test-loop-closure
- Kumar, R. (2026). Part 5, LLM Context Window Management: The Policy Nobody Wrote. https://ranjankumar.in/harness-engineering-context-floor-position-debt
- Kumar, R. (2026). Part 6, AI Agent Decision Logs: Catch the Refund No Control Decided. https://ranjankumar.in/harness-engineering-agent-decision-log-owed-decisions
- Kumar, R. (2026). Part 8, LLM Fallback Models Inherit Authority They Never Earned. https://ranjankumar.in/harness-engineering-llm-fallback-second-plant-budget-amnesia
- Kumar, R. (2026). Part 9, AI Agent Approval Gates: Failed Checks Must Never Widen. https://ranjankumar.in/harness-engineering-agent-approval-gate-verdict-widening
- Kumar, R. (2026). Part 12, LangGraph Interrupt Resume: Approvals Run on Stale Facts. https://ranjankumar.in/harness-engineering-agent-checkpoint-resume-restore-line
- Kumar, R. (2026). Part 13, AI Agent Spend Limits Pay for the Call That Crosses Them. https://ranjankumar.in/harness-engineering-agent-spend-limit-receipt-ceiling
- Kumar, R. (2026). Harness Engineering for Production AI Systems, Chapter 13, "Cost, Depth, Width". https://ranjankumar.in/harness-engineering-for-production-ai-systems
- Kumar, R. (2026). Harness Engineering for Production AI Systems, Chapter 14, "Authority Bands". https://ranjankumar.in/harness-engineering-for-production-ai-systems
- Kumar, R. (2026). harness-engineering-code, tag
ch14-authority-bands. https://github.com/ranjankumar-gh/harness-engineering-code/tree/ch14-authority-bands
Related Articles
- Deterministic Constraint Systems: Building Tool Registries That Keep Agents in Scope
- AI Agent Approval Gates: Failed Checks Must Never Widen
- Testing AI Agent Guardrails: Green Suites Hide Dead Controls
- AI Agent Failure Attribution: Why the Model Gets the Blame






