Independent AI intelligence Two editions daily · ET
Fervor AI
Menu

Analysis · October 18, 2026 · concept

Anthropicclaude-codeagent-harnessmulti-agentagent-infrastructure

Anthropic's AI Agents Wait on Humans 80% of the Time. Here's How to Measure Yours.

The company that builds Claude looked at its own logs. The slow part of the loop is the person at the keyboard, and here's how to measure yours.

Every agent demo shows the agent working. Files fly open, tests turn green, a pull request appears.

No demo shows the part where the agent finishes a step, asks a question, and sits there. Waiting for someone to say yes. Waiting for someone to read the plan. Waiting for someone to come back from a meeting.

That part turns out to be most of the session. In a report published on October 16, Anthropic looked at how its own employees use Claude and found that interactive Claude sessions "amount to around 80% idly waiting for human input."

Read that again with your own setup in mind. If the agent spends four minutes of every five waiting on you, a model that thinks twice as fast saves you very little. Cutting your own turnaround saves a lot. The bottleneck in agent work has moved from the machine to the human, and most of us are still shopping for faster machines.

This piece walks through what Anthropic measured, why adding more agents tends to make the problem worse, and a small setup you can run this week to find out how long your agents wait on you.

What Anthropic actually measured

The report, "How employment is changing at Anthropic," comes from four researchers (Nathan Wilmers, Regina Catipon, Maxim Massenkoff and Peter McCrory) working from the company's own staffing records and Claude usage. Anthropic is an unusual test case. It builds the models its staff use, so its numbers read best as a preview, with the caveat that most companies look nothing like it.

A few numbers carry the story.

Agents now outwork the staff, in raw hours. By August, the report says, "interactive AI agent hours outnumbered employees' six to one." Six hours of agent time for every hour a person works, counting agent time as active thinking and tool use and estimating human time at 40 hours a week per employee.

Most of that agent time is idle. The 80% figure is the share of wall-clock time (real elapsed time, not compute time) in Anthropic's interactive Claude sessions spent waiting for a human to respond. An "interactive" session here means one where a person is in the loop, like a Claude Code session in your terminal, as opposed to a fully automated pipeline.

Output outruns reading. Anthropic estimates its interactive sessions put out enough text to "take up over half of the work week" just to read. Code commits per engineer rose to about 5x what they were six months earlier.

