Claude Code can now say no when nobody is there to answer. Decide what a denied call should mean
An unattended agent run used to stall on the first permission prompt and sit there until morning. Claude Code's newest setting turns that prompt into a refusal and keeps going. That's progress, and it moves the real question to what the agent does after it hears no.

Claude Code 2.1.319, released November 6, 2026, adds permissions.denyInsteadOfPrompting. When it's on, any tool call that would wait for a person is denied and the turn carries on, in terminal sessions, subagents and teammates. Turn it on for unattended runs, but first write explicit allow and deny rules, tell the agent what to do after a refusal, and read the denials every morning. A denial nobody reads is just a quieter failure.
What changed on November 6
Claude Code 2.1.319 landed on November 6 with a setting that people running agents overnight have wanted for a while. It's called permissions.denyInsteadOfPrompting. The changelog puts it plainly: a tool call that would wait on a permission prompt is denied, and the turn continues. It works in terminal sessions, in subagents and in teammates.
Until now, an unattended run had one bad habit. The first time the agent tried something that wasn't already allowed, it asked, and then it waited. If nobody was there, it waited all night. You came back to a session that had done twenty minutes of work and then sat in front of a question for nine hours.
The same release changes how long-running tool calls behave. When an MCP server runs a tool call as a task, Claude Code now moves it to the background right away and tells Claude the result when it finishes, instead of blocking. A few smaller changes point the same way: an exact ask rule is now refused when a broader deny rule covers the command, and after safeguards stop a subagent, Claude is told to retry with a narrower prompt or tell you, not to go and do the work itself.
Taken together, it's a release about agents that keep moving when you're not there. That's useful. It also changes what you have to think about.
Decision guide
Waiting for a person, or refusing and moving on
| Consideration | Prompt and wait (default) | denyInsteadOfPrompting on |
|---|---|---|
| Somebody at the keyboard | Fine: the person answers and work continues | Annoying: they'd rather be asked |
| Overnight or scheduled run | Stalls on the first prompt until someone wakes up | Refuses the call and keeps working on what it can |
| Subagents and teammates | A hidden worker can block the whole job | The worker gets a refusal and reports back |
| What you read later | One stuck prompt | A list of refusals, each one a decision to make |
The question moves from "will it stall?" to "what will it do instead?"
Turning a prompt into a refusal doesn't make the decision go away. It just makes the agent make it, at three in the morning, from whatever it was told.
Picture a nightly job that updates dependencies and runs the test suite. One test needs a network call to a service that isn't on the allow list. With the old behaviour, the run stops and asks. With the new setting, the call is denied and the agent carries on. What it does next depends entirely on its instructions. A well-briefed agent writes "integration test skipped: network call denied" and moves on. A badly briefed one might decide the test is broken and try to change it, or reach for a different command that does roughly the same thing and happens to be allowed.
That's not a flaw in the setting. It's the reason the setting needs a few other things beside it.
A denial nobody reads is just a quieter failure.
Write the allow list and the deny list first
Before you turn the refusal on, list what the job genuinely needs. The specific test command, the linter, read-only lookups, writes inside one working directory. Put those in allow rules. Then list what must never happen in an unattended run, whatever the agent thinks: pushing to the main branch, deploying, deleting outside the working folder, reaching hosts you don't know. Put those in deny rules.
Everything else falls into the gap the new setting covers. Unlisted means refused. That's a sensible default for a run nobody is watching, as long as the two lists are short and specific enough that the gap holds the odd cases, not the normal work.
If your team already has "don't ask again" approvals scattered across personal settings files, this is the moment to gather them up. A refusal setting on top of years of forgotten allows isn't much of a boundary. Our note on cloud sessions makes a similar point about keeping secrets outside the agent's reach.
How the work moves
Setting up an unattended run
- Allow
List the exact commands and tools the job needs: tests, lint, read-only lookups.
- Deny
Name what must never happen: pushes to main, deploys, deletes, network to unknown hosts.
- Refuse the rest
Turn on denyInsteadOfPrompting so anything unlisted is refused, not queued.
- Say what to do next
Tell the agent in its instructions to note each refusal and skip, not improvise.
- Read in the morning
Review the refusals. Each one becomes an allow rule, a deny rule or a human task.
Tell it what a refusal means
Add a short paragraph to the instructions for any unattended job. Something like: if a tool call is denied, don't look for another way to do the same thing. Write down what you were trying to do and why, skip that step, and continue with the rest. If the step was essential, stop and leave a summary.
That one paragraph is the difference between a run that ends with a tidy list of five things it couldn't do, and one that ends with a creative workaround nobody approved. It also makes the next morning faster, because the refusals come with reasons.
Background tasks need a finish line too
The other half of the release deserves a minute. When an MCP server runs a tool call as a task, Claude Code no longer waits for it inside the call. It moves the task to the background and carries on, then tells Claude the result when it lands. If you'd rather it waited, the CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND environment variable keeps the old behaviour.
For a long export, a slow report or a test environment that takes ten minutes to spin up, backgrounding is the right default. But in an unattended run, it means the agent may make its next few decisions before it knows whether the task worked. Say in the instructions which tasks the rest of the job depends on, and that the agent must wait for those results before acting on them. A job that deploys a preview, assumes it succeeded and starts posting links to it is the kind of mistake that is easy to prevent in one sentence and tedious to unpick afterwards.
One more change in the same release is worth knowing if you use /loop. A self-paced loop now ends when a turn finishes without rescheduling, instead of scheduling a fallback wake-up. If one of your jobs quietly relied on that, it will now stop sooner than you expect.
Read the refusals every morning
A denial nobody reads is just a quieter failure.
Make reviewing them part of somebody's morning. For each refusal, decide one of three things. It should have been allowed, so add a narrow allow rule. It should never happen, so add it to the deny list. Or it needs a person, so it becomes a task. After a week or two the list gets short, which is how you know the rules fit the job.
Keep the setting off for interactive work, where a person is there and would rather be asked. It's a tool for the hours when nobody is. And if several people share the same unattended setup, agree on who owns the rules file, so one person's quick allow on a Friday doesn't quietly widen what every overnight run can do.
If you're building agents that run on a schedule, against real systems, and want the limits written down before they start, that's the work we do on AI applications and agents. Talk to TWIMCO.
Related work: Spin:Market
We build alongside the people doing the work.
Bring us the problem you’re thinking about.