Estimating agent work in agent time

Coding agents often answer estimation questions in familiar human-team terms:

“roughly 75 to 130 hours.” That estimate already contains useful decomposition

and judgment. I do not want to throw it away. I want to change its units.

My forward skill takes the agent’s own human-hour estimate as its starting

point, converts it into agent labor with coefficients derived from completed

session traces, then accounts for dependencies and parallel work to estimate

attended wall-clock. The look-back is supporting calibration: it helps the

conversion improve after each run.

This is one person’s small, changing dataset—not formal research or a universal

benchmark.

Keep the estimate. Change the units.

The process is:

1. Ask the agent for its conventional human-hour estimate, including the task

breakdown, range, assumptions and dependencies.

1. Convert the human-hour estimate to agent labor using empirical calibration

from prior traces. My current global conversion is

agent_labor_h ≈ agent_estimated_human_h / 43.3.

1. Apply the dependency graph, real parallelism and serial integration gates to

estimate attended wall-clock.

The outputs remain separate:

• Human-equivalent effort: a rough implementation-size estimate for an

experienced person working alone.

• Agent labor: the sum of all worker durations.
• Attended wall-clock: elapsed time from dispatch to verified completion.

Four agents working for 15 minutes represent about one hour of agent labor, but

perhaps only 15 minutes of wall-clock before serial integration and

verification.

Take the skills—and the coefficients

Todd shared the seed in public, so I want to do the same with my fork. These are

the complete, portable Markdown skills I currently use—not abbreviated prompts

or screenshots.

• Forward agent-effort estimation skill
• Look-back effort-accounting skill

The forward skill starts with the agent’s own human-hour estimate, preserves its

task breakdown and dependencies, cross-checks the estimate against likely files

and complexity, converts it to agent labor, and models parallel work as a

critical path. The look-back skill examines the completed git range, excludes

generated material, classifies insertions, keeps deletion-only cleanup separate,

and records observed wall-clock and agent labor.

Each file includes the real trace-derived conversion, file-tier rates, formulas,

guardrails and output templates. Save either Markdown file as SKILL.md

wherever your agent loads skills. The coefficients are a usable starting point,

but they should be replaced as your own actuals accumulate.

Current personal human-equivalent rates:

The current trace-derived conversion applied to the agent’s human-hour estimate

is 43.3 human-equivalent hours per attended agent hour, based on 243

anonymized work-item rows over four weeks. It is not “the speed of agents.” The

resulting estimate will probably be different for everyone because workflows,

project types, models, tools, verification gates and attendance assumptions all

change the calibration. Zero work-type medians are treated as missing data, not

instant work.

In a future post, I plan to share the trace-harvesting repository behind this

experiment so you can collect the same kind of evidence from your own sessions

and derive coefficients for your own work.

From 64 hours to 1.5 was the useful result.

The human-equivalent work estimate held up: about 64 hours going in versus 59.7

in the look-back.

Neither the original agent estimate nor my conversion assumed parallel

execution. The 1.5-hour result is total agent labor, not a parallel wall-clock

forecast.

The observed run used Grok 4.5. In my measurements, its prefill and decode

speeds were at least 50% faster than the Codex and Claude API routes behind my

coefficient, and the harness also ran work in parallel. Those unmodeled

advantages help explain the seven-minute wall-clock. This is an observation

about my workflow, not a universal model comparison.

I don't need to model every variable. The conversion already tells me what

matters: work the agent sized at 64 human hours is about an hour and a half of

actual agent work — precise enough to kick it off and go walk my dog.

Credit

This work was seeded by Todd Saunders’s public /cost-estimate prompt: lines of

code plus complexity translated into senior-developer hours. I used it publicly

on March 5, 2026 with both hours and dollar return-on-investment framing.

• Todd’s original post: https://x.com/toddsaunders/status/2029594318361571497
• Todd Saunders: https://x.com/toddsaunders
• Julien Barbier’s later parallel expansion:

https://github.com/jbarbier/claude-code-cost-estimate

My current fork retires the dollar layer, keeps hours-only look-back accounting,

separates agent labor from attended wall-clock, and calibrates a forward

forecast against my own session ledger. Julien later built a parallel expansion

of Todd’s idea; it was not the direct source of my fork.

Related research:

• https://metr.org/time-horizons/
• https://dora.dev/research/2025/dora-report/

Skills

Portable skills shipped with this field note (OKF skill bundles):

• Agent Effort Estimation
• Look Back Effort Accounting