METR's 2026 Task-Completion Time Horizons: How Long Can Frontier Agents Work Unsupervised?

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Introduction

If you want to know how much autonomy a frontier model is actually capable of, there is one measurement worth watching: METR's task-completion time horizons. METR — the research group best known for modeling AI risk — runs standardized tasks and measures how long each model can keep making progress without human help before it fails or needs intervention. The number is deceptively simple and genuinely informative: it is the best public estimate of how long an agent built on that model could run unattended.

The 2026 measurements show the most capable public models working on tasks for multiple hours before needing help — up from minutes in earlier generations. That trend is the quiet story under every agentic deployment this year: the models got autonomous, and the oversight controls have to catch up. This blog explains the metric, the trend, and the three engineering consequences for anyone shipping production agents: autonomy budgets, interruption controls, and containment. It pairs with the agent workflow safety blueprints in our library and the AI news coverage of agent-incident reports.

What the time-horizon metric actually measures

METR's benchmark works like a real task queue: the model gets a goal (set up an environment, fix a bug, run a research pipeline), and it works until it succeeds, fails, or stalls. Time horizon is measured across a distribution of tasks, and the headline number is how long a model can work on the harder end of that distribution before needing intervention. It is not a measure of raw IQ; it is a measure of reliable autonomous execution — the thing production agents actually need.

The honest framing matters: a model's time horizon is bounded by its weakest link. Tool-calling errors, stuck loops, context degradation, and failure to recognize when it is off-track all end a run early. Which means improvements in tool-calling reliability and self-correction show up directly in the time-horizon numbers — and they have been improving steadily.

The trend: minutes to hours

The 2026 shift from tens of minutes to multiple hours is the jump that matters for deployment. An agent with a 30-minute time horizon needs constant supervision — it is effectively an assisted tool. An agent with a multi-hour time horizon can run a meaningful work session while the human does something else, which is exactly the autonomy that changes the risk profile of a deployment.

Consequence 1 — Autonomy budgets

If a model can run for hours, the architecture must decide how much autonomy it gets. This is the concept of an autonomy budget: a per-task, per-agent cap on unsupervised steps, tool calls, cost, or wall-clock time before a checkpoint requires human review. The engineering reality is the same pattern we build into every production agent workflow:

AUTONOMY_BUDGET = {
    "max_steps": 25,          # hard cap on unsupervised steps
    "max_cost_usd": 8.0,      # stop the loop when spend exceeds budget
    "max_wall_time_min": 45,  # checkpoint for human review
    "human_gates": ["payment", "delete", "external_commit"],  # always gated
}

The capability is not the deployment: the deployment is the capability times the controls. A multi-hour-capable model running under a 45-minute autonomy budget is a supervised worker, and supervised workers are what most production tasks need.

Consequence 2 — Interruption controls

METR's time horizons assume the model works until it needs help — which means the system must be able to notice when the model is off-track and stop it. The oversight controls that matter are not more prompts; they are engineering controls:

1. Progress gates — if the agent has not produced a verifiable artifact (a test passing, a diff applied) within N steps, halt.
2. Cost and time circuit breakers — hard stops on spend and wall-clock time, independent of model judgment.
3. Human interrupt — the ability to pause the agent mid-loop, inspect state, and resume or abort. In LangGraph terms, this is interrupt_before on sensitive nodes, wired to real human review.
4. Escape detection — monitoring for behavior outside the intended action set (accessing files it should not, calling tools it was not given), the pattern we cover in agent containment.

An agent you cannot interrupt is not supervised, regardless of how many tokens you spend on instructions. The interrupt must be mechanical, not linguistic.

Consequence 3 — Containment

As time horizons grow, the blast radius of a failed unsupervised run grows with them. A 10-minute run can at worst do minutes of damage; a 4-hour run can change files, call APIs, and commit results before anyone looks. The containment stack that keeps pace with autonomy:

• Least-privilege tool access — the agent has exactly the credentials its task needs, nothing more (the MCP directory gateway patterns are the practical shape of this).
• Egress control — agent processes cannot exfiltrate data except through monitored, allowlisted paths.
• Immutable audit logs — every tool call, state transition, and artifact is recorded append-only, so a long unsupervised run is fully reconstructable. This is the same logging discipline the EU AI Act now requires of high-risk systems.
• Scoped identities — machine identities with per-task permissions and short lifetimes, so a compromised run cannot pivot through the whole estate.

What this means for your roadmap

The time-horizon trend is not a reason to avoid agents; it is a reason to size the controls honestly. The model's capability number tells you the worst case your oversight stack must handle — and the gap between capability and control is the risk you carry. For most production workloads the right move is not to run agents at the edge of their time horizon; it is to set autonomy budgets that treat multi-hour capability as the ceiling, not the default. That is how you get the productivity of autonomous agents without betting the estate on a run nobody watched.

Frequently Asked Questions

Q: What exactly does METR measure?

A: Standardized tasks with a clear goal, where a model works until it succeeds, fails, or stalls — the time-horizon number is how long the most capable public models can keep making progress without human help.

Q: Why do time horizons matter for production agents?

A: They are the best public estimate of how long an agent built on a model could run unattended — the worst case your oversight stack must handle.

Q: Does a multi-hour time horizon mean agents should run unattended?

A: No. Capability is the ceiling, not the default. Set autonomy budgets (steps, cost, wall-clock caps) and human gates so the deployment is a supervised worker regardless of model capability.

Q: How do I keep oversight proportional to autonomy?

A: Mechanical interruption controls — progress gates, circuit breakers, human interrupts — plus least-privilege tools, egress control, and immutable audit logs. More autonomy requires more control, not more instructions.