Skip to content
Contents
Decision AI

    Type to search. Planned chapters match by title only.

    Chapter 3.1

    Deciding when an agent is finished

    On tasks written for this booklet, an agent's first finish met every checked requirement in 87.5% of runs, sending it back on a model's judgment raised that to 90.0%, about what sending every finish back achieves, and telling it which requirement failed raised that to 94.0%.

    Affiliation
    NYU Stern
    Published

    Full report: every estimate with its interval, and every figure as a table.

    DraftFigures and numbers may change as the analysis is rebuilt.what is still being checked

    First draft, without human rating: verdicts come from grader rules written before any run. Revised after the metrics review: the grader was amended and every controller was run to the end of the task.

    An AI agent finishes a task and says it is done. Someone, or something, now has to decide whether to believe it. Accept a wrong "done" and a person finds the mistake later, when it is expensive to fix. Check every "done" and the agent saves far less time than it promised. This chapter asks whether a model reading the agent's record can make that call.

    The agent in this test said it was done too early on 13%12.5% percent of finish attemptsEstimandagent said done while a rule-checked criterion was unmetn200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of its first finishes. Sending work back on a model's judgment raised the share of runs with every checked requirement met from 88%87.5% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 81.0% to 93.0%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks to 90%90.0% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 85.5% to 94.5%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks, about the same as sending every finish back, while a check that named the failed requirement reached 94%94.0% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 90.5% to 97.0%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks. So telling the agent what failed mattered more than asking it to look again. The tasks were written for this booklet and that check is the grader itself, so this shows the pattern in one test and not what a real test suite would deliver.

    The decision
    Owner and actions
    The team running the agent platform decides what happens when the agent stops.
    Evidence at decision time
    The request, the completion criteria, the recent steps and tool results, and the current state of the work.
    Simplest alternative
    Accept every finish, send every finish back, run simple checks on the record, or send every finish to a person.
    What establishes correctness
    A grader whose rules were written before any run, and for faults, the right action as built into the fault.
    When the model is wrong or cannot decide
    A premature finish means rework later; a needless check costs a person's time.
    Does the policy pay
    Share of runs with every checked requirement met when each policy runs to the end, and expected cost per hundred finish attempts under stated costs.

    The test

    One agent worked through 4040 tasksEstimandconstructed tasksWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks short tasks: update a document, answer from a set of records, repair a small program. Each task ran several times, and the harness injected a different problem each time, such as a failed tool call or a required input held back. That produced 200200 finish attemptsEstimandtimes the agent said it was doneWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks moments when the agent said it was done, and at 2525 finish attemptsEstimandagent said done while a rule-checked criterion was unmetWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of them a rule-checked requirement was still unmet.

    Figure 1

    The agent's "done" is usually right and wrong often enough to matter

    Finish attempts by task kind and the grader's verdict, percent of attempts

    Show data
    Data for The agent's "done" is usually right and wrong often enough to matter
    kindshareverdict
    Answer from records78.50Criteria met
    Answer from records21.50Said done too early
    Repair a program86.20Criteria met
    Repair a program13.80Said done too early
    Update a document97.10Criteria met
    Update a document2.90Said done too early
    Each bar splits the agent's finish attempts by what the grader found. The grader checks rules written before any run, and rater-only criteria on document tasks are not checked.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs with injected faults, October 2026; unweighted

    Answering from records is where the agent stopped too early most often, 22%21.5% percent of finish attemptsEstimandpremature, record lookupsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks against 8%8.1% percent of finish attemptsEstimandpremature, documents and program repairWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks elsewhere, though a handful of tasks hold many of these finishes, so that gap is not firmly established. A wrong number looks just like a right one, and the record shows no failed test to give it away.

    Reading the record tells a model something about whether the work is done

    Each model read the record at the moment of the finish attempt and gave a probability that all the criteria had been met.

    Figure 2

    Reading the trace tells the models something about whether the work is done, with wide intervals on this few tasks

    AUC of each model's P(done) against the grader's verdict, with 95% intervals, finish attempts

    • Decision engine
    • General language model
    Show data
    Data for Reading the trace tells the models something about whether the work is done, with wide intervals on this few tasks
    aucconf_highconf_lowkindmodeln
    0.7130.8300.551Decision engineJev 1.14.0200
    0.7600.8620.624Decision engineOpenAI Luna200
    0.7650.8730.621General language modelClaude Haiku adapter200
    The dashed line marks a coin flip, and the right edge of the scale is perfect. Each whisker is an interval from resampling tasks, and with this few tasks the intervals are wide.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs with injected faults, October 2026; unweighted

    The scores are 0.710.71 area under the ROC curveEstimandP(done) against the grader's verdict on finish attemptsInterval95% CI 0.55 to 0.83n200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks for Jev and 0.760.76 area under the ROC curveEstimandP(done) against the grader's verdict on finish attemptsInterval95% CI 0.62 to 0.87n200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks for the general language model, well short of perfect, with wide intervals. They also depend on how finishes with an unscored rater-only criterion are treated, since there are 3434 finish attemptsEstimandcounted as met with a rater-only criterion unscoredWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of them: Jev's score is 0.720.72 area under the ROC curveEstimandJev, leaving those finishes outWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks leaving them out and 0.560.56 area under the ROC curveEstimandJev, counting those finishes as unmetWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks counting them as unmet. Jev's choice of next action points the same way. On the premature finishes, it still says to finish 96%96.0% percent of premature finishesEstimandJev's next action is still finishn25 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of the time. A record can show that an agent did the steps and sounded sure. It often cannot show that the answer is right, because the model judging it has no more access to the truth than the agent did.

    Choose the next action

    Some finished-looking traces are not finished

    Constructed tasks: read the request, the criteria and the last steps, then pick the next action

    constructed set: not pooled with sampled results

    Item 1 of 8

    Checkpoint 1: the agent says it is done

    Request

    How many units of SKU K-220 are on hand across all warehouses, excluding quarantined lots? Give the total and the units per warehouse.

    Completion criteria

    • The answer gives the total units on hand, excluding quarantined lots.
    • The answer gives the units per warehouse.

    Trace so far (checkpoint type: after_contradiction)

    StepActionTool result
    1query_records {"table": "inventory", "where": {"sku": "K-220"}}7 row(s) [ {"lot": "L-01", "quarantined": false, "sku": "K-220", "units": 120, "warehouse": "W1"}, {"lot": "L-02", "quarantined": true, "sku": "K-220", "units": 40, "warehouse": "W1"}, {"lot":…
    2finishCalculated non-quarantined inventory by warehouse and in total.
    What should the controller do next?
    Choose an option to enable the reveal.constructed

    Checkpoint 1: the agent says it is done: make your ruling first. The answers appear after you choose one of 5 options and reveal.

    The data table for this item appears after your ruling.

    Decide first, then see what each model chose and what the grader's verdict makes acceptable.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs with injected faults, October 2026; unweighted

    Priced on recorded finishes, a model saves a little over a person

    Suppose accepting a premature finish costs $50$50 US dollars per premature finish acceptedEstimandassumed rework costWeightsnot applicable; assumed inputsPopulationa controller's decision on one finish attempt (assumed inputs)Periodassumed inputs, October 2026SourceConstructed agent tasks in rework and sending a finish to a person costs $5$5 US dollars per finish attempt sent to a personEstimandassumed: five minutes at a dollar a minuteWeightsnot applicable; assumed inputsPopulationa controller's decision on one finish attempt (assumed inputs)Periodassumed inputs, October 2026SourceConstructed agent tasks. Then a controller should accept only when the model puts the chance of being done above 0.90.9 probability that the work is doneEstimand1 minus person cost over premature costWeightsnot applicable; assumed inputsPopulationa controller's decision on one finish attempt (assumed inputs)Periodassumed inputs, October 2026SourceConstructed agent tasks, because a mistake costs far more than a check.

    Figure 3

    At high cutoffs the models land near the cost of sending every finish to a person

    Expected cost per 100 finish attempts by the cutoff for accepting, at assumed costs

    Show data
    Data for At high cutoffs the models land near the cost of sending every finish to a person
    costcutoffpolicy
    5250.500Jev 1.14.0
    5250.510Jev 1.14.0
    502.50.520Jev 1.14.0
    5050.530Jev 1.14.0
    4600.540Jev 1.14.0
    4600.550Jev 1.14.0
    442.50.560Jev 1.14.0
    4450.570Jev 1.14.0
    4450.580Jev 1.14.0
    4500.590Jev 1.14.0
    452.50.600Jev 1.14.0
    452.50.610Jev 1.14.0
    4550.620Jev 1.14.0
    4600.630Jev 1.14.0
    462.50.640Jev 1.14.0
    462.50.650Jev 1.14.0
    462.50.660Jev 1.14.0
    4650.670Jev 1.14.0
    4500.680Jev 1.14.0
    4500.690Jev 1.14.0
    4300.700Jev 1.14.0
    4300.710Jev 1.14.0
    432.50.720Jev 1.14.0
    4350.730Jev 1.14.0
    4150.740Jev 1.14.0
    4200.750Jev 1.14.0
    4250.760Jev 1.14.0
    4150.770Jev 1.14.0
    422.50.780Jev 1.14.0
    382.50.790Jev 1.14.0
    3950.800Jev 1.14.0
    407.50.810Jev 1.14.0
    422.50.820Jev 1.14.0
    4400.830Jev 1.14.0
    4200.840Jev 1.14.0
    427.50.850Jev 1.14.0
    442.50.860Jev 1.14.0
    4150.870Jev 1.14.0
    382.50.880Jev 1.14.0
    392.50.890Jev 1.14.0
    412.50.900Jev 1.14.0
    397.50.910Jev 1.14.0
    4150.920Jev 1.14.0
    4350.930Jev 1.14.0
    462.50.940Jev 1.14.0
    4600.950Jev 1.14.0
    467.50.960Jev 1.14.0
    4950.970Jev 1.14.0
    5000.980Jev 1.14.0
    5000.990Jev 1.14.0
    502.50.500OpenAI Luna
    502.50.510OpenAI Luna
    502.50.520OpenAI Luna
    502.50.530OpenAI Luna
    5050.540OpenAI Luna
    5050.550OpenAI Luna
    5050.560OpenAI Luna
    5050.570OpenAI Luna
    5050.580OpenAI Luna
    5050.590OpenAI Luna
    5050.600OpenAI Luna
    5050.610OpenAI Luna
    507.50.620OpenAI Luna
    507.50.630OpenAI Luna
    5100.640OpenAI Luna
    5100.650OpenAI Luna
    5100.660OpenAI Luna
    5100.670OpenAI Luna
    4900.680OpenAI Luna
    472.50.690OpenAI Luna
    472.50.700OpenAI Luna
    472.50.710OpenAI Luna
    472.50.720OpenAI Luna
    477.50.730OpenAI Luna
    477.50.740OpenAI Luna
    477.50.750OpenAI Luna
    482.50.760OpenAI Luna
    482.50.770OpenAI Luna
    4600.780OpenAI Luna
    4600.790OpenAI Luna
    437.50.800OpenAI Luna
    437.50.810OpenAI Luna
    417.50.820OpenAI Luna
    4200.830OpenAI Luna
    422.50.840OpenAI Luna
    4250.850OpenAI Luna
    427.50.860OpenAI Luna
    4100.870OpenAI Luna
    3950.880OpenAI Luna
    4000.890OpenAI Luna
    4050.900OpenAI Luna
    407.50.910OpenAI Luna
    3650.920OpenAI Luna
    372.50.930OpenAI Luna
    3600.940OpenAI Luna
    3100.950OpenAI Luna
    3150.960OpenAI Luna
    327.50.970OpenAI Luna
    337.50.980OpenAI Luna
    357.50.990OpenAI Luna
    412.50.500Claude Haiku adapter
    412.50.510Claude Haiku adapter
    412.50.520Claude Haiku adapter
    412.50.530Claude Haiku adapter
    412.50.540Claude Haiku adapter
    4150.550Claude Haiku adapter
    4150.560Claude Haiku adapter
    4150.570Claude Haiku adapter
    4150.580Claude Haiku adapter
    4150.590Claude Haiku adapter
    3950.600Claude Haiku adapter
    3950.610Claude Haiku adapter
    3950.620Claude Haiku adapter
    3950.630Claude Haiku adapter
    3950.640Claude Haiku adapter
    3950.650Claude Haiku adapter
    3950.660Claude Haiku adapter
    3950.670Claude Haiku adapter
    3950.680Claude Haiku adapter
    3950.690Claude Haiku adapter
    372.50.700Claude Haiku adapter
    372.50.710Claude Haiku adapter
    372.50.720Claude Haiku adapter
    372.50.730Claude Haiku adapter
    372.50.740Claude Haiku adapter
    372.50.750Claude Haiku adapter
    372.50.760Claude Haiku adapter
    372.50.770Claude Haiku adapter
    372.50.780Claude Haiku adapter
    372.50.790Claude Haiku adapter
    3000.800Claude Haiku adapter
    3000.810Claude Haiku adapter
    302.50.820Claude Haiku adapter
    302.50.830Claude Haiku adapter
    302.50.840Claude Haiku adapter
    362.50.850Claude Haiku adapter
    362.50.860Claude Haiku adapter
    362.50.870Claude Haiku adapter
    362.50.880Claude Haiku adapter
    362.50.890Claude Haiku adapter
    387.50.900Claude Haiku adapter
    387.50.910Claude Haiku adapter
    392.50.920Claude Haiku adapter
    4950.930Claude Haiku adapter
    4950.940Claude Haiku adapter
    487.50.950Claude Haiku adapter
    492.50.960Claude Haiku adapter
    5000.970Claude Haiku adapter
    5000.980Claude Haiku adapter
    5000.990Claude Haiku adapter
    6250.500Accept every finish
    5000.500Send every finish to a person
    6250.510Accept every finish
    5000.510Send every finish to a person
    6250.520Accept every finish
    5000.520Send every finish to a person
    6250.530Accept every finish
    5000.530Send every finish to a person
    6250.540Accept every finish
    5000.540Send every finish to a person
    6250.550Accept every finish
    5000.550Send every finish to a person
    6250.560Accept every finish
    5000.560Send every finish to a person
    6250.570Accept every finish
    5000.570Send every finish to a person
    6250.580Accept every finish
    5000.580Send every finish to a person
    6250.590Accept every finish
    5000.590Send every finish to a person
    6250.600Accept every finish
    5000.600Send every finish to a person
    6250.610Accept every finish
    5000.610Send every finish to a person
    6250.620Accept every finish
    5000.620Send every finish to a person
    6250.630Accept every finish
    5000.630Send every finish to a person
    6250.640Accept every finish
    5000.640Send every finish to a person
    6250.650Accept every finish
    5000.650Send every finish to a person
    6250.660Accept every finish
    5000.660Send every finish to a person
    6250.670Accept every finish
    5000.670Send every finish to a person
    6250.680Accept every finish
    5000.680Send every finish to a person
    6250.690Accept every finish
    5000.690Send every finish to a person
    6250.700Accept every finish
    5000.700Send every finish to a person
    6250.710Accept every finish
    5000.710Send every finish to a person
    6250.720Accept every finish
    5000.720Send every finish to a person
    6250.730Accept every finish
    5000.730Send every finish to a person
    6250.740Accept every finish
    5000.740Send every finish to a person
    6250.750Accept every finish
    5000.750Send every finish to a person
    6250.760Accept every finish
    5000.760Send every finish to a person
    6250.770Accept every finish
    5000.770Send every finish to a person
    6250.780Accept every finish
    5000.780Send every finish to a person
    6250.790Accept every finish
    5000.790Send every finish to a person
    6250.800Accept every finish
    5000.800Send every finish to a person
    6250.810Accept every finish
    5000.810Send every finish to a person
    6250.820Accept every finish
    5000.820Send every finish to a person
    6250.830Accept every finish
    5000.830Send every finish to a person
    6250.840Accept every finish
    5000.840Send every finish to a person
    6250.850Accept every finish
    5000.850Send every finish to a person
    6250.860Accept every finish
    5000.860Send every finish to a person
    6250.870Accept every finish
    5000.870Send every finish to a person
    6250.880Accept every finish
    5000.880Send every finish to a person
    6250.890Accept every finish
    5000.890Send every finish to a person
    6250.900Accept every finish
    5000.900Send every finish to a person
    6250.910Accept every finish
    5000.910Send every finish to a person
    6250.920Accept every finish
    5000.920Send every finish to a person
    6250.930Accept every finish
    5000.930Send every finish to a person
    6250.940Accept every finish
    5000.940Send every finish to a person
    6250.950Accept every finish
    5000.950Send every finish to a person
    6250.960Accept every finish
    5000.960Send every finish to a person
    6250.970Accept every finish
    5000.970Send every finish to a person
    6250.980Accept every finish
    5000.980Send every finish to a person
    6250.990Accept every finish
    5000.990Send every finish to a person
    Each line shows what a controller would cost if it accepted the agent's finish above that probability and sent the rest to a person. The two dashed lines are the policies that ignore the model.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs with injected faults, October 2026; unweighted

    Accepting everything costs $625$625 US dollars per 100 finish attemptsEstimandpremature finishes accepted plus finish attempts sent to a personInterval95% CI $350 to $951n200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasksNoteAssumed costs; a person is assumed to catch every premature finish. per hundred finish attempts, and sending everything to a person costs $500$500 US dollars per 100 finish attemptsEstimandpremature finishes accepted plus finish attempts sent to a personn200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasksNoteAssumed costs; a person is assumed to catch every premature finish.. Models with a cutoff land around that second number: $413$413 US dollars per 100 finish attemptsEstimandpremature finishes accepted plus finish attempts sent to a personInterval95% CI $327 to $500n200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasksNoteAssumed costs; a person is assumed to catch every premature finish. for Jev and $388$388 US dollars per 100 finish attemptsEstimandpremature finishes accepted plus finish attempts sent to a personInterval95% CI $285 to $497n200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasksNoteAssumed costs; a person is assumed to catch every premature finish. for the language model. To get there, Jev sends 84%84.0% percent of premature finishesEstimandpremature finishes sent to a personWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of the premature finishes to a person and also 59%59.4% percent of finished workEstimandfinished work sent to a person anywayWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of the finished work. A simple set of checks on the record, such as whether the last test run passed, stops almost nothing here: it catches 0%0.0% percent of premature finishesEstimandpremature finishes sent to a personWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of premature finishes and costs $625$625 US dollars per 100 finish attemptsEstimandpremature finishes accepted plus finish attempts sent to a personInterval95% CI $350 to $951n200 finish attemptsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 finish attempts by one agent on 40 tasks written for this bookletPeriodagent runs and engine calls, October 2026SourceConstructed agent tasksNoteAssumed costs; a person is assumed to catch every premature finish., because in this test the agent's premature finishes look clean.

    Policy comparison

    Model policies cost a little less than sending every finish to a person at these costs

    Cost per 100 finish attempts, premature finishes caught and finished work sent to a person, by controller, with 95% intervals

    constructed set: not pooled with sampled results

    Policyderivedmeasuredmeasured
    Jev, person below the cutoff (chapter policy)$413 ($327–$500)84% (64%–98%)59% (49%–70%)
    Accept every finish$625 ($350–$951)0% (0%–0%)0% (0%–0%)
    Simple checks on the trace$625 ($350–$951)0% (0%–0%)0% (0%–0%)
    Luna, person below the cutoff$405 ($243–$585)56% (27%–79%)22% (13%–32%)
    Haiku adapter, person below the cutoff$388 ($285–$498)80% (61%–94%)49% (38%–59%)
    Send every finish to a person$500 ($500–$500)100% (100%–100%)100% (100%–100%)

    n = 200 items. Intervals are paired bootstrap 95% intervals from the pipeline.

    Jev, person below the cutoff: cost per 100 $413 (95% interval $327 to $500). Haiku adapter, person below the cutoff has the lowest point estimate on this measure, $388 (95% interval $285 to $498).

    Show data
    Data for Model policies cost a little less than sending every finish to a person at these costs
    PolicyCost per 100Lower 95%Upper 95%Premature caughtLower 95%Upper 95%Finished work sent to a personLower 95%Upper 95%
    Jev, person below the cutoff413327500846498594970
    Accept every finish625350951000000
    Simple checks on the trace625350951000000
    Luna, person below the cutoff405243585562779221332
    Haiku adapter, person below the cutoff388285498806194493859
    Send every finish to a person500500500100100100100100100
    Read across a row. Costs are assumed, and a person is assumed to catch every premature finish. These are scores at recorded finish attempts; the executed comparison comes later in the chapter.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs with injected faults, October 2026; unweighted

    The comparison stops at the finish attempt, and it assumes a person catches every premature finish. It cannot say what would happen if the work went back to the agent.

    Running the automated policies to the end

    So the five automated policies were run; a person was not, and that comparison stays a calculation. When a controller sends work back, the agent receives a message and continues, and its final state is graded by the same rules. Every controller accepts after twotwo send-backs per runEstimandlimit in every controllerWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks send-backs. The tasks, faults and agent are the same, and each run repeats the recorded run exactly until its first send-back. Sharing that history makes the arms easier to compare, though it does not show how much a fresh agent run would vary at each step.

    One run shows why the message matters. A task asked the agent to fix a billing bug: invoices within a five-day grace period were being charged a late fee, and fees after the grace period had to stay as they were. The agent changed the grace period, ran the tests, saw them pass and said it was done. But it had also shifted the formula for later fees, and no test it could see caught that. From there, the same first finish went four ways.

    PolicyWhat the agent was toldWhat it didResult
    AcceptNothingStoppedThe later-fee requirement stays unmet
    Jev, below the cutoffRe-check against each criterion, each time it was sent backRe-read its code, re-ran the tests and said everything was fine each timeStill unmet
    Independent check, silentThe same general messageThe same re-readingStill unmet
    Independent check, namedThat the third criterion is not metRead the older test file, restored the original formula and re-ran the testsEvery checked requirement met

    This run shows the common pattern and not a guarantee: the named message rescued more runs than the general one, and it left others unrepaired, as the counts below show.

    Policy comparison

    Telling the agent what failed raises completed work the most, and a model's send-back saves steps without finishing more

    Share of runs that end with every rule met, steps per run and first finishes sent back, by controller, with 95% intervals; each policy run to the end of the task

    constructed set: not pooled with sampled results

    Policymeasuredmeasuredmeasured
    Independent check, names the failed criterion (chapter policy)94.0% (90.5%–97.0%)5.5 (4.9–6.1)13% (7%–19%)
    Accept every finish87.5% (81.0%–93.0%)5.0 (4.6–5.5)0% (0%–0%)
    Send back every finish89.5% (85.0%–94.0%)9.7 (8.8–10.7)100% (100%–100%)
    Jev, send back below the cutoff90.0% (85.5%–94.5%)8.1 (7.0–9.1)65% (56%–74%)
    Independent check, says only to re-check90.5% (86.0%–94.5%)5.5 (5.0–6.2)13% (7%–19%)

    n = 200 items. Intervals are paired bootstrap 95% intervals from the pipeline.

    Independent check, names the failed criterion: runs with every rule met 94.0% (95% interval 90.5% to 97.0%). It has the highest point estimate on this measure.

    Show data
    Data for Telling the agent what failed raises completed work the most, and a model's send-back saves steps without finishing more
    PolicyRuns with every rule metLower 95%Upper 95%Steps per runLower 95%Upper 95%First finishes sent backLower 95%Upper 95%
    Independent check, names the failed criterion94.090.597.05.54.96.113719
    Accept every finish87.581.093.05.04.65.5000
    Send back every finish89.585.094.09.78.810.7100100100
    Jev, send back below the cutoff90.085.594.58.17.09.1655674
    Independent check, says only to re-check90.586.094.55.55.06.213719
    Read across a row. Every controller accepts after two send-backs. The independent check is the grader itself, which the agent never sees, so its rows are an oracle-style comparator for the checked requirements and not an estimate of any real test suite.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs per controller with injected faults, October 2026; unweighted

    Sending back every finish, with no judgment at all, reaches 90%89.5% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 85.0% to 94.0%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks at 9.79.7 agent steps per runEstimandmean steps to accepted finishInterval95% CI 8.8 to 10.7n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks steps per run, against 5.05.0 agent steps per runEstimandmean steps to accepted finishInterval95% CI 4.6 to 5.5n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks for accepting. Using Jev to choose reaches 90%90.0% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 85.5% to 94.5%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks at 8.18.1 agent steps per runEstimandmean steps to accepted finishInterval95% CI 7.0 to 9.1n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks steps. Jev does carry signal: it sends back 88%88.0% percent of first finishesEstimandJev sends back a first finish that missed a rulen25 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of first finishes that missed a requirement and 62%61.7% percent of first finishesEstimandJev sends back a first finish that met every rulen175 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of those that met them all, which changes the steps per run by −1.7 (95% CI −2.1 to −1.3)−1.7 steps per runEstimandjev minus recheckInterval95% CI −2.1 to −1.3n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks. It does not produce more finished work, with a gain over sending everything back of +0.5 (95% CI 0.0 to 1.5)+0.5 percentage pointsEstimandjev minus recheckInterval95% CI 0.0 to 1.5n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks points, because a general request to look again rarely fixes anything.

    The independent check is different in kind. It is the grader itself, a test the agent never saw, so it sends back only work that missed a checked requirement. It is an oracle-style comparator for the checked requirements, which no real test suite would match, and it does not guarantee a repair after the send-back. Comparing its silent and named rows separates the value of detecting a failure from the value of saying what failed. Told only to re-check, the agent reaches 91%90.5% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 86.0% to 94.5%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks, and fixes the same 66 runsEstimandmissed a rule at the first finish and met every rule at acceptanceWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of 2525 runsEstimandfirst finish missed a rule-checked criterionWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks premature finishes as Jev's and the blanket send-backs do. Told which requirement failed, it reaches 94%94.0% percent of runsEstimandaccepted final state meets every rule-checked criterionInterval95% CI 90.5% to 97.0%n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks, a gain of +6.5 (95% CI 2.5 to 11.5)+6.5 percentage pointsEstimandcheck_named minus acceptInterval95% CI 2.5 to 11.5n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks points over accepting at 5.55.5 agent steps per runEstimandmean steps to accepted finishInterval95% CI 4.9 to 6.1n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks steps, and fixes 1313 runsEstimandmissed a rule at the first finish and met every rule at acceptanceWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks. Naming the failure alone adds +3.5 (95% CI 1.0 to 6.5)+3.5 percentage pointsEstimandcheck_named minus check_silentInterval95% CI 1.0 to 6.5n200 runsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks points. Sending work back also carries a small risk: finished work later failed in 22 runsEstimandmet every rule at the first finish and not at acceptanceWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks runs under sending everything back and 11 runsEstimandmet every rule at the first finish and not at acceptanceWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation200 runs by one agent on 40 tasks written for this booklet, each policy run to the end of the taskPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks under Jev.

    An action changes what the system knows next. The useful part of a send-back is the evidence it carries, and here the agent could act on a specific failure and could do little with a general request to look again.

    Where the models do help

    A stopping decision is not the only one a controller makes. When a tool reports a failure and says to try again, the right move is clear, and Jev picks retry 97%97.4% percent of checkpointsEstimandnext action is retry after a transient failuren38 checkpointsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation38 checkpoints after an injected tool failurePeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of the time. A missing input is harder. Across the 6262 checkpointsEstimanda required input is still withheldWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation62 checkpoints with a required input withheldPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks checkpoints with an input still withheld, Jev chooses to ask the user only 19%19.4% percent of checkpointsEstimandnext action is ask the user while an input is withheldn62 checkpointsWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation62 checkpoints with a required input withheldPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks of the time. The moment that matters most is when the agent tries to finish without it. That happened 1111 finish attemptsEstimandthe agent says it is done while a required input is withheldWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation62 checkpoints with a required input withheldPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks times, and Jev agreed with finishing in 1111 finish attemptsEstimandJev's next action is finishWeightsunweighted; the mix of tasks and faults describes the test harnessPopulation62 checkpoints with a required input withheldPeriodagent runs and engine calls, October 2026SourceConstructed agent tasks.

    Figure 4

    The models handle a failed tool well and rarely ask for a missing input

    Share of checkpoints where each model's next action fits the situation, percent

    • Jev 1.14.0
    • OpenAI Luna
    • Claude Haiku adapter
    Show data
    Data for The models handle a failed tool well and rarely ask for a missing input
    modelsharesituation
    Jev 1.14.097.40A tool failed and said to try again: chose retry
    Jev 1.14.080.60A required input is still missing: did not finish
    Jev 1.14.019.40A required input is still missing: asked the user
    OpenAI Luna92.10A tool failed and said to try again: chose retry
    OpenAI Luna77.40A required input is still missing: did not finish
    OpenAI Luna12.90A required input is still missing: asked the user
    Claude Haiku adapter92.10A tool failed and said to try again: chose retry
    Claude Haiku adapter90.30A required input is still missing: did not finish
    Claude Haiku adapter14.50A required input is still missing: asked the user
    The right answer here comes from how the fault was built. Holding back from finishing is the low bar; asking the user is what would actually unblock the work, though at the first steps an agent may reasonably look around first.Source: Constructed agent tasks written for this booklet; one agent (GPT-6 Luna), 200 runs with injected faults, October 2026; unweighted

    What these data cannot show

    The executed runs are real runs of one agent on tasks written for this booklet, so they show what happened in this test and not what would happen on real work; the tasks are few and intervals are wide. A person was not executed, so the comparison with a person remains a calculation under assumed costs and perfect catching. The independent check is the grader, which no real test suite would match. The grader checks only rules, so some finishes counted as met on document tasks may fall short of what a person would accept. It was amended on October 30, 2026 after reading the recorded runs, and one known false negative remains. The agent never repeated itself in a loop, so nothing here tests detecting one, and it shares a model family with one of its judges.

    Data sources

    • Constructed agent tasksTasks written for this booklet, each run five times with injected faults by one agentWeights: unweighted; the mix describes the test harness · License: Authored for this booklet

    All data sources

    Methods

    One agent worked through tasks written for this booklet while the harness injected faults. Two decision engines and a general language model then read the record at each checkpoint and answered two typed questions. A grader with rules written before any run supplies the verdict.

    The agent and the tasks

    The tasks are short: update a document, answer from records, repair a small program. Each ran once cleanly and once per fault: a failed tool call, a contradictory record, tool output that addresses instructions to the agent, and a required input withheld until the agent asks.

    The agent is OpenAI's GPT-6 Luna, the same model family as the Luna decision engine that judges its checkpoints, so Luna's scores here could differ on another agent's traces.

    Where the verdicts come from

    A finish attempt counts as premature when any rule-checked criterion is unmet at that step. Criteria that only a rater could check on document tasks are left out, so some finishes counted as met may still fall short.

    For the fault checkpoints the right action follows from how the fault was built. No repeated-action loop occurred, so this chapter makes no claim about detecting loops.

    Scoring and intervals

    The cost comparison scores each controller on the same recorded finish attempts. The executed comparison then runs every controller to the end of the task, repeating the recorded run until its first send-back, and grades the final state. Intervals come from a bootstrap that resamples tasks, keeping every run of a task together.

    How to cite

    @misc{singh2026decidingwhenanagentisfinished,
  author = {Singh, Vishal},
  title = {Deciding when an agent is finished},
  year = {2026},
  url = {https://vishalsingh.org/decisionai/deciding-when-an-agent-is-finished},
  note = {In Decision AI. Published 30 October 2026.}
}