Are You Your Agent’s Bottleneck? Run a Monthly “Human-Dependency Audit”

On this page

What Happened

Looking back over 30 days of conversations, @mihai673 found “What’s next?” 60 times—and 32 of those were followed immediately by “Do it”1. Pending decisions pile up into a long queue by morning1; as agents multiply, just managing them eats up nearly a full workday3. An agent stuck on a login page waiting for a verification code paused the workflow on its own when the code never came4. These cases point to the same thing: the bottleneck is no longer whether agents are smart enough, but human attention2. However fast code gets written, if it still waits on requirements clarification and review, the whole process won’t speed up5.

A paper from Hugging Face and others calls this “approval fatigue”: the more autonomous agents become, the more likely humans are to approve on autopilot, over-rely on them, and lose judgment over time67. In cases compiled by @anishmoonka, Claude Code asked the same developer for permission 47 times in one session, and each time he clicked allow without reading8.

Common Approaches

1. Have your agent take stock once a month. A “human-dependency audit” prompt16 asks the agent to review the past month and list where you keep approving, keep supplying information, or hand work off manually. Two real runs each surfaced more than a dozen fixable items, and most of them were actually fixed1718.

2. Tier approvals by risk. The shared principle: let go of what’s reversible and low-impact; keep humans on anything involving money, sending email, deleting, or publishing externally1315. One similar audit found that most bottlenecks were repeated approvals of things already approved five times; switching to standing permissions solved more than any prompt did19. When PRs pile up faster than they can be reviewed, an agent can score each PR on several risk dimensions after checks pass, auto-approve the low-risk ones, and notify a human about the rest—a human still clicks merge23.

3. Limit capabilities first, then cut approvals. Sandboxes, narrower permissions, and separate development and production environments mean many actions never need a human’s sign-off. But a sandbox can stop an accidental file deletion; it can’t stop an agent with legitimate permissions from doing the wrong thing to a production database. Those actions still need approval every time12.

4. Let another agent review first. OpenAI launched Auto-review, in which a second agent reviews actions. In a chart posted by @thsottiaux, 9,280 of 10,000 actions stayed inside the sandbox910.

5. Report exceptions only. An unread renewal notice led to a refund; afterward the setup changed to an early reminder before expiry, with only exceptions reported day to day21. For workflows that touch money, step one can be limited to “read, flag, and prepare for human approval”24.

Consensus

  • An approval button is not, by itself, a control. If a human can’t understand the action in time or can’t undo it, the button is just decoration13.
  • Approval requests should spell out what changed, what was checked, and what couldn’t be verified; otherwise they’re a rubber stamp22.
  • Standing permissions need an expiry, must be revocable, and should leave a record20.

Disagreements

  • Should humans stay in the loop? Step-by-step approval is itself the bottleneck and defeats the purpose of using agents14. But compare self-driving cars: when everything is automated until a critical moment suddenly hands control back, humans often can’t take over in time14.
  • Does automated review count as oversight? It cuts down on low-risk interruptions10; but the same model reviewing itself with the same context isn’t an independent check13.
  • Too many approvals, or work sliced too thin? That many approvals can be read not as an interface problem but as work split into pieces that are too small: plan the whole job first, ask everything at once, and the fatigue goes away830.
  • Should permissions be granted item by item? Another approach puts authorization outside the agent, in an independent policy layer, instead of relying on prompt constraints11.

What to Do

  1. Run the audit prompt below on a fixed day each month. If your agent can’t remember past work, paste in last month’s conversation logs or to-do list.
  2. Handle only the top 5 items. Change one at a time and watch for two weeks before changing the next.
  3. Start with approvals where you always give the same answer, and turn them into standing permissions with an expiry.
  4. Always keep payments, sending email, deletions, and public posts for yourself.
  5. Next month, before running a new audit, check whether any permissions you granted last time should be revoked.

General-Purpose Prompt

Works with any agent that can read records of your past work:

Human-Dependency Audit · 25 lines
HUMAN-DEPENDENCY AUDIT
Review how we've worked together over the past [30] days. Sources: [the work you remember / the conversation logs or task lists I've attached].
Base this only on records that actually exist. Where you don't remember clearly, say so; don't guess.

Find every place where work stopped, slowed down, or came back to wait on me before it could continue, especially:
1. Work you could have started without me asking
2. Decisions you repeatedly waited for me to make
3. Information you repeatedly asked me for that could have been stored
4. Approvals where I always give the same answer
5. Work I manually hand off between tools or agents
6. Repetitive checks that could run on a schedule or a trigger
7. Outputs I distribute by hand that you could deliver directly
8. Work where I review every item but reviewing only exceptions would be enough

For each item, include:
- Category: Keep me in / Teach you / Store as standing information / Automate / Escalate exceptions only
- Evidence: cite specific work or records
- Waiting: roughly how long it waited on me and how often it happens (only if there are records; don't estimate)
- Suggested change: if I'd be giving you standing permission, state the scope, the expiry, and a review after [30] days
- Risk: what could go wrong after the change, and whether it can be undone

Rules:
- Don't change anything yet. List the biggest items first; we'll go through them one at a time afterward.
- Payments, sending email, deleting anything, and publishing publicly in my name always fall under "Keep me in."
- From now on, when you ask me for approval, state: what you'll do, what changed, what you checked, and what you couldn't verify.

Replace the [ ] parts with your own details

Adapted from @Michael_Fenech_’s approach

How Tools Differ

  • Memory: Agents that remember work across conversations (for example, Grok Bot’s memory stores preferences, role context, and summaries, separately for each bot27) can review directly; with tools that don’t remember, attach the records yourself.
  • Approval mechanics: Claude Code subagents can be set to a permission mode25; when Grok Bot sends email from its own inbox, every message needs approval, and approval requests raised by routines or other bots expire after a short while2628; OpenAI’s Auto-review has a second agent review first9. Before switching to standing permissions, check how finely your tool lets you scope them.
  • Scheduling: Tools that can run on a schedule (for example, Grok Bot’s Routines, where every run consumes usage29) can run the audit monthly; for tools that can’t, put a reminder on your calendar and paste the prompt manually.

References

  1. @mihai673: 60 “What’s next?” prompts, 32 straight yeses, 41 pending decisions ↩ a b
  2. @StanleyWei4748: The bottleneck is human attention ↩
  3. Jason M. Lemkin (LinkedIn): From 3 agents to 22, daily management time grew to 8 hours ↩
  4. Ashish Gupta (LinkedIn): Agent paused after waiting in vain for a verification code ↩
  5. Kelly Waters (LinkedIn): Output got faster, waiting didn’t shrink ↩
  6. @rohanpaul_ai: Summary of the paper “AI Agents Push Humans Out of the Loop” ↩
  7. @mmitchell_ai: Six oversight strategies from the paper ↩
  8. @anishmoonka: 47 “Allow” clicks in one session ↩ a b
  9. @thsottiaux: Auto-review opened for free; distribution chart of 10,000 actions ↩ a b
  10. @aakashgupta: A guardian subagent reviews commands ↩ a b
  11. r/AI_Agents: Put authorization outside the agent and workflow code ↩
  12. @vicky_grok: Sandboxing and credential isolation; replies flag the risk of legitimate permissions ↩
  13. Junaid Ahmed (LinkedIn): Five kinds of work that should keep a human; same-model review isn’t independent ↩ a b c
  14. Adrian Sanabria (LinkedIn): Questions whether human-in-the-loop is a bottleneck; self-driving analogy in the replies ↩ a b
  15. mindforge.iq (TikTok): Automate more of what’s low-risk and reversible; keep humans on high-impact actions ↩
  16. @Michael_Fenech_: The original human-dependency audit prompt ↩
  17. @Kevin_Logan: Found 15 items, applied 13 ↩
  18. @DisruptConcept: Found 15 items, implemented 12, now runs it every 30 days ↩
  19. @OpsDaddyAI: Turned repeated approvals into standing permissions ↩
  20. @YoKoSuKa929: Standing permissions need an expiry and must be revocable ↩
  21. @DanielMed_2: Switched to exception-only reporting after a missed renewal notice ↩
  22. @brandononchain: Approval requests should include what was checked ↩
  23. How I AI (YouTube): Scoring PRs by risk and auto-approving low-risk ones (workflow from 11:36, six-factor risk scoring from 15:47) ↩
  24. r/AI_Agents: Money workflows should read, flag, and wait for human approval first ↩
  25. Claude Code docs: Subagents ↩
  26. Grok Bot Help: FAQs ↩
  27. Grok Bot docs ↩
  28. Grok Bot Help: Agent email ↩
  29. Grok Bot Help: Routines ↩
  30. @madebyoliver reply: 47 approvals means the work was sliced too thin ↩