New: watch your coding agents work, step by step, on a live board. Try the demo, no account

Why VS Code's Copilot agent waits for you without telling you, and the fix

By Jake Marsh, who builds Taskhold. Updated 2026-11-17. Facts about other tools checked 2026-11-17. 9 min read.

Short answer: Copilot agent mode stops on tool and terminal approvals, on its own questions, and on a "Continue to iterate?" pause when it reaches chat.agent.maxRequests (25 by default). VS Code sends an OS notification only while its window is unfocused unless chat.notifyWindowOnConfirmation is always. Terminal rules, permission levels and a higher limit cut the stops. For questions about the work, have the agent post to a shared board such as Taskhold's live board.

You give Copilot's agent a long task in VS Code, switch to another file or app, and come back to find it stopped on an Allow button a few minutes in, or on a "Continue to iterate?" card. This guide covers each kind of stop, the setting that controls it, how to make VS Code tell you when one happens, and how to get the agent's questions onto your phone.

For the same problem in other agents, see Cursor agent waiting for input, Claude Code waiting for input and Codex CLI waiting for approval. To try answering a blocked agent from a browser, open the live board demo.

The live board, drawn with the same progress bar component the app uses. A working task with five steps, and a blocked task waiting on a reply.

Why there was no alert

VS Code has a setting for exactly this: chat.notifyWindowOnConfirmation sends an OS notification when the agent needs your input or confirmation to continue. Its default is windowNotFocused, so the notification shows only when the VS Code window isn't focused. If you switched to another file or panel in the same window, nothing fires. A second setting, chat.notifyWindowOnResponseReceived, does the same for a finished response. Set both to always in your user settings.json:

{
  "chat.notifyWindowOnConfirmation": "always",
  "chat.notifyWindowOnResponseReceived": "always"
}
Values: off, windowNotFocused (default) or always. Selecting the response notification brings focus to the chat session.

On macOS, check System Settings > Notifications > Visual Studio Code and make sure a Focus mode isn't holding notifications.

Tool approvals: Allow Once and broader scopes

New sessions start at Manual permissions (the chat.permissions.default setting). At that level, any tool call that isn't auto-approved waits for you to review its inputs and approve it. In Copilot harness sessions, Allow Once is the default action for terminal commands, web fetches and file access, and its dropdown offers broader grants:

  • An in this Session option limits the grant to the current session. Always Allow saves it for future sessions on the same Agent Host, including after a restart.
  • For a terminal command, the grant covers a suggested prefix such as npm run build, or the exact command. For a web fetch it covers the host shown. For a file it covers the file or, when offered, its folder; read and edit approvals are separate.
  • On your machine, Always Allow for a terminal command is written to chat.tools.terminal.autoApprove in your user settings, and Always Allow Fetching to chat.tools.urls.autoApprove.

Run Chat: Manage Tool Approval from the Command Palette to see every approval grouped by MCP server or extension. Pre-approval runs a tool without asking; post-approval adds its result to the chat without review, which matters for external data that could carry a prompt injection. Chat: Reset Tool Confirmations clears saved approvals. To keep one tool always asking, set it to false in chat.tools.eligibleForAutoApproval.

Terminal command approvals

The agent runs every shell command through one terminal tool, and VS Code checks each command against the rules in chat.tools.terminal.autoApprove. By default common read-only commands run without asking, and the built-in rules require approval for rm, rmdir, del, kill, curl, wget, eval, chmod, chown and Remove-Item. Add your own rules to stop the prompts you always approve:

{
  "chat.tools.terminal.autoApprove": {
    "mkdir": true,
    "/^git (status|diff|log)$/": true,
    "/^npm (test|run lint)$/": true,
    "git push": false
  }
}
true runs the command without asking, false asks every time. Wrap a regular expression in / characters.
  • Rules match each subcommand. A compound command runs without asking only when every part matches a true rule and none matches a false rule. Set matchCommandLine to true in the object form to match the whole line instead.
  • A false rule asks for approval; it doesn't block the command. A false rule also wins over a true rule or a session approval.
  • In Copilot harness sessions, the runtime can approve read-only or sandboxed commands before your rules are checked, so a matching false rule may not prompt.
  • chat.tools.terminal.enableAutoApprove (on by default) switches rule-based approval off entirely. chat.tools.terminal.blockDetectedFileWrites defaults to outsideWorkspace, so detected writes outside the workspace still ask.
  • If a command itself waits for input in the terminal, such as a yes/no question, chat.tools.terminal.autoReplyToPrompts (off by default) replies with a default answer.

VS Code's docs call terminal auto-approval a best-effort convenience, not a security boundary: the parser can miss subcommands, and zsh and fish are parsed with the bash grammar. For untrusted work, turn on agent sandboxing (chat.agent.sandbox.enabled), which limits file system and network access even for approved commands.

"Continue to iterate?" and chat.agent.maxRequests

chat.agent.maxRequests is the maximum number of requests the agent can make, 25 by default. VS Code's docs stop there. In VS Code's source, the agent loop that hits the limit shows a confirmation titled "Continue to iterate?" with the message "Copilot has been working on this problem for a while. It can continue to iterate, or you can send a new message to refine your prompt." and two buttons:

  • Continue lets the agent keep going with a limit about one and a half times the previous one, so a long task can pause again later.
  • Pause stops the request there. Send a new message to refine the prompt and carry on.
  • The message's Configure max requests link opens the setting.
  • In Autopilot, the same loop raises the limit by itself, up to 200, instead of asking.

This loop is VS Code's built-in agent, the one Local harness sessions run. The docs don't say how the setting applies to Copilot harness sessions. To pause less often, raise the number in your user settings:

{
  "chat.agent.maxRequests": 100
}
A higher limit also lets a run that has gone wrong keep going longer before you look.

Fewer stops: permission levels and global auto-approve

  • The permissions dropdown in the chat input sets the level per session: Manual permissions (default), Assisted permissions (a model judges each tool call and you confirm the ones it doesn't approve; Copilot harness only) or Allow all (no confirmations). chat.permissions.default sets the starting level: default, autoApprove or autopilot.
  • Autopilot auto-approves all tools, retries on errors and answers questions that would otherwise block progress, working until it decides the task is done. In Copilot harness sessions it's an agent mode in the mode picker; in Local harness sessions it's a permission level.
  • chat.tools.global.autoApprove approves every tool in every workspace. Until VS Code 1.104 it was called chat.tools.autoApprove, and the rename had no automatic migration, so the old key does nothing now. A warning dialog asks you to confirm the first time it's used.
  • /yolo or /autoApprove in the chat input bypasses approvals for the current supported session only, and /disableYolo or /disableAutoApprove restores the session's level.

An organization can turn these off. GitHub's enterprise-managed setting disableBypassPermissionsMode set to disable turns off chat.tools.global.autoApprove in VS Code and stops it from being re-enabled, and a managed default permission level applies to new sessions. Sandboxing stays on under Allow all and Autopilot when it's enabled.

Several sessions, and getting at them from your phone

In the Agents window, Inbox mode sorts sessions by what needs you. Turn on sessions.list.inboxEnabled (off by default), then pick Filter Sessions > Grouping > Inbox Mode. The Inbox category collects questions, approval requests, errors, failing pull request checks and responses to review, above Working, Ready to merge, On hold and Done.

GitHub environments, in preview, registers your machine with your GitHub account so you can continue its agent sessions from VS Code on another machine, the GitHub Copilot app, Copilot CLI, GitHub.com or GitHub Mobile. VS Code's docs say available actions vary by client, so check that yours shows the approval before you count on it. The session's files, tools and commands stay on your machine, so it has to stay online.

Where Taskhold fits

Taskhold handles the other kind of stop: a question about the work, from Copilot or any other agent. With the workflow snippet in AGENTS.md or .github/copilot-instructions.md, the agent calls taskhold_block with one specific question instead of waiting in the chat. When the answer is a choice, it passes two to four options, marks the one it recommends and says what it will do if nobody answers.

  • The question appears as a card under Needs you on the live board and on the Needs you page (/dashboard/needs-you), laid out for a phone. Tap an option or type a reply.
  • Taskhold emails you the question as soon as the agent asks (on by default, at most one email per question), and you can add web push on your phone or ntfy in Settings.
  • The agent reads your answer with taskhold_updates, and can take the next task while it waits.
If you need a decision from me, call taskhold_block on the task with one
specific question. When it's a choice, pass 2 to 4 options, the one you
recommend, and what you'll do if I don't answer. Then take the next todo
and check taskhold_updates between steps for my reply.
Add to AGENTS.md or .github/copilot-instructions.md next to the Taskhold workflow snippet from the VS Code setup page.
  • Tool and terminal approvals still need an answer in VS Code, and so does the Continue to iterate pause. Taskhold carries questions about the work, not tool approvals.
  • Taskhold doesn't wake an agent that has stopped. The agent reads your reply the next time it calls taskhold_updates.
  • Setup is on the VS Code page, and the whole loop is in answering a blocked coding agent. If the taskhold tools never appear, see VS Code Copilot MCP tools not showing.
Share this page:XLinkedInBlueskyHacker News

Answer your coding agents from anywhere.

$12/month or $120/year after the trial. Card up front. Cancel before day 7 and you pay nothing. Every agent you run is included.

Or connect your agent first, no sign-up: add https://taskhold.com/api/mcp as an MCP server. The first time it uses Taskhold, it gives you the trial link.

Questions

Why didn't VS Code notify me when the agent needed approval?
chat.notifyWindowOnConfirmation defaults to windowNotFocused, so VS Code sends an OS notification only when its window isn't focused. Set it to always to get one while you work elsewhere in VS Code.
Does chat.tools.autoApprove still work?
No. VS Code 1.104 renamed it to chat.tools.global.autoApprove without migrating the old value, so you have to set the new key. Per-session Allow all, or terminal rules in chat.tools.terminal.autoApprove, approve less at once.
How do I stop the "Continue to iterate?" prompt?
Raise chat.agent.maxRequests (25 by default) in your settings, or select Continue when it appears. Autopilot raises the limit by itself, up to 200, without asking.

Sources

Related

Updated 2026-11-17. Something wrong or out of date? Email hello@greatwork.company.