All posts

Design Agent Work Around Human Attention

Anthropic's workforce report finds interactive agent sessions idle 80% of the time, waiting for people. How to treat human attention as the constraint.

Misha Druzhinin
Diagram: five agent sessions route their requests through standing instructions, a triage queue, and risk-based review before reaching one person.

Anthropic’s agents now work far more hours than the people running them. They also spend most of that time waiting for those people. On October 16, 2026, Anthropic published How employment is changing at Anthropic, a study of its own workforce. By August, agents deployed by individual employees ran about six times as many hours as their human handlers. Interactive sessions sat idle about 80% of the time, waiting for human input. We found it through the AI Collective’s summary of the report.

Our read: the constraint has moved. Most teams still tune agent throughput, model choice, and token cost. The scarce resource in Anthropic’s data is a person’s attention. If you add agents without designing for that, you get longer queues, more meetings, and engineers who feel busy but decide less.

Key Takeaways

  • Anthropic measured interactive agent sessions idle about 80% of the time, waiting for a person.
  • “Meta-work” such as building skills, reviewing agent output, and monitoring pipelines rose from about 10% to 22% of sessions.
  • Commits per engineer rose about fivefold. Same-person comparisons found no difference in later deletions or reverts, with caveats Anthropic states itself.
  • Treat attention as a budget: measure time agents spend blocked on people, then cut it with standing instructions, triage, and risk-based review.
  • Junior hiring fell sharply. If agents now do the work that trained newcomers, you need a deliberate way to build judgment.

What Anthropic measured

The report combines HR records, agent telemetry, output metrics, surveys, Slack and calendar data, and 17 interviews. Some figures are direct measurements. Others come from surveys or LLM-based classification. That difference matters when you decide how much weight to give each one.

Finding Value How it was measured
Agent hours vs. human hours Agents passed human hours in March 2026; by August, agents deployed by individual employees ran about 6x their handlers’ hours Session telemetry; 40 h/week per human; agent runtime excludes waits over 30 min; subagents pooled
Idle time in interactive sessions About 80% of wall-clock time waiting for human input Session time minus active agent time
Commits per engineer About 5x the level six months earlier Code records; adopters vs. non-adopters
Meta-work share of sessions About 10% (fall 2025) to 22% (spring 2026) LLM classification of sessions
Meeting time, median employee About 20% more than a year earlier Calendar data
Standing instructions for agents A few hundred (July 2025) to about 8,500 a year later Internal records
Junior share of technical hires About 27% to 9%, early 2025 to 2026 HR records

Anthropic is careful about limits. It’s a single frontier AI company with unusually heavy adoption. Tool adoption wasn’t random, and rapid revenue growth confounds the output numbers. The authors caution that most of its employment practices aren’t replicable across the economy. We agree. The direction of the findings is still the useful part.

Why human attention became the constraint

The 80% idle figure is the core finding. An interactive agent that waits four minutes out of five isn’t limited by its model or its tools. It’s limited by how quickly someone answers its questions, approves its plans, and reviews its output. One engineer in the report describes “an army of Claudes, with every one asking for my attention.”

The other numbers point the same way. Meta-work, the work of managing agents rather than doing tasks, more than doubled as a share of sessions. Meeting time rose too, though growth and role mix explain part of that. In an April 2026 survey, 20% of employees described their role shifting from doing work to managing agents.

For non-technical staff, Anthropic estimates that reading all interactive Claude output would take more than half a work week. That’s a token-to-words estimate, not a measurement. It still shows the scale of the problem. Output now arrives faster than a person can read it.

This matches what we wrote about the engineer’s job becoming saying no. When agents write the code, a person’s value shifts to judgment: what to build, what to reject, and what to trust. Judgment needs attention, and attention doesn’t scale with agent count.

More output isn’t the same as more value

Commits per engineer rose about fivefold in six months, the fastest-rising output metric in the report. Anthropic’s quality check is more interesting than the headline. It compared agent-written and human-written code from the same person, in the same month and directory. It found no difference in the share of lines later deleted or reverted.

That’s a reasonable proxy, and Anthropic names its own caveats. More code isn’t necessarily better code or more business impact. AI errors may be harder to detect than human ones. Adopters were already on steeper output curves before they adopted.

Our take for leaders: don’t adopt commits per engineer as your agent success metric. It rewards exactly what floods your reviewers. Track outcomes you’d track anyway, such as lead time for changes, revert rate, and incidents. Then add one metric most teams don’t have: how long agents wait on people.

Treat attention as a budget

If attention is the constraint, design agent work the way you’d design around any bottleneck. Measure it, route work away from it, and spend it only where it buys safety or direction. These five practices follow from the report. Some appear in it directly; the rest are our recommendations.

