All chapters
  1. Start hereEvery step can fail. The outcome still has to be acceptable
  2. Foundations · 1Available, correct, durable, resilient: four qualities that are not the same
  3. Foundations · 2Failure modes: what breaks around an agent, and how it shows
  4. Mechanisms · 3Timeouts, deadlines and retries: trying again without making it worse
  5. Mechanisms · 4Idempotency: when the same request arrives twice
  6. Mechanisms · 5Queues: delivery semantics, dead letters and poison messages
  7. Mechanisms · 6Checkpoint, resume and sagas: finishing what a crash interrupted
  8. Mechanisms · 7Circuit breakers, load shedding and graceful degradation
  9. Mechanisms · 8Concurrency: rate limits, budgets and distributed locks
  10. Operations · 9SLOs: saying how reliable is reliable enough
  11. Operations · 10Deployment: canary, blue-green, feature flags and rollback
  12. Operations · 11Model fallback and provider failover: what a second route costs in quality
  13. Operations · 12Fault injection: breaking it on purpose, before production does
  14. Operations · 13Incidents: response, runbooks, postmortems and the case that joins the golden set
  15. Reference · 14Frameworks and standards: what each one keeps reliable for you
  16. Reference · 15Advanced: the human step, cost ceilings and capacity
  17. Reference · 16The insurance lab: one quote, fifteen ways to fail, end to end
  18. ReferenceGlossary
  19. AboutAbout this site and its sources
Reference · 15

Advanced: the human step, cost ceilings and capacity

The slowest and least available dependency is a person. Approval that survives a holiday, spending that stops at a ceiling, and capacity planned for the queue in front of the underwriter.

What you will understand
The human step
Why the underwriter is a dependency with failure modes, and how approval timeouts, an escalation path and delegation keep a waiting run from being forgotten.
Cost ceilings
How a run that keeps retrying is stopped before the next call, and why the stop is an honest escalation, never a silent failure.
Capacity
Two queues, one measured in seconds in front of the provider and one in hours in front of the underwriter, and the headroom that lets each one recover.

Scenario UW-R15 ends well. The roof-data provider timed out twice, the worker crashed after the write, the queue delivered the message three times, and still run run-7f3a finished at 30024 ms in waiting_for_human with exactly one recommendation row and one review task. All seven invariants hold. The recommendation is escalate, citing R-ROOF-03: the application says the roof is 9 years old, the provider says 22, and the rule sends the case to a senior underwriter. The model recommends; a person decides.

It is Friday evening. The review task lands in the queue of the senior underwriters. One of them is on leave for two weeks, the other has forty tasks ahead of this one, and the broker asked for a quote by Wednesday.

Look at what the example's code says at that moment. The span of step 8 carries one note: "A person's time is not part of the deadline of the automated part." That is correct, and it is where this site's protections stop. The automated part has a deadline, retries, a breaker, a checkpoint and a cost ceiling. The person has none of these. If the task is never opened, no timeout fires, no retry happens and no alert goes off, and the broker's request is lost as surely as if the run had crashed. Nothing failed; the outcome is still unacceptable.

This page treats the three things the mechanism pages left open: the person as a dependency, the spending that must stop somewhere, and the capacity of the two queues the workflow feeds. Each one ends with what is still unsolved.

Plain English. Every earlier page asked what is still true after a machine fails. This page asks the same of the slowest, least available and least predictable part of the system: a person, a budget and a queue.

The person is a dependency, with failure modes of its own#

Failure modes names six dependencies of the workflow, and the human is one of them. Seen with the eyes of the earlier pages, the underwriter fails in recognizable ways, each with a counterpart among the machine failures.

How the human step failsIts machine counterpartWhat the example does todayWhat a production design adds
Nobody opens the task (leave, illness, a full queue)A timeout with no answerThe run sits in waiting_for_humanAn approval timeout and an escalation path
The assigned person is not authorized for this caseA permanent errorNothing: the human step is not simulatedRouting by role, checked against R-HUMAN-01
The decision is slow because the queue is longQueueing in front of a providerNothingCapacity planning and headroom
The person decides against the recommendationNot a failure at allNothing (shared case UW-009 shows it)An override record, human_decision
The decision is submitted twiceA duplicate writeNothingA key on the decision, as on every write
The policy changed while the task waitedVersion skewThe row carries policy_version (INV-6)A check of the version when the person decides

