Office Hours — How long does it actually take to wait for AI agents to complete complex tasks, and what's the productivity trade-off?

How long does it actually take to wait for AI agents to complete complex tasks, and what’s the productivity trade-off?

The honest answer depends on what “complex” means to your workflow. A coding agent might spend 2-5 minutes on a straightforward refactor, or 45+ minutes reasoning through architectural changes with test failures. A research agent could burn through 3-4 hours synthesizing documents across heterogeneous sources and still hallucinate citations. The wait itself isn’t the bottleneck. The real cost is invisible context switching and what you lose while waiting.

Real Wait Times in Production

Autonomous coding agents like Claude Code with Opus 5.5 or Cursor Agent typically run 30 seconds to 3 minutes for simple tasks (fixing linter errors, adding tests), but 10-20 minutes for multi-step work involving repo cloning, test iteration, and PR generation. Gemini 3.5 Flash tends to be 2-4x faster on the same tasks but sometimes sacrifices reasoning depth. The variance matters more than the median. When an agent is stuck in a loop retrying failed tests, you’re watching real minutes tick away.

For longer-horizon tasks, the picture gets worse. Qwen3.7-Max demonstrated 35 hours of autonomous operation on a chip optimization problem, but that’s a first-party claim from Alibaba and hasn’t been independently reproduced. More typical production agents plateau around 2-4 hours before context saturation or tool failure cascades force human intervention. Browser agents frequently fail silently or generate false positives on valid interactions, which means you can’t just fire and forget. You end up spot-checking work anyway.

The Hidden Cost: Context Switching

The wait time itself is deceptive because it creates a coordination problem. While your agent grinds through 15 minutes of work, you’re not idle. You switch to Slack, email, or a different task. When the agent finishes, you’ve mentally context-switched out and need 5-10 minutes to load the result back into working memory. That’s a hidden tax on every agentic task.

Industry data from Databricks and OpenAI shows developers get more absolute throughput from agentic systems than from manual coding. But the quality of work shifts. Agents are eloquent at obvious stuff and confidently wrong on judgment calls. So you spend less time implementing features and more time validating results. The math works out to win in favor of agents for large codebases, but only if you account for review overhead.

Token Economics and Real Costs

A 15-minute agent run burning 500K tokens at current frontier pricing (Claude Opus 5.5 at $4/$20 per M) costs roughly $2 in input and $10 in output, plus caching overhead. If your agent runs 20 times per sprint, that’s $240. If it fails twice and needs a retry, you’ve just paid $480. Compare that to a senior engineer spending 30 minutes on the same task at fully loaded cost (~$75-$100). The math depends on task reliability. Cached requests are cheaper ($0.20 for Opus 5.5 input cache reads), so repeated queries against the same codebase drop to ~$1 per run once warmed up.

The deeper issue: frontier models slow down as their request queues fill during peak hours. OpenAI’s GPT-6 Astra with Fast mode gives 2x speed for 2x price. Claude with its current rate limits shows 5-15 minute queue waits during peak hours (3-7 PM Pacific). That’s real latency you can’t optimize away.

When Waiting Actually Works

Agents excel when the task is verifiable (test pass/fail, linter, CI) and you don’t need the result immediately. Overnight optimization runs, async batch processing of documents, background refactoring on branches you’re not actively touching—those are wins. Autonomous coding agents rebuilt SQLite in Rust with 100% test coverage using Cursor’s architecture (frontier models for planning, cheaper models for execution), which validates that decoupled pipelines reduce wall-clock time.

But wait if you’re expecting real-time productivity gains on interactive tasks. The Remote Labor Index from the Center for AI Safety shows even top agents complete only ~16% of real freelance jobs at professional quality. That ceiling is meaningful. You’re trading wall-clock time for uncertain outcomes.

The Productivity Trade-off in Numbers

OpenAI’s latest research on 165 work activities globally shows AI is most impactful on repetitive, rule-based tasks with clear success criteria. For creative or judgment-heavy work (architecture review, security decisions, design choices), agents become a time sink. You wait for their output, find issues, iterate. A human might be slower but also less likely to need rework.

One concrete pattern: GitHub Copilot (multi-model, including GPT-5.6 Sol and Claude Sonnet 5) shows productivity gains of 35-55% on coding speed when measured by characters/tokens generated per hour. But researchers at UT Austin found junior lawyers using AI improved short-term performance by 40% on patent tasks yet showed zero skill retention after the tool was removed. You’re paying upfront latency cost for outputs that don’t build durable capability.

What Actually Hurts

The real productivity killer is silent failure. Browser agents can look successful while actually breaking—dashboards stay green but the agent hallucinated its way through a workflow. If your agent runs unattended, you don’t know it failed until the next day’s standup. Sync points matter. Every check-in or validation step adds 5-15 minutes of latency.

Container-based sandboxing, persistent logging, and explicit fault detection (not just exit codes) add friction but prevent invisible waste. Anthropic’s recent architecture patterns show single well-reasoned agents now outperform multi-agent setups that were popular 6 months ago. Consolidation reduces context switching between agents, which actually speeds up wall-clock time despite using one larger model.

Practical Baseline

If you’re not waiting more than 5-10 minutes per task on average, the agent is probably too constrained to be useful. If you’re regularly waiting 30+ minutes, you’re either working on genuinely hard problems (where waiting is fine) or the agent is thrashing (where you should redesign the task boundary).

Cost-sensitive teams are standardizing on Claude Sonnet 5.5 ($2/$10, cache $0.10) for most agent work because Opus-class models ($4+/$20+) rarely justify 2x cost for 15-20% capability lift on agentic tasks. For latency, Gemini 3.5 Flash remains fastest on coding and browser tasks, though reasoning depth sometimes suffers.

Bottom line: AI agents don’t save wall-clock time on interactive tasks—they save human effort on verifiable work. Accept 10-30 minutes of wait per task and validate outputs, or you’ll end up reviewing code three times. Cost per task is $1-$15 depending on model and cache hits. The productivity win is real but asymmetric: agents win on breadth and speed, humans win on judgment.

Question via Hacker News