1. Measure blocked time, not agent count

Anthropic could see the 80% because it computed idle time from session telemetry. Many teams can’t see it at all. Start by logging each time an agent stops for a person, and how long until it resumes. Tag each stop by type: approval, clarification, or review.

A shared spreadsheet is enough to start. This is the shape we’d use:

Time Agent and task Stop type Wait (minutes) Resolution
10:42 Migration agent, billing service Clarification 25 Answered: keep the old column until backfill finishes
11:15 Test-fix agent, checkout Approval 40 Approved plan; rule added to repo instructions
13:05 Refactor agent, search API Review 90 Sent back: missing rollback note

These rows are illustrative, not measurements. The log tells you where attention goes. Look for repeated question types, because those are the cheapest stops to remove first.

2. Turn repeated questions into standing instructions

Anthropic’s standing written instructions for agents grew from a few hundred to about 8,500 in a year. Each one is a decision a person made once instead of every session. When an agent asks the same clarifying question twice, the answer belongs in a skill, a CLAUDE.md-style file, or a lint rule.

We made the same argument in building agent context from what shipped. Context written once, and kept current, is cheaper than answers typed into a chat window again and again.

3. Put decisions where agents can read them

The report found agents in nearly half of Anthropic’s active public Slack channels. It also notes pressure to move decisions into agent-visible channels. A decision made in a hallway or a private DM leaves agents without context. They then come back and ask, which costs attention again.

For engineering teams, that means writing decisions where agents already look. Use the ticket, the spec, the PR description, or a decisions log in the repo.

4. Triage agent requests before they reach a person

One Anthropic engineer built an agent “chief of staff” to triage requests from other agents. The report gives no detail on how it works, so don’t treat it as a proven design. The idea is still sound. Many agents sending equally urgent pings to one person is an interrupt storm.

A simpler version works without another agent. Route all agent requests into one queue instead of many terminals. Sort by what’s blocking the most work. Let the person batch approvals at set times instead of reacting to each ping.

5. Spend review attention by risk

Review is where agent volume hits people hardest. We covered how Anthropic’s Claude Code team tiers review by risk: some changes need zero human approvers, others need two. Warp published a similar idea this week. Ben Holmes described a merge-risk skill, published in Warp’s common-skills repository. It grades a PR on alignment, impact, verification, rollback cost, and error detection. Warp’s Zach Lloyd framed code review as risk mitigation.

Warp sells developer tools, so read the pitch with that in mind. The categories are useful regardless. Rollback cost and error detection are exactly what tell you whether a person needs to look closely.

The junior pipeline is an attention problem too

Anthropic’s junior share of technical hires fell from about 27% to 9%. The junior share of technical headcount fell from about 21% to 14%. About a third of ML managers and a fifth of software engineering managers said they were hiring less because of AI. The report calls the junior decline descriptive, not causal.

Hiring scorecards shifted as well. For technical candidates, comments on autonomy and judgment rose most, while domain expertise fell as a share of assessments. Some employees say they’re moving away from the hands-on work that built their skills in the first place.

Here’s the connection to attention. Judgment is what you spend reviewing agent work. People build judgment by doing the object-level work that agents now take. If nobody does that work any more, nobody builds the judgment needed to supervise agents.

We don’t think the answer is avoiding agents. It’s designing apprenticeship on purpose. Have newer engineers write specs and review agent output alongside a senior engineer. Give them ownership of a code area’s evals or review rules. They learn the system by deciding what counts as correct.

When this doesn’t apply yet

Not every team has an attention problem. If engineers run one agent at a time on short tasks, idle time is normal and cheap. Adding queues and triage would be overhead with no payoff. Our five levels of AI SDLC maturity are a rough guide here. The attention bottleneck shows up when teams run parallel agents and long background tasks.

Be careful with Anthropic’s numbers as benchmarks, too. A frontier lab building the model it uses is not a typical engineering org. Use the report to choose what to measure, not as a target.

The bottom line

Anthropic’s data shows the bottleneck in agent work moving from the agent to the person directing it. Interactive sessions wait on people about 80% of the time. Meta-work more than doubled. Output rose faster than anyone can read it. Teams that keep adding agents without managing attention will feel this as queues, interruptions, and shallow review.

One thing to do this week: pick two engineers who run coding agents daily. For five working days, have them log every time an agent waits on them, the wait length, and whether it was approval, clarification, or review. Group the clarifications. Turn the three most common into standing instructions in the repo, then compare the next week’s log.

If your agents are busy but your team isn’t shipping faster, look at the workflow around them. Our AI cleanup work starts there.

Sources