$ man agent-estimate
How to estimate AI agent work effort.
Stop guessing. Get a calibrated forecast for any AI-agent task in two seconds, on the command line — built from 250+ real dispatches (May 2026) across Claude, GPT, Gemini, and Codex.
// direct answer
To estimate AI-agent work effort, point agent-estimate at your task list. It sizes each task, runs three-point PERT with calibration modifiers, checks every task against the model's METR reliability limit, and outputs a wave plan with review and integration overhead included — in about two seconds.
$ pip install agent-estimate docs → THE PROBLEM
Why estimating AI-agent effort is different.
// short answer
AI agents work in seconds-to-minutes, not days. Anchoring to human-developer timelines — what most training data describes — systematically inflates every estimate, so you need an agent-native method.
Ask an agent how long something will take and it'll quote you a human's answer: "2–3 days" for work it'll actually finish in 30 minutes. Manual planning meetings have the opposite problem — slow, optimistic, blind to which model is reliable for the task.
The gap between "agents can do it" and "we know when it'll be done" is where projects break. agent-estimate closes it.
# same task, three estimators- agent (anchored to humans): "2–3 days"~ human planning meeting: "4 hours, maybe 6"+ agent-estimate (calibrated): "57.8 min · METR ok"# observed: 51 minutes
EXAMPLE
An AI-agent effort estimate, end to end.
// short answer
Here's what agent-estimate produces for a three-task sprint: sized tiers, three-point PERT with calibration, METR reliability check, multi-agent wave plan, review overhead, and human-equivalent ratio — one command, ~2 seconds.
$ agent-estimate estimate --file sprint.txt --review standard▸ parsed 3 tasks · sized · running PERT (calibrated, n=257)…┌─────────────────────────┬──────┬─────────────────┬──────────┬──────────┬───────┐│ task │ tier │ pert (o/m/p) │ expected │ human-eq │ metr │├─────────────────────────┼──────┼─────────────────┼──────────┼──────────┼───────┤│ Implement OAuth flow │ M │ 25 / 50 / 90m │ 57.8m │ 160m │ ok ││ Add login E2E tests │ S │ 12 / 23 / 40m │ 24.0m │ 75m │ ok ││ Wire session middleware │ L │ 45 / 95 / 180m │ 109.2m │ 300m │ warn │└─────────────────────────┴──────┴─────────────────┴──────────┴──────────┴───────┘# applied modifiersspec-clarity × 1.00 warm-context × 1.10 agent-fit × 1.00⚠ METR Wire session middleware (109.2m) exceeds Opus 4.7 p80 (90m).consider splitting into 2 tasks · agent-estimate split <task-id># wave plan (2 agents, parallelism=2)wave 1 T+0 → T+57.8m codex Implement OAuth flow + reviewT+0 → T+24.0m claude Add login E2E tests + reviewwave 2 T+57.8 → T+167m claude Wire session middleware + review# totalsagent wall-clock 167m sum of tasks 191m+ review (standard) +42m coordination +18m (10%)────────────────────────────────────────────────────estimated delivery ~227m (best 142m · worst 348m)human-equivalent 535m → 2.36× compression▸ report saved to .agent-estimate/2026-05-21.md · open with --view
PERT
3-point estimate per task, weighted (O + 4M + P) / 6.
METR
Auto-warns when a task exceeds model p80 reliability.
Waves
Wall-clock = slowest wave, not sum of tasks.
Human-eq
Compression ratio for stakeholder communication.
METHOD
The math, without making you do it.
// short answer
agent-estimate combines three established techniques — three-point PERT, METR-style reliability thresholds, and dependency-aware wave planning — and calibrates the result against measured agent dispatches.
PERT
Three-point estimates.
For each task, optimistic, most likely, and pessimistic. Weighted into a single expected value plus a confidence band.
METR
Model reliability limit.
Every model has a task length beyond which success rate drops sharply. Cross it and you get silent failures, not slow progress.
WAVES
Multi-agent planning.
Independent tasks run concurrently across agents. Wall-clock equals the slowest wave plus integration overhead.
wave 2 · claude
// accuracy: 61% of forecasts within ±30% out of the box; 85% with spec-clarity / warm-context / agent-fit modifiers applied. Measured across 250+ dispatches (May 2026).
DEFAULTS
Calibrated defaults, shipped in the box.
// short answer
Size tiers, METR thresholds, and human-equivalent multipliers — what agent-estimate uses out of the box. Override any of them in your agent config YAML.
| Tier | Example | Optimistic | Likely | Pessimistic |
|---|---|---|---|---|
| XS | typo, rename, one-liner | 5m | 10m | 20m |
| S | small patch, stub | 12m | 23m | 40m |
| M | standard feature | 25m | 50m | 90m |
| L | multi-file, complex | 45m | 95m | 180m |
| XL | rewrite, overhaul | 90m | 180m | 360m |
| Model | p80 |
|---|---|
| Opus 4.7 | 90m |
| GPT-5.5 | 90m |
| GPT-5.4 | 60m |
| Gemini 3.1 Pro | 45m |
| Sonnet 4.6 | 30m |
| Haiku 4.5 | 15m |
| Task type | Human takes |
|---|---|
| Boilerplate | 3–5× |
| Documentation | 3–6× |
| Tests | 2.5–4.5× |
| Feature | 2–4× |
| Frontend / app-dev | 2.5–3.5× |
| Refactor | 2–3.5× |
| Bug fix | 1.5–3× |
INTEGRATIONS
Run it where you already work.
// short answer
Three surfaces, same engine — pick the one that matches how you plan. CLI for sprint planning, Claude Code plugin for in-editor checks, GitHub Action for PR-time forecasts.
Pipe in tasks, get reports as JSON, Markdown, or stdout.
pip install agent-estimate Slash command /estimate inside any Claude session.
/plugin marketplace add kiloloop/agent-estimate Runs in CI — estimates land as PR comments, or issue comments on a label.
uses: kiloloop/agent-estimate@v0 // label → estimate comment
The Action is on the GitHub Marketplace. The smallest useful consumer: label an issue estimate and the report lands on it as a comment — no checkout, one step.
name: Auto-estimate
on:
issues:
types: [labeled]
permissions:
issues: write
jobs:
estimate:
if: github.event.label.name == 'estimate'
runs-on: ubuntu-latest
steps:
- uses: kiloloop/agent-estimate@v0
with:
issues: ${{ github.event.issue.number }}
output-mode: issue-comment ALTERNATIVES
Why not estimate AI-agent effort by hand?
// short answer
You can — but a planning meeting takes 30–60 minutes per sprint, lands at ±50–100% accuracy, and stays blind to model-specific reliability. agent-estimate takes ~2 seconds and lands at 85% within ±30%.
→ full side-by-side: agent-estimate vs manual vs no estimation
INSTALL
One command. No account.
// short answer
Apache 2.0, Python ≥ 3.10. Reports save to .agent-estimate/ by default.
FAQ
Frequently asked questions.
// short answer
Six questions we hear most often about estimating AI-agent work.
?How do you estimate how long an AI agent will take to build a feature?
›Run agent-estimate on the spec: it sizes each task into a tier, applies a three-point PERT estimate with spec-clarity / context / agent-fit modifiers, then adds review overhead. A standard feature (M tier) runs ~25–90 minutes of agent time before review.
?Why do AI coding agents overestimate task duration?
›They anchor to human developer timelines learned from training data, so they pad a 30-minute task to "2–3 days." Estimating in agent-native units calibrated to real dispatch data removes the bias.
?Should I estimate AI-agent work in hours or tool-call rounds?
›Rounds are a useful in-agent reasoning unit; for team planning and CI budgets, convert to calibrated wall-clock time anchored to real dispatch data. agent-estimate does both — it reports rounds and wall-clock minutes side by side.
?How accurate is AI-agent effort estimation?
›With agent-estimate, ~61% of forecasts land within ±30% of actual out of the box, rising to ~85% with spec / context / agent-fit modifiers applied — measured across 250+ real agent dispatches (May 2026 corpus).
?What is METR and why does it matter for estimation?
›METR-style p80 thresholds capture the task length beyond which a model’s success rate drops sharply (e.g., ~90 min for Opus 4.7, ~30 min for Sonnet 4.6). agent-estimate flags any task whose estimate exceeds the threshold so you can split it before the agent silently fails.
?How do I estimate work across multiple parallel agents?
›agent-estimate groups independent tasks into waves that run concurrently across an agent fleet, then reports total wall-clock as the slowest wave plus integration overhead — not the sum of all tasks.