Sample · built from public data

What a pilot report looks like.

An optimization pilot ends with one document: where the workflow's money went, which fixes were worth testing, and what each fix and the combination did to cost and quality on the same tasks. This is that document, built from 60,000 public runs instead of a customer's, so you can see the format before you send anything.

Read this first. Nothing here is a customer result. The workflow is nvidia/Open-SWE-Traces v1.1: the same trace version run through three scaffolds, 20,000 runs each, which is the closest thing in public data to one team trying a change. Dollars are estimated from characters at Sonnet-class rates, the same basis as the Index, so read the percentages. A real pilot prices from your provider's usage report or your traces' recorded cost, and says which.

1. Baseline

Before any fix is proposed the report states what was measured, how much of the data it covered, and what it could not see. Everything later in the report is relative to this table.

WorkflowOpen-SWE v1.1 on SWE-agent (the scaffold the tasks were first run through)
WindowFirst 20,000 runs of the split, as served by the dataset in September 2026
Intake20,000 records parsed, 0 files not parsed, 0 duplicate attempt ids dropped
Tasks and attemptsOne attempt per task in this data, so task cost equals run cost. A customer's pilot counts every attempt at a task, restarts included, and reports how many tasks were restarted.
Outcomes17,764 of 20,000 runs carry a label (field: resolved); 2,236 are unknown and stay unknown. Success rate 53% over labelled runs.
Median run length76 steps
Cost basisEstimated, characters ÷ 4 at Sonnet-class rates, with and without cached-input pricing. Rate card version 2026-09-15.
Cost per successful task$11.88 on the estimated basis, every labelled run in the numerator

The Intake and Outcomes rows are the ones customers skip and should not. If 40% of your runs carry no outcome, the resolve figures below describe the other 60%, and the report says so rather than treating missing as failed.

2. Where the money went

Runs sorted by step count and cut into five equal buckets. Each row is that bucket's share of estimated spend, its success rate, and how many successful tasks a dollar bought.

BucketStepsShare of spendShare, cached basisSuccessSuccesses per $
1 (shortest)19–6311%13%67%0.172
263–7215%16%58%0.109
372–8118%19%53%0.083
481–9522%22%48%0.059
5 (longest)95–24533%30%40%0.032

The longest fifth of runs takes a third of the spend and returns a fifth as many successes per dollar as the shortest fifth. That is a concentration finding, not a saving: a cap still pays for every step up to the cap, and the tasks in the long bucket may be the hard ones. It tells you where to look, and it is why ticket 2 exists.

DetectorRuns affectedWhat it means here
Oversized tool output55%A single tool result over 20,000 characters, re-sent in the context of every later step
Blind retry2.3%The identical command re-issued immediately after it failed
Loop0.2%The same action three or more times with nothing changing in between
Ended without a result0.0%No submission, context limit reached, or cut off

Costed together, the three mechanical detectors account for 2% of this group's estimated spend. That number is small on purpose: the detectors price only the waste they can see, and the report never adds the categories together as if they were independent.

3. Tickets, ranked

Every finding that is worth a conversation becomes a ticket: the evidence, a proposed fix, who owns it, how it will be tested, and its status. Ranked by expected dollars, then by evidence, then by effort. Three is the ceiling for a pilot; a low-ranked ticket is still written down so the decision not to test it is on record.

Ticket 1 · oversized tool outputRank 1 of 3

55% of runs carry a single tool result over 20,000 characters, and the scaffold re-sends it on every later step.

Evidence
observed10,963 of 20,000 runs. Median run length 76 steps, so a result that lands early is paid for dozens of times. The same tasks on the bash-only scaffold: 0.1% of runs.
Proposed fix
Bound tool output at the scaffold: truncate results to a fixed size with a marker, and give the agent a way to page through the rest. A config change in SWE-agent and OpenHands; a small wrapper elsewhere.
Expected effect
modeledShorter context on every step after the first oversized result. The Index cannot put a customer dollar figure on this; assumption: the customer's provider bills input tokens per step, which is how every current API bills. The pilot measures it.
Owner
Platform engineer who owns the scaffold config
Test plan
Same task set, bound on and bound off, outcomes recorded per task. Quality gate: success rate within 2 points of baseline. Watch for runs that get longer because the agent pages through truncated output.
Status
proposedAwaiting the customer's go
Why rank 1: the largest number of runs affected, the strongest evidence level, and a fix that is a config change rather than a rewrite.
Ticket 2 · the long tailRank 2 of 3

The longest fifth of runs takes 33% of estimated spend and succeeds at 40%, against 67% for the shortest fifth.

Evidence
observedThe run-length table above. Successes per dollar fall in every bucket from shortest to longest, 0.172 to 0.032.
Proposed fix
Measure what the marginal step buys before changing anything. Instrument the point in each run where success becomes unlikely (the task type's resolve-by-length curve), then test an escalation rule on the executed prefix: hand the task to a person or a different configuration instead of continuing.
Expected effect
modeledUnknown until measured. Assumption to test: the long runs are long because they are stuck, not because the tasks are harder. If the long bucket is the hard tasks, an escalation rule trades success for cost and the report will say so.
Owner
Engineer who owns the agent loop, with the person who owns the task queue
Test plan
Simulate the rule on the baseline's own runs first (executed prefix priced, recovery priced), then run it live on a holdout. Success, quality and latency recorded before the test starts.
Status
proposedNeeds the customer's outcome labels per task type
Why rank 2: the most money sits here, but the fix is a policy, not a config change, and it can lower success. It is tested second because ticket 1 changes run length and the curve should be re-measured after it.
Ticket 3 · blind retriesRank 3 of 3 · not recommended for the pilot

2.3% of runs re-issue the identical command right after it failed.

Evidence
observed453 of 20,000 runs, usually one repeat per run. Loops are rarer still, at 0.2%.
Proposed fix
On an identical action after an error, return the error with an instruction to change the action. A few lines in the scaffold's observation handler.
Expected effect
modeledSmall: one step saved in one run in forty. Assumption: the repeated call costs about one median step.
Owner
Scaffold maintainer
Test plan
Not worth a pilot slot. Ship it as a hygiene change and confirm the rate drops at the next check.
Status
recommended outside the pilot
Why rank 3: the retry problem is largely solved on current models and scaffolds. Testing it in the pilot would spend a slot on a fix that cannot move the total.

4. Result: fixes against the baseline on the same tasks

Each fix is run on the tasks the baseline ran, alone and then all together. Cost counts every attempt. A fix that lowers the success rate by more than the agreed tolerance is rejected however much it saves. The combined configuration is the number the pilot claims; the individual fixes are shown so the overlap between them is visible, and they are never added up.

In this sample the only change that public data lets us measure is a scaffold swap, because Open-SWE v1.1 ran the same tasks through SWE-agent and through a bash-only scaffold. Treat it as a candidate fix named bash-only, tested against the SWE-agent baseline. This is the exact output format of compare.py; the numbers are group aggregates from the Index rather than a task-paired cohort, which the pilot version would be.

# metermaid comparison

Baseline against 1 arm(s) on the tasks present in every arm. Cost counts every
attempt at a task. Quality tolerance 2.0 points; minimum cohort 20 tasks.
Latency is not in trajectory records and is not reported.

## Result

**REJECTED** — bash-only cuts estimated cost by 60% and fails the quality gate.

| arm       | role      | success | Δ pp   | unknown | $/success | Δ cost | status   |
|-----------|-----------|--------:|-------:|--------:|----------:|-------:|----------|
| baseline  | baseline  | 53%     | —      | 2,236   | $11.88    | —      | —        |
| bash-only | candidate | 30%     | -23.7  | 2,292   | $8.61     | -60%   | rejected |

### bash-only: rejected

- success rate fell 23.7 points, beyond the 2.0-point tolerance
- cost per successful task fell from $11.88 to $8.61 on the estimated basis
- runs are shorter (median 51 steps against 76) and carry no oversized output

## Coverage

- bash-only: 20,000 runs, outcome labels on 17,708

This is what an honest negative looks like. The cheaper scaffold solves fewer tasks, so a team choosing on cost alone would be choosing a lower success rate. The report says so and the ticket closes as rejected. In a customer pilot the same table would carry ticket 1, ticket 2 and the combined arm, with a 90% interval on the cost change from a paired bootstrap.

5. What is not in this report