The work around the work is growing. "Meta-work" is the report's name for building things that help agents do their jobs: Claude skills, plans and reviews for other agents, dashboards for agent pipelines. It rose from 10% to 22% of the average employee's interactive sessions between fall 2025 and spring 2026. Written standing instructions for agents (the reusable guidance a team writes once so it doesn't have to repeat itself) grew from a few hundred in July 2025 to 8,500 a year later.

Hiring shifted. The junior share of technical hires fell from 27% to 9%, and in interview comments on technical candidates, mentions of autonomy and judgment rose the most.

There's also a quality result worth knowing. In a comparison of 192 engineers who adopted coding agents and 74 who didn't, output rose after adoption, and the researchers found no difference in how often agent-written code was later removed or reverted compared with human-written code. They're careful with it, and so should you be: "AI errors may be harder to identify than human ones."

The mental model: a fast machine with a slow inspector

Think of a dishwasher that runs a full cycle in ten minutes and then waits all night for someone to unload it. Buying a dishwasher that runs in five minutes changes nothing about when you get clean plates.

Agent work has the same shape. The agent runs a step, then stops at a checkpoint that needs a person:

  • a permission prompt ("can I run this command?")
  • a clarifying question ("which of these two APIs did you mean?")
  • a review (a plan, a diff, a summary that someone has to read before the next step)

Each checkpoint is a queue, and you are the only worker serving it. While you're in a meeting, reading Slack, or reviewing a different agent's work, the queue grows.

So the useful question changes. "How smart is my agent?" matters less than "how often does my agent need me, and how long does each need take to clear?"

That reframing explains the meta-work numbers too. When Anthropic employees spend more of their sessions writing skills, plans and standing instructions, they're answering future questions in advance. Every instruction an agent can read is a question it doesn't have to ask.

Why more agents can make it worse

The obvious response to an idle agent is to start another one. Tools like Orca, a free desktop app that runs several coding agents side by side in separate copies of your repo (git worktrees), make that easy, and they're popular for good reason.

But look at the math. If one agent waits on you 80% of the time, three agents don't triple your output. They triple the queue. You now have three agents asking for permission, three plans to read, three diffs to review, and the same one brain to do it with.

Linear's Karri Saarinen made a related point in an essay published October 15. When every person works with agents, each "operating a small software factory," changes that make sense on their own can add up to a product nobody actually designed. Parallel agents raise output. They don't raise the amount of attention available to decide what that output should be.

A separate benchmark preprint posted the same week, FDE-Gym, points at the other half of the problem. It tests agents on real customer delivery work, where the hard part is discovering requirements nobody wrote down. The best of 13 configurations fully solved only 14 of 95 tasks, and the authors name finding those unstated constraints as the main bottleneck. Some of what your agent waits on is information only you have. No amount of parallelism produces it.

None of this means parallel agents are a mistake. It means they pay off after you shrink the queue, not before.

Put this into practice: measure your own wait time

You don't need Anthropic's data team to get a rough version of the 80% number for yourself. If you use Claude Code (Anthropic's terminal coding agent), its hooks can log every moment the agent hands control back to you and every moment you hand it back.

Hooks are small commands Claude Code runs when certain events happen. Two events give you a stopwatch:

  • Stop fires "when Claude finishes responding." Waiting starts.
  • UserPromptSubmit fires "when a prompt is submitted." Waiting ends.

A third event, PermissionRequest, fires "when a tool call needs a permission decision," so you can count how often the wait is a permission question. Permission waits happen in the middle of a turn, so the stopwatch below doesn't time them; the count tells you how often they interrupt.

Each hook receives a small JSON object on standard input that includes the session_id and hook_event_name. That's all you need.

Step 1: add the hooks. Put this in ~/.claude/settings.json (all projects) or .claude/settings.local.json (one project, not shared). If the file already has a hooks block, merge these entries into it. It needs jq installed.

{
  "hooks": {
    "Stop": [
      { "hooks": [ { "type": "command",
        "command": "jq -c --arg t \"$(date +%s)\" '{t:($t|tonumber), e:.hook_event_name, s:.session_id}' >> ~/.claude/wait-log.jsonl" } ] }
    ],
    "UserPromptSubmit": [
      { "hooks": [ { "type": "command",
        "command": "jq -c --arg t \"$(date +%s)\" '{t:($t|tonumber), e:.hook_event_name, s:.session_id}' >> ~/.claude/wait-log.jsonl" } ] }
    ],
    "PermissionRequest": [
      { "hooks": [ { "type": "command",
        "command": "jq -c --arg t \"$(date +%s)\" '{t:($t|tonumber), e:\"permission\", s:.session_id}' >> ~/.claude/wait-log.jsonl" } ] }
    ]
  }
}

Step 2: work normally for a day or two. Don't change your habits yet. You want the honest baseline.

Step 3: add up the gaps. This short script pairs each Stop with the next UserPromptSubmit in the same session and reports the total.

import collections, json, os, statistics
waits, perms, last_stop = collections.defaultdict(list), collections.Counter(), {}
for line in open(os.path.expanduser("~/.claude/wait-log.jsonl")):
    r = json.loads(line)
    if r["e"] == "Stop":
        last_stop[r["s"]] = r["t"]
    elif r["e"] == "UserPromptSubmit" and r["s"] in last_stop:
        waits[r["s"]].append(r["t"] - last_stop.pop(r["s"]))
    elif r["e"] == "permission":
        perms[r["s"]] += 1
all_waits = [w for ws in waits.values() for w in ws]
print(f"{len(all_waits)} hand-backs, {sum(all_waits)/60:.0f} min waiting, "
      f"median {statistics.median(all_waits) if all_waits else 0:.0f}s, "
      f"{sum(perms.values())} permission prompts")

What you'll see is a count of hand-backs, total minutes the agent sat waiting, the median wait, and how many permission requests came up. Treat it as a rough proxy, not a stopwatch accurate to the second. The output is one line, something like 37 hand-backs, 96 min waiting, median 41s, 22 permission prompts (illustrative numbers, not real data). If permission prompts come close to your hand-back count, start with the allow list below; if the median wait is long but prompts are rare, your agent is mostly waiting on answers or reviews. The median matters more than the total. A total inflated by one long lunch tells you nothing; a median of four minutes tells you that every small question costs you four minutes.

Two caveats so you read the numbers fairly. The Claude Code docs note that UserPromptSubmit also fires on turns Claude Code starts on its own (scheduled tasks and background reports, for example), so some "waits" end without you typing anything. And the clock can't tell an agent waiting on you from an agent that simply finished. A session that ends is not a session that's stuck. Use the numbers to find patterns, not to grade yourself.

Then shrink the queue

Once you know where the time goes, the fixes are mostly boring, which is good news.

If permission prompts dominate, pre-approve what you always approve. If you've said yes to npm test forty times, that question is pure delay. Claude Code has permission modes and allow rules for exactly this; move the commands you never refuse into an allow list and keep prompts for the ones that can do damage.

If clarifying questions dominate, write the answer down once. This is the meta-work Anthropic's employees are doing. A project instruction file such as CLAUDE.md that names the test command, the code style, the APIs to avoid and the definition of "done" turns a recurring question into a line the agent reads at startup. The 8,500 standing instructions inside Anthropic are this habit at company scale.

If reviews dominate, change what you review. Ask the agent to end each chunk of work with a short summary: what changed, what it's unsure about, what it needs from you. Reading five lines is faster than reading a 400-line diff to find the one question buried inside it. Batch those reviews into two or three fixed windows a day instead of reacting to every ping.

Only then add agents. When your median wait drops and your permission count falls, a second or third agent starts paying for itself instead of stacking up behind you.

Honest limitations

This is one company measuring itself. Anthropic builds the models and has every incentive to adopt early, so its numbers are a preview, not a forecast. The authors say so plainly: they caution that "many parts" of Anthropic's employment practices "cannot be replicated across the economy."

Most of the figures are descriptive. The researchers note that engineers who adopted agents "were already on a steeply upward trajectory" before adopting, so not all of the output rise belongs to the agents. Some of their measures (session difficulty, meta-work, hiring comments) were scored by automated Claude-based graders, and the reading-time estimate rests on stated assumptions about words per token and reading speed.

The 80% figure also isn't a measure of wasted human time. While an agent waits, the person might be doing other useful work, including running a different agent. It measures how much of the agent's clock sits idle, which is exactly why it's a pointer to your process and not a verdict on your productivity.

And the hiring number cuts the other way from the speedup story. If agents absorb the routine work juniors used to learn on, the judgment everyone now prizes in reviewers gets harder to grow. Shrinking your review queue is good. Shrinking it by reviewing less carefully is how agent errors that are "harder to identify than human ones" reach production.

What you can do this week

Install the three hooks. Work for two days without changing anything. Run the script.

If your agents rarely wait on you, great: you're the exception, and a faster model or a second agent may be the right next purchase. If they wait most of the time, like Anthropic's do, you've found the cheapest upgrade available, and it doesn't come with a subscription. It's the list of questions you keep answering, written down once.

Sources: Anthropic, "How employment is changing at Anthropic" (October 16, 2026); Claude Code hooks reference; FDE-Gym, arXiv 2610.22350 (submitted October 15, 2026); Karri Saarinen, "Someone behind the software" (October 15, 2026); stablyai/orca.