The README of the example says it plainly: the human step is not simulated, and approval timeouts and escalation are not in its code. Everything in the next three sections is therefore a design this site proposes, with illustrative numbers, not an output of the example.

What this is not. Which actions need a person's approval at all, and how a policy enforces that rule, belongs to guardrails: https://guardrails.sammuthu.com. This page owns what happens to a run while the person it waits for is late, absent or wrong.

Approval timeouts: a deadline for the person#

A provider call has a timeout: after 2 seconds the workflow stops listening. The person needs the same idea, on a different clock. An approval timeout is the longest a review task may wait for a decision before the system acts on the delay. A tiny example, illustrative: the review task of SUB-1004 is due one business day after it opens; at that moment, if nobody has decided, the task moves along its path.

The obvious design copies the machine timeout too closely. When the time runs out, decide: auto-approve the clean cases, auto-decline the rest. That breaks the one rule this whole series keeps. R-HUMAN-01 says every recommendation needs a decision by an authorized underwriter, and INV-3 checks that the agent never writes a decisions row. A timeout that decides is the agent deciding, with a delay.

So the approval timeout never decides. It does one of three things, in order: it reminds the assigned person, it reassigns the task to the next role on the path, and finally it tells a person with authority that the case is overdue. The run stays in waiting_for_human the whole time; what changes is the owner of the review task. Retrying a person means reminding them, and escalating means asking someone else.

Common confusion. "The run has a deadline of 120000 ms, so the human step must finish inside it." No. The deadline in this example bounds the automated part, which ends when the review task is open. The person's step has its own clock, measured in business hours, and its own terminal outcomes. Mixing the two either makes every run fail its deadline or hides a forgotten task inside a run that "ended normally".

The escalation path and delegation#

An escalation path is the ordered list of roles a task moves through when it is not decided in time, each with its own approval timeout. It is written down before it is needed, because the moment it is needed is the moment nobody has time to think about it. An illustrative path for the insurance example:

LevelWho holds the taskApproval timeout (illustrative)What happens when it passes
0The assigned underwriter1 business dayA reminder, then level 1
1The pool of senior underwriters4 business hoursThe task moves to the pool's priority lane, then level 2
2The underwriting manager1 business dayA notice that the case is overdue; the manager assigns it or tells the broker

Every role on the path must be authorized to decide this kind of case. An escalation that ends with "anyone who is free" turns a delay into a breach of R-HUMAN-01. For escalate recommendations such as SUB-1004, level 0 is already a senior underwriter, so the path is shorter.

Delegation handles the absence the path cannot see. A person who will be away hands their authority, for a stated period, to another authorized person, and the system records who delegated to whom, from when to when, and for which kinds of case. A task that falls due while its owner is away then goes to the delegate before any timeout runs out. A delegation without an end date is how authority leaks; give it one.

The diagram shows the path of one review task, with the decision that only a person writes.

Diagram: One review task on its escalation path: every timeout leads to another person, never to a decision

Read left to right. The automated run ends when the review task is open, in the state waiting_for_human. From then on the task has its own clock in business hours. If the assigned underwriter does not decide in time, a reminder goes out and the task moves to the pool of senior underwriters, then to the underwriting manager. A delegate takes over when the owner is away. At every level the only way forward to a decision is a person writing human_decision. The timeouts and levels are illustrative designs; the example does not simulate the human step.

  1. The automated run · ends here
    1. waiting_for_human: The normal end of the automated part: one recommendation row and one review task. The run's 120000 ms deadline does not cover the person's time.
  2. The escalation path · its own clock
    1. Level 0 · assigned underwriter: The person the task was routed to. When the due time passes, a reminder, then the next level.
    2. Level 1 · senior pool: Any authorized senior underwriter may take the task. It moves to a priority lane.
    3. Level 2 · manager: A person with authority assigns the task or tells the broker. The path ends with a person, not with a default.
  3. Absence · recorded in advance
    1. Delegate: An authorized person who holds the owner's tasks while the owner is away, for a stated period and kind of case.
  4. The decision · only a person
    1. human_decision: What the person decided, whether it overrides the agent, and why. Written once; a double submission stores one row. INV-3 holds.

Notice the arrow that is missing: there is no path from a timeout to a decision. Every timeout leads to another person.

