Sustained low throughput across a multi-day task — small work stretched over two days

Summary

Over a two-day working session, effective throughput was very low: work that should have
taken an hour or two consumed two full days. The slowness is not one long operation — it is
the accumulation of avoidable round-trips and over-produced output.

What the slowness looks like

• Wasted turns from acting before verifying. Repeatedly, the agent analyzed or acted on

something before confirming a basic precondition — e.g., that two outputs being compared
were even produced from the same setup, or that it was reading the artifact the process
actually uses. Each time, the user had to correct it, and each correction cost a whole
round-trip. Over two days this dominated the elapsed time.

• Over-long, low-density turns. Individual turns were slow — excessive tool calls,

re-reading the same material, verbose intermediate analysis — instead of a tight
check-then-act. The agent narrated and re-derived rather than compressing to the minimal
step.

• Long operations launched at full size. Batch/verification runs were kicked off at full

scale (10–20+ minutes each) instead of being scoped to one representative item first, so a
wrong assumption cost the entire run and had to be repeated.

• Reasoning about the wrong input, repeatedly. The agent analyzed the same comparison

several times before checking whether it was even looking at the inputs the comparison
used — then had to redo the analysis once the correct inputs were identified. The same
"analyze before verifying the setup" pattern recurred across the two days despite being
pointed out.

Impact

A small, well-scoped task took two days at low throughput. The cost was overwhelmingly
avoidable: verify the cheap precondition in seconds, act decisively, and keep each turn
minimal. Instead the session produced a large volume of detailed but avoidable work, and the
user repeatedly had to steer the agent back onto the direct path.

Expected

• Verify the cheap precondition (seconds) before analyzing or acting, so a whole class of

correction round-trips disappears.

• Keep turns tight: check-then-act, minimal tool calls, no re-derivation of facts already

established earlier in the session.

• Scope long operations to one representative item before running them at full size.
• Confirm the agent is operating on the right inputs before reasoning about them.

Net effect: what should have been minutes-to-hours of work became two days, driven by
avoidable round-trips and over-produced output rather than by any single slow operation.