Agents That Finish
Engineering long-horizon reliability into software that runs without you
Agent reliability is an architecture, not a model property: systems complete multi-hour work because they can decompose it, verify each step, checkpoint state and undo a wrong commitment.
Frontier models are close to perfect on work a skilled person would finish in four minutes and close to useless on work that takes four hours. The gap is not intelligence. It is that most agent architectures cannot notice a wrong intermediate state, let alone roll one back, so the first bad commitment is inherited by every step after it. This book builds outwards from that failure mode: decomposition as a real artifact, verification between steps, checkpoints an agent can resume from, compensating actions for effects that already left the system, and budgets that bound the damage when none of it works.
What it makes operable
-
01
Instrument the step where your agent's first wrong commitment happens
-
02
Design checkpoints and compensating actions an agent can genuinely recover through
-
03
Place verification gates between steps instead of trusting the final answer
-
04
Measure a reliability horizon for your own workload rather than a benchmark's
Contents
12 of 12 published
Every chapter is free to read in the browser, cites its own sources, and stands on its own if you came for one decision rather than the whole argument.
- 01 The Four-Minute Agent and the Four-Hour Task Where the reliability horizon actually sits, and why capability scores hide it. 10 min
- 02 Why Failures Compound: The No-Recovery Bottleneck One wrong intermediate state, inherited by every step that follows it. 10 min
- 03 Decomposition as an Engineering Artifact, Not a Prompt Writing the plan as a structure the runtime can check, resume and revise. 10 min
- 04 Checkpoints: What an Agent Must Be Able to Resume From Choosing the state boundary that makes a restart cheap and a rollback possible. 11 min
- 05 Verification Gates Between Steps Cheap per-step checks that catch a wrong commitment before it propagates. 10 min
- 06 Compensating Actions and Safe Undo Reversing effects that already left your system, and admitting when you cannot. 10 min
- 07 Durable Execution: Workflows, Retries, Idempotency Where agent state lives when the process running it dies mid-task. 10 min
- 08 Tools Are the Real Interface Designing an API for a caller that will sometimes get the arguments wrong. 10 min
- 09 Budgets: Time, Tokens, Tool Calls, Blast Radius Four ceilings that turn an open-ended loop into a bounded operation. 10 min
- 10 Handing Control Back to a Human Escalation as a designed path, carrying enough context to be actionable. 10 min
- 11 Measuring a Reliability Horizon for Your Own Workload Building the curve for your tasks instead of inheriting someone else's benchmark. 10 min
- 12 On-Call for Agents Alerts, kill switches and the runbook for software that acts on its own. 10 min
Evidence · 3 sources
Third-party sources behind the book's premise. Every figure in them belongs to the party that published it and is attributed to them in the text.