The clock of an approval timeoutBusiness hours, durable timers, and a timeout that survives a deployment

An approval timeout counts business hours in the underwriter's calendar, not milliseconds on a worker. "One business day" opened at 17:00 on a Friday falls due at 17:00 on Monday, and a public holiday moves it again. Compute the due time once, when the task opens, store it on the task, and recompute only when the calendar changes.

The timer must survive the same faults the run survives. A timeout held in a worker's memory dies with the worker, which is the crash of Checkpoints on a longer scale. Store the due time with the task and let a scheduled job, or a workflow engine's durable timer, find the overdue tasks. Workflow engines offer durable timers and callback tasks for this; what each one documents about long waits and their limits is on Frameworks. Whichever you use, give the waiting step a timeout of its own.

Escalation is a write (the task changes owner), so it needs what every write needs: a key such as <task_id>:escalate:<level>, so that two scheduler instances escalating the same task leave one escalation.

The override record: what the person decided#

When the person decides, the decision is written once, by the person, and it says whether it agrees with the agent. In shared case UW-009 the agent recommends approve for a clean office building, and the underwriter declines after 90 minutes because the broker's loss run shows an open water damage claim that is not on the application. Nothing failed. This is the human step working: the person knew something the agent did not.

The record of that act is human_decision. Its shape on this site:

{"recommendation_id": "REC-0001", "submission_id": "SUB-1009",
 "human_decision": {"decided_by": "underwriter", "decision": "decline", "override": true,
                    "reason": "The broker's loss run shows an open water damage claim that is not on the application."},
 "policy_version": "2026.2", "decided_after_minutes": 90}

Three reliability rules follow from the earlier pages. The decision is a write, so it carries a key, here one decision per recommendation enforced by a unique index; a double click in the underwriter cockpit then stores one row. Only a person writes it, which INV-3 checks on the agent's side. And the person decides on the recommendation as it was stored: if the policy fixture changed while the task waited (a new version became effective), the cockpit must show that the recommendation was written under 2026.2 and that a newer version now applies, rather than let the person approve under rules that no longer hold.

Before AI. Business process engines in Java shops have had user tasks with due dates, reassignment and escalation for a long time, and loan approval systems have had four-eyes rules. The pattern is the same. What is new is the volume and the shape of the input: an agent can open review tasks faster than any team can read them, and each one arrives with a confident text that invites a quick yes.

Cost ceilings: a run that cannot stop spending#

A model call costs something every time it runs, whether its answer is used or not. In this example cost is counted in cost units, simulated tokens, never money: a draft on the primary route costs 1340 cost units, a draft on the fallback route 620. In UW-R05 the first answer is malformed, the workflow asks again, and the run spends 2680 cost units for one recommendation. The malformed answer was paid for.

Retries, re-asks and fallbacks each make a run repeat a call. One repeat is cheap. A run that keeps repeating, because a bug returns the same malformed output forever or a loop calls a tool again and again, spends without limit, and nothing in a retry budget stops it, because a retry budget counts attempts of one step, not spending of one run.

A cost ceiling is the most a single run may spend; when the next call would cross it, the call is not made. In this example the ceiling is 6000 cost units per run. The ceiling is not the shared spending plan of all runs: that is the cost budget of Concurrency, which this page uses and does not redefine. The ceiling is the stop for one runaway.

The example implements it in limits.py, class Budget (the two methods are shown dedented from the class, otherwise verbatim). Read them for one detail: require is called before the call, so a call the run cannot afford is never sent.

def require(self, units: int) -> None:
    """Ask before a call that may cost `units`. Raises BudgetExhausted when the run cannot afford it."""
    if self.spent + units > self.limit_units:
        raise BudgetExhausted(f"{units} cost units asked, {self.remaining()} left of {self.limit_units}")

def charge(self, units: int) -> int:
    """Spend `units` after a call that used them. Returns the total spent."""
    self.require(units)
    self.spent += units
    return self.spent

workflow.py asks the budget inside Workflow._call_model, before each model call, with the comment "the cost ceiling stops a runaway run". BudgetExhausted is a permanent error, so it is not retried. Workflow.draft_recommendation catches it and writes, in code, an escalate with the reason "the run reached its cost ceiling", marks the result degraded, and the run continues to store it and open a review task. The run does not vanish; a person is told why it stopped.

None of the fifteen scenarios reaches the ceiling: the most expensive, UW-R05, spends 2680 cost units. So the next block shows the ceiling directly. It is a short script that imports the example's own Budget, route costs and code_written_escalation, run in a scratch copy of examples/uw-reliability. A successful run proves that the fifth draft is refused before it is sent and that the refusal produces an escalation that still requires a person; it does not prove that 6000 is the right ceiling for any real agent.

# Five drafts on the primary route against the run's cost ceiling (in a scratch copy of the example).
from agent_sim import ROUTE_PROFILE, code_written_escalation
from errors import BudgetExhausted
from limits import Budget
from workflow import RUN_COST_LIMIT

budget = Budget(RUN_COST_LIMIT)
cost = ROUTE_PROFILE["primary"]["cost_units"]
for draft in range(1, 6):
    try:
        budget.require(cost)
    except BudgetExhausted as error:
        print(f"draft {draft}: refused before the call: {error}")
        print(code_written_escalation("2026.2", "the run reached its cost ceiling"))
        break
    print(f"draft {draft}: allowed, {budget.charge(cost)} of {RUN_COST_LIMIT} cost units spent")
draft 1: allowed, 1340 of 6000 cost units spent
draft 2: allowed, 2680 of 6000 cost units spent
draft 3: allowed, 4020 of 6000 cost units spent
draft 4: allowed, 5360 of 6000 cost units spent
draft 5: refused before the call: 1340 cost units asked, 640 left of 6000
{'recommendation': 'escalate', 'reasons': ['the run reached its cost ceiling', 'Next step: a senior underwriter reviews this submission by hand.'], 'citations': [], 'missing': [], 'stated_confidence': 0.0, 'requires_human': True, 'policy_version': '2026.2'}

Notice two things. The refusal happened with 640 cost units still unspent, because the check asks whether the whole next call fits. And the outcome is an honest escalate with requires_human: true: the ceiling turns a runaway into a case for a person, the same move as the degraded request_info of Breakers.

The agent here is a scripted stand-in, and every fault is injected on purpose, so these results show how the mechanism works, not how reliable any model or provider is.

Production pitfall. A ceiling set from the average cost of a run stops healthy runs. In this example a normal run spends 1340 cost units and one re-ask doubles it; a ceiling of 1500 would turn every UW-R05 into an escalation. Set the ceiling from the high end of the distribution of cost per run (the cost SLI of SLOs), leave room for the retries and re-asks the workflow allows, and alert on runs that reach it: each one is either a runaway or a ceiling set too low, and both need a person.
Ceilings at three scopes, and the estimate problemPer run, per tenant per day, and a provider's own cap

A ceiling per run stops one runaway. It does not stop a thousand normal runs started by a bug in the intake step; that needs a ceiling per tenant or per day, the shared budget of Concurrency, with its own honest outcome (new runs wait, or are refused with a reason). A third ceiling sits outside your system: model providers enforce spending limits on the account. What one provider documents about the response at that limit, including that retries fail until the limit resets, is on Frameworks. Your own ceilings should trigger well before the provider's, so the outcome is a decision of yours and not an outage.

The check before the call needs to know the cost of a call that has not happened. The example uses a fixed cost per route. A real model's cost depends on the length of its answer, which is not known in advance; the usual design reserves the maximum the call may cost (from the output limit set on the request) and charges the actual cost afterwards. That is safe and wasteful: reserving the maximum refuses some calls that would have fit. Which side of that trade a team takes is a design decision to write down.

Capacity: two queues, one in seconds and one in hours#

The workflow feeds two queues. Runs wait for the roof-data provider and the model provider, in seconds. Review tasks wait for underwriters, in hours. Both behave the same way, and one law relates what you can measure about them.

Capacity planning means making sure there is enough capacity, and enough to spare, for the demand you expect, at the reliability you promised. Google's SRE book lists what it takes: a forecast of normal growth, the expected effect of launches and campaigns, and regular load tests that tie raw capacity to what the service can do (Site Reliability Engineering, Introduction).

Queueing delay is the time a piece of work waits before anyone starts on it. A tiny example, illustrative: a review task opened at 09:00 and picked up at 11:00 had two hours of queueing delay, whatever the review then took.

The law is Little's law: the average number of items in a system equals the average arrival rate times the average time each item spends in it, L = λW. Its author's 50th-anniversary paper shows that over a finite period of observation it holds exactly, with no assumption about the arrival pattern or the order of service (Little's Law as Viewed on Its 50th Anniversary, Operations Research 59(3), 2011; a copy hosted for a university course). The same paper adds a caution: the law relates measured averages; it does not forecast them.

The diagram shows the two queues and what each one waits on.

Diagram: Two queues fed by one workflow: seconds in front of the provider, hours in front of the underwriter

Read left to right. Submissions arrive and runs start. While a run waits on the roof-data provider, it holds a worker, a lease and a slot of the provider's rate limit; when the provider slows from 180 ms to 5140 ms, as in UW-R02, the number of runs waiting multiplies by almost thirty at the same arrival rate. Each finished run opens a review task, and tasks wait for underwriters for hours. In both queues Little's law ties the measured averages together: items waiting equal the arrival rate times the time in the system. Headroom, the spare capacity at the peak, decides how fast a backlog drains. The rates in this diagram are illustrative.

  1. Arrivals
    1. Runs start: The arrival rate of the first queue. Little's law calls it lambda.
  2. Queue 1 · seconds
    1. Waiting on the provider: Runs in step 2. Healthy: 5 x 0.18 s = 0.9 on average. With two timeouts and backoff, step 2 takes 5140 ms in this example: 5 x 5.14 s, about 26.
  3. Queue 2 · hours
    1. Review tasks open: Tasks from opening to decision. With an average of 2 hours in the system, 24 are open at once, illustratively.
  4. Recovery
    1. Headroom: Spare capacity at the peak. A backlog of 36 tasks after a 3-hour outage drains in 36 / 4 = 9 working hours. With no headroom it never drains.

In front of the provider. The next numbers are illustrative: suppose 5 runs start per second. In the healthy example, step 2 calls the provider for 180 ms, so on average 5 × 0.18 = 0.9 runs are waiting on the provider at once. In UW-R02 the provider times out twice and step 2 takes 5140 ms in this example (two attempts of 2000 ms, backoff of 52 and 908 ms, and the successful 180 ms call). At the same arrival rate, 5 × 5.14 ≈ 26 runs now wait on the provider at once. Nothing changed in the demand. A slow dependency multiplied the work in flight by almost thirty, and every one of those runs holds a worker, a lease and a slot of the provider's rate limit. This is why Breakers and Concurrency cap what may wait on one dependency.

In front of the underwriter. Again illustrative: 12 review tasks open per hour, a review takes 15 minutes on average, and four underwriters are on shift. Together they can finish 16 tasks per hour, so they are busy 12 / 16 = 75% of the time. If tasks spend two hours on average from opening to decision, Little's law says 12 × 2 = 24 tasks are open at any moment, which the team can check against the cockpit.

Headroom is the capacity left over at the expected peak: here 16 − 12 = 4 tasks per hour. It looks like waste until something goes wrong. Suppose the underwriter cockpit is down for three hours and 36 tasks pile up. New tasks keep arriving at 12 per hour, so the backlog drains only at the rate of the headroom: 36 / 4 = 9 working hours, more than a full day, while every new task waits behind the backlog. With three underwriters instead of four, capacity is 12 per hour, the headroom is zero, and the backlog never drains on its own. The same arithmetic holds for the provider queue after an outage: the retry storm of Retries is a backlog trying to drain through no headroom at all.

The rule that follows: plan capacity so that the expected peak leaves headroom for the recovery you need, then decide what the recovery time may be. "We can absorb three lost hours and be current again by the end of the next day" is a capacity plan. "We are at 100% and fine" is a plan for the day nothing fails.

Using Little's law without misusing itWhat it needs, what it gives, and where it says nothing

L = λW needs three numbers measured over the same period and the same boundary. Count tasks "in the system" from the moment they open to the moment of decision, measure arrivals over the same window, and the law ties them together; change the boundary (from pickup, not from opening) and W changes meaning. The paper's point about finite periods matters in practice: over a day that starts and ends with an empty queue, the law holds exactly for that day's numbers.

What it does not give is the shape of the waiting. Two teams with the same average time in system can have very different worst cases, and the broker who waits three days does not care about the average. For the tail, measure the distribution of queueing delay, as SLOs measures latency percentiles, and set the approval timeouts above from that distribution.

The provider calculation above uses the same law for a different question: given the arrival rate and the time a call takes, how many calls are in flight. That is the number to compare with the concurrency limit, the worker pool and the provider's rate limit.

Ordering the human queueEscalations first, by due time, with a limit on work in progress

A queue in front of people needs an order, and first-come-first-served is a choice, not a default. Order by due time (the approval timeout computed when the task opened), with escalations and request_info tasks in a lane of their own, because a broker is waiting on the missing information. Cap the work in progress per person: twenty tasks assigned to one underwriter is a queue hidden inside an inbox, and Little's law applies to it as well.

Watch for the failure that looks like throughput. Under pressure, a person can approve tasks faster by reading less, and the queue shrinks. The rate of overrides (UW-009) is one signal that people are still reading: a team whose override rate falls to zero while the queue grows deserves a look. Measuring that well belongs to evaluation: https://eval.sammuthu.com.

The same idea for a coding agent#

A coding agent opens a pull request and waits for a human review before merge. The reviewer named by the repository's ownership rules is away, and the pull request sits for a week while the branch drifts from main. The design is the one above: a review due time, a reminder, reassignment to the next owner, and never an automatic approval when the time runs out. The agent's own run has a cost ceiling too: a loop of "run the tests, read the failure, edit, run the tests" that never converges should stop at a ceiling and hand the branch to a person with a reason. And the CI runners are the provider queue: a slow test suite multiplies the agent runs waiting on CI exactly as a slow provider did. The runtime around such an agent is https://harness.sammuthu.com; the review and merge path is https://diff-to-deploy.sammuthu.com.

Open problems#

These are the parts of the problem for which this site has no settled answer. They are stated so that a design can decide on them on purpose.

ProblemWhy it is hardWhat a design can at least do
No authorized person is available before the broker's deadlineThe rule (R-HUMAN-01) and the business promise conflict; no code can resolve thatMake the conflict visible early, and let a manager decide, on the record
A recommendation goes stale while it waitsThe policy, the roof data or the submission can change during days of waitingStore policy_version and evidence_ids (INV-6) and check them when the person decides
Approval under pressure turns into a rubber stampThroughput rises while scrutiny falls; nothing failsWatch override rates and time per review next to queue length
The cost of a model call is unknown until it endsA ceiling checked before the call must estimateReserve the maximum, charge the actual, and write the trade down
Retries hide in layersA library, an SDK and an engine can each retry the same callName one owner per step (Frameworks)
The provider's capacity is not yoursRate limits and capacity can change without your releaseKeep headroom below the provider's limit and a fallback route (Fallback)
Failures correlateA fallback provider may share an upstream with the primary; a holiday removes many reviewers at onceTest the correlated case in a game day, not only single faults (Fault injection)
What this is not. Seeing the queue length, the age of the oldest task and the spending per run is observability: https://observe.sammuthu.com. This page decides what those numbers must stay below, and what happens when they do not.

Checklist#

QuestionGood answer
Does every review task have a due time, stored with the task?Yes, in business hours, computed when the task opens
What happens when it passes?A reminder, then reassignment along a written escalation path; never a decision
Is every role on the path authorized to decide the case?Yes, checked against R-HUMAN-01
Is delegation recorded, with an end date?Yes
Does the decision carry a key, and is it written only by a person?Yes: one decision per recommendation; INV-3 holds
Is the policy version checked when the person decides?Yes; a stale recommendation is flagged
Is a cost ceiling checked before each model call?Yes, with a code-written escalate when it is reached
Was the ceiling set from the distribution of cost per run, with alerts on runs that reach it?Yes
Is there headroom at the expected peak, in front of the provider and in front of the underwriters?Yes, with a stated time to drain a backlog

In one breath#

The underwriter is a dependency like the provider: give the review task a due time, let a missed due time remind and escalate along a path of authorized roles, and never let a timeout decide. Stop each run's spending before the call that would cross its cost ceiling, and turn the stop into an honest escalation. Plan capacity for both queues with headroom, because a backlog drains only as fast as the spare capacity, and Little's law tells you how much work is waiting.

Next: the whole example in one place#

Every mechanism of this site has now been met on its own page, and this one added the parts no library wraps. The insurance lab puts them back together: one quote, fifteen ways to fail, the full fault-injection suite, and the careful and naive workflows side by side, with the code that produced every number.