---
type: Article
title: "Estimating agent work in agent time"
description: "A personal process for translating an agent-provided human-hour estimate into agent labor and wall-clock time using empirical calibration from completed traces."
resource: "https://localgradient.dev/posts/estimating-agent-work-in-agent-time"
tags: ["coding-agents", "estimation", "measurement", "field-notes"]
status: stable
generated: { by: human:local-gradient, at: "2026-07-25T16:00:00-04:00" }
sources:
  - id: agent-effort-estimation-skill
    resource: "../resources/agent-effort-estimation/index.md"
    title: "Agent Effort Estimation skill"
    author: human:local-gradient
  - id: look-back-effort-accounting-skill
    resource: "../resources/look-back-effort-accounting/index.md"
    title: "Look Back Effort Accounting skill"
    author: human:local-gradient
  - id: todd-cost-estimate
    resource: "https://x.com/toddsaunders/status/2029594318361571497"
    title: "Todd Saunders /cost-estimate post"
    author: human:toddsaunders
---

# 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.
2. 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`.
3. 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](https://localgradient.dev/downloads/agent-effort-estimation-skill.md)
- [Look-back effort-accounting skill](https://localgradient.dev/downloads/look-back-effort-accounting-skill.md)

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:

| Tier | Work | Lines/hour |
|---|---|---:|
| T1 | Trivial | 60 |
| T2 | Routine | 35 |
| T3 | Medium | 22 |
| T4 | High | 14 |
| T5 | Specialist | 10 |
| Cleanup | Deletion-only credit | 120 |

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.

| Measurement | Result |
|---|---:|
| Agent estimate | 75–130 human hours |
| Estimate from forward-estimation skill | about 64 human-equivalent hours; about 1.5 total agent-labor hours |
| Estimate from look-back skill | 59.7 human-equivalent hours |
| Wall-clock time | about seven minutes with the Grok 4.5 harness |

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](../resources/agent-effort-estimation/index.md)
- [Look Back Effort Accounting](../resources/look-back-effort-accounting/index.md)