twimco.Let’s talk ↗︎
Menu
Field notes / AI in practice

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.

Editorial engraving of a bright home office where a developer returns with tea to a laptop left open at an empty desk, a cat asleep on the windowsill.

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

ConsiderationPrompt and wait (default)denyInsteadOfPrompting on
Somebody at the keyboardFine: the person answers and work continuesAnnoying: they'd rather be asked
Overnight or scheduled runStalls on the first prompt until someone wakes upRefuses the call and keeps working on what it can
Subagents and teammatesA hidden worker can block the whole jobThe worker gets a refusal and reports back
What you read laterOne stuck promptA list of refusals, each one a decision to make
Decision framework: assess against how and when your agent runs.

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

  1. Allow

    List the exact commands and tools the job needs: tests, lint, read-only lookups.

  2. Deny

    Name what must never happen: pushes to main, deploys, deletes, network to unknown hosts.

  3. Refuse the rest

    Turn on denyInsteadOfPrompting so anything unlisted is refused, not queued.

  4. Say what to do next

    Tell the agent in its instructions to note each refusal and skip, not improvise.

  5. Read in the morning

    Review the refusals. Each one becomes an allow rule, a deny rule or a human task.

Illustrative setup sequence, not a client screenshot or measured result.

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

twimco.

We build alongside the people doing the work.
Bring us the problem you’re thinking about.

Related work

Spin:Market ↗︎