# Claude Code 'Auto Mode Check Unavailable' or 'Classifier Unavailable'? 4 Fixes

> Bash, Edit and MCP calls all refused while Read still works. The auto mode safety check failed, not your command. What the error means, why it stops after ten, and four fixes from Anthropic's own docs.

By Tahir Nazir · Published 2026-10-05 · Updated 2026-11-19
Canonical: https://www.its-tahir.com/blog/claude-code-auto-mode-classifier-no-verdict

**If Claude Code shows `Auto mode check unavailable` and then refuses every shell command — even `pwd` — because the auto mode classifier is unavailable or gave no verdict, your command was never judged.** A safety check that runs before risky actions failed to answer, and the CLI chose to block rather than run anything unchecked:

```text
The server-side auto mode classifier gave no verdict (error), so auto mode cannot
determine the safety of Bash. This is a transient failure of the check, not a
judgment about the action: a later response may get a verdict.

Auto mode is unavailable — the server returned no safety verdict for the last 10
responses, so Claude stopped. Send a message to try again, or switch out of auto mode.
```

In an interactive session the denial can show only as a dim `Not run · auto mode's check had no usable answer` row under the tool call (press `Ctrl+O` to read the full message). In debug logs from the 28 September outage, the line reads `Auto mode classifier unavailable, denying with retry guidance (fail closed)`.

**Quick fix:** send another message, which resets the count; most outages cleared within minutes. If it keeps happening, restart with `CLAUDE_CODE_AUTO_MODE_SERVER=0` (v2.1.281+) or press `Shift+Tab` to leave auto mode. If the denial says `(the conversation is too long for the check)`, run `/compact`.

**Since v2.1.302**, the release notes say auto mode with the server-side classifier is improved: "a conversation too long for the safety check is now compacted, instead of every checked tool call being denied." On an older version, `claude update` gets you that.

Starting on 28 September, three separate GitHub reports filed the same day collected dozens of "same here" replies across macOS, Linux, Windows and WSL, in the terminal, VS Code and the desktop app. The top one, [#97854](https://github.com/anthropics/claude-code/issues/97854), describes **every** Bash call failing for several minutes, then recovering with nothing changed. Users kept reporting it on 29 and 30 September and into October.

Below is what that check is, why the failure looks so strange, and the four ways out.

## What auto mode's classifier actually does

In auto mode, the CLI stops asking you to approve each action. Instead, as Anthropic's docs put it, *"a separate classifier model reviews actions before they run, blocking anything that escalates beyond your request, targets unrecognized infrastructure, or appears driven by hostile content Claude read."*

From v2.1.283, auto mode is the **default starting mode** for interactive terminal and VS Code sessions. That's why so many people met this error without ever choosing auto mode.

The detail that matters for this error is **where** the check runs. Recent versions ask Anthropic's servers to do it as part of the normal model request, instead of Claude Code making a separate classifier call. The docs call this *server-side classifier review*, and it's being rolled out across the direct Anthropic API, cloud providers and LLM gateways.

When the server returns its decision, that decision is final. When it returns **nothing**, the classifier gave no verdict, and the action is refused.

## Why pwd is blocked but Read still works

This is the part that makes the error feel broken. Claude can still read your files, search the code and often edit, but `ls` fails.

It's by design. In auto mode's decision order:

| Action | Goes through the safety check? |
| --- | --- |
| Read tool, searches | **No** — auto-approved |
| File edits inside your working directory | **No** — auto-approved, except protected paths |
| Read-only shell commands (`pwd`, `ls`, `git log`) | **Yes**, with server-side review — they wait for the check |
| Other shell commands, network calls, MCP tools | **Yes** |

The docs are explicit that *"in a session with server-side classifier review, read-only and sandboxed shell commands wait for that review."* So when the review fails, every Bash call fails with it, harmless or not. The Read tool, which never goes to the check, carries on.

**If your file edits are blocked too**, which two of the reports describe, check two things. Is the file outside the directory you started the session in? And is it under a protected path such as `.claude/`, `.git/`, `.vscode/` or `.mcp.json`? Both of those always go to the check in auto mode.

## What does "Auto mode check unavailable" mean?

`Auto mode check unavailable` is the Claude Code spinner, with a countdown, shown while it waits to retry an action whose auto mode safety check got no answer from Anthropic's servers. Your command was not judged dangerous. Press `Esc` to interrupt. After ten responses in a row with no verdict, auto mode stops the turn with `Auto mode is unavailable`, and sending a message resets the count.

## The three messages, and what each means

**One action blocked:**

```text
The server-side auto mode classifier gave no verdict (timed out), so auto mode
cannot determine the safety of <tool>.
```

The word in brackets is the failure category, when one can be worked out — `(timed out)`, `(error)` and so on. Before some retries, it waits; the spinner shows `Auto mode check unavailable` with a countdown, and `Esc` interrupts.

**The turn stopped:**

```text
Auto mode is unavailable — the server returned no safety verdict for the last 10
responses, so Claude stopped. Send a message to try again, or switch out of auto mode.
```

Ten responses in a row without a verdict ends the turn. In a non-interactive `-p` run, the run ends with an execution error. A subagent that hits the limit stops early, and the main session gets whatever it produced.

**A different failure that looks similar:**

```text
<model> is temporarily unavailable (rate-limited), so auto mode cannot determine
the safety of <tool> right now. Wait a moment and then try this action again.
```

This one comes from **Claude Code's own** classifier request rather than the server's review. The category can be `(rate-limited)`, `(overloaded)`, `(server error)`, `(timed out)` or `(connection failed)`. If `timed out` or `connection failed` keeps coming back, treat it as a network problem first — it's the same territory as [529 overloaded errors](/blog/claude-code-529-overloaded-retry-behaviour).

## What does "A hook gave no usable answer, so it didn't check this action" mean?

**It means a `PreToolUse` hook, one you configured or one a plugin added, didn't return a decision for that tool call: it ran out of time or printed nothing Claude Code could read. Unlike the classifier messages above, it doesn't block anything by default. The hook's check is skipped, and the action goes ahead as if the hook weren't there, so your permission rules and mode decide.** It's a warning, not an auto mode failure, though it often shows up in auto mode sessions because that's where people run guard hooks.

The two wordings, as they appear in the Claude Code 2.1.325 and 2.1.328 builds:

```text
A hook gave no usable answer, so it didn't check this action.
A hook of the "<plugin>" plugin didn't answer in time, so it didn't check this action.
```

Claude Code names the plugin when the hook came from one, and says `didn't answer in time` instead of `gave no usable answer` when the hook timed out. To fix it:

1. **Find the hook.** If the message names a plugin, it's that plugin's hook: update or disable the plugin in `/plugin`. Otherwise run `/hooks` to see the `PreToolUse` hooks in your settings.
2. **See what it printed.** Start Claude Code with `claude --debug` and repeat the action; the debug log shows the hook's output and exit code.
3. **Make it answer.** A command hook decides with its exit code (`0` lets the call continue, `2` blocks it) or with JSON on stdout. If it's slow rather than broken, raise its `timeout` (in seconds) in the hook's settings entry.
4. **If the hook is a safety guard, make failures block.** Add `"onFailure": "block"` to the hook's entry. A hook that fails, times out or prints invalid JSON then counts as a block instead of being skipped. 2.1.328 extended this setting to `mcp_tool` hooks.

If you want a guard written in code rather than a script, a [Claude Code mod](/blog/claude-code-mods) can refuse a tool call from inside Claude Code; a hook is still the simpler choice for a one-line rule.

## Is the Claude classifier down?

Sometimes, but you can't confirm it directly: Anthropic's status page, [status.claude.com](https://status.claude.com), lists a **Claude Code** component but no separate entry for the auto mode classifier, so an outage of the check can show up there as a Claude Code incident or not at all. Two quicker signs:

- **It's everyone:** sessions on different machines or networks fail at the same time, and GitHub fills with "same here" reports, as on 28 September 2026. Wait a few minutes and send another message.
- **It's only you, for hours:** the check's response is probably being cut short on the way, usually by an LLM gateway or proxy. Fix 4 covers that.

Since Claude Code 2.1.314, an action skipped because the auto mode check gave no verdict is no longer reported as blocked or listed in `/permissions`, so it doesn't clutter your review list.

## Four fixes, in the order I'd try them

### 1. Send another message

The official first step, and often enough. Sending a new message resets the count of failed responses. In the reports, most outages cleared on their own within minutes to tens of minutes. One commenter put a window of roughly 13:16–13:35 UTC on 28 September.

If you can, keep Claude busy with read-only work meanwhile. Reading and searching don't need the check.

### 2. Use Claude Code's own classifier instead of the server's

```bash
export CLAUDE_CODE_AUTO_MODE_SERVER=0
claude
```

This tells the CLI to skip the server-side review and make its own classifier requests, the way it did before. It's documented, and a commenter on [#97766](https://github.com/anthropics/claude-code/issues/97766) reported it as an effective workaround during the outage. Set it **before** starting the session, in your shell or in the `env` block of your settings file.

Three things to know first:

- **It needs v2.1.281 or later** on a direct Anthropic API connection. Earlier versions ignore it there.
- **It can cost money, depending on your account.** The server's checks are free. Claude Code's own classifier requests count toward token usage on Enterprise plans, Claude API accounts, and Amazon Bedrock, Google Cloud's Agent Platform and Microsoft Foundry.
- **It's temporary.** Anthropic's billing page says the variable *"is a temporary setting and may be removed in a later release."* Use it to get through an outage, not as permanent config.

To see which path a session is on, run `/status`. The **Auto mode server** row reads `Enabled` while the server is doing the checks, and `Disabled` once the session has fallen back to its own.

### 3. Switch out of auto mode

Press `Shift+Tab` to change permission mode. This was the most common workaround in the threads, and the one Anthropic's message itself suggests:

- **Manual** (`default`) — you approve everything except reads. Slower, but immune to this error.
- **Accept edits** — file edits and common filesystem commands like `mkdir`, `mv` and `cp` run automatically. Other shell commands still ask you.

Several people reported switching to accept-edits for a few actions and then back to auto as a fix. That probably just coincided with the server recovering — there's no documented reason it would reset anything. But it's harmless.

### 4. If it never stops: check your gateway or proxy

If your traffic goes through an LLM gateway or company proxy (`ANTHROPIC_BASE_URL` points somewhere other than Anthropic), and the error **keeps** coming back when nobody else is reporting an outage, the gateway is the likely cause.

The docs name the behaviour precisely. A gateway that **cuts streaming responses short**, or rewrites them, means the safety results never arrive intact. The client then sees no verdict and blocks the action. The fix is on the gateway side: pass requests and responses through unchanged, including fields it doesn't recognise, such as `safeguards` on requests and `safeguard_results` on responses.

If you know your gateway can't do that, `CLAUDE_CODE_AUTO_MODE_SERVER=0` is the documented setting for exactly this situation.

A gateway that drops those fields entirely, rather than cutting responses short, causes a different symptom: no denials, but a notice that *"this session isn't eligible"* for free classifier checks. That one is covered in [Claude Code auto mode classifier billing](/blog/claude-code-auto-mode-classifier-billing).

## Why it blocks instead of asking you

The most-repeated request in the threads is the same one: *if the check is down, fall back to asking me, don't refuse.* It's a fair complaint. A blocked turn burns time, and one user pointed out that each failed attempt still spends a turn against their usage.

Claude Code's current behaviour is a deliberate **fail-closed** design. Its docs say it *"denies the action rather than run it unreviewed."* Anthropic doesn't spell out the reasoning there, but my reading is this: auto mode exists for people who aren't watching each action. Quietly downgrading to "ask" could just as easily mean an action sits waiting while nobody is there, or, in a non-interactive run, gets dropped without a decision.

You don't have to accept that default. The fixes above are the ways to choose a different trade-off for your own session.

**Update, 10 November 2026:** Claude Code 2.1.319 moved partly toward that request. When the session has no check it can use at all, for example with telemetry or feature flags off or behind a gateway that drops the server's review, actions that need the check now ask you instead of only being refused; the dialog reads `Auto mode can't check actions in this session`. The same release made auto mode explain itself and ask you in the terminal when your permission rules or `autoMode` settings are too large to send, unless `autoMode` deny rules are set, and `claude -p` now exits 1 when its actions were refused for lack of a check. A server that answers without a verdict still gets a denial. Details are in [the classifier billing post](/blog/claude-code-auto-mode-classifier-billing#what-does-auto-mode-cant-check-actions-in-this-session-mean).

## The bigger picture: a check on every tool call is now a product category

This outage is a good example of something every agent builder will run into. **Once a second model sits between the agent and every risky action, that model's uptime becomes your agent's uptime.**

That pattern has just become its own kind of product. On 15 September, TypeSafe AI released **Jev**, a "decision model" that doesn't write text at all. You send it the current state and a set of typed questions, and it returns choices with probabilities, in tens to hundreds of milliseconds. [LangChain's walkthrough](https://www.langchain.com/blog/building-a-harness-with-jev) uses it for precisely this job: classifying risky tool calls *before they're taken*, alongside a normal LLM doing the actual work.

Two cautions if you're tempted. Jev is in limited early access, and its headline claims — 40 to 200 times faster and 40 to 400 times cheaper than frontier models — are the company's own. [Wikipedia notes](https://en.wikipedia.org/wiki/Jev_(AI_model)) that TypeSafe itself describes those figures as likely to sit at the high end of real-world results.

More importantly, a faster checker doesn't remove the problem this post is about. It moves it. Whatever you put in front of your tool calls, decide up front what happens when it doesn't answer — block, ask a human, or allow — and make that choice visible to the people running the agent. Claude Code made its choice and documented it. Most homegrown agent harnesses haven't made one at all.

## Quick triage

1. **Is Read still working?** Then the agent is fine and only the safety check is failing.
2. **Send another message.** It resets the counter, and short outages clear on their own.
3. **Still failing?** Restart with `CLAUDE_CODE_AUTO_MODE_SERVER=0` (v2.1.281+), knowing it may bill classifier calls on API, Enterprise and cloud-provider accounts.
4. **Need to keep moving right now?** `Shift+Tab` out of auto mode and approve actions yourself. To stop sessions starting in auto mode at all, [set `defaultMode`](/blog/claude-code-auto-mode#how-do-i-turn-off-auto-mode-in-claude-code).
5. **Happens constantly, and only for you?** Check whether a gateway or proxy is truncating streamed responses.

**Key takeaways**

- 'Gave no verdict' means auto mode's safety check failed to answer — not that your command was judged unsafe.
- With server-side review, even read-only shell commands like pwd and ls wait for the check, which is why they fail while the Read tool keeps working.
- Ten responses in a row with no verdict stops the turn; sending a new message resets the count.
- CLAUDE_CODE_AUTO_MODE_SERVER=0 switches to Claude Code's own classifier (v2.1.281+), but it can bill tokens on API, Enterprise and cloud-provider accounts and is documented as temporary.
- A gateway that cuts streaming responses short causes the same error permanently. Any agent with a safety check in front of its tools needs a deliberate policy for when that check is down.

If auto mode isn't the only thing failing, [the full list of Claude Code errors and fixes](/blog/claude-code-troubleshooting) matches each error message to the post that solves it.

If the gateway in step 5 is a company proxy, the same "something in the middle rewrote the traffic" problem is behind [Claude Code's corporate-proxy SSL errors](/blog/claude-code-ssl-certificate-corporate-proxy). Other agents have checks that fail in the same confusing way: [OpenCode's "free tier can only be used from within OpenCode"](/blog/opencode-free-tier-can-only-be-used-from-within-opencode) blames the client when a config or network check failed, and [Codex's Auto-review](/blog/codex-auto-mode) puts a reviewer agent in the same seat as this classifier. Deciding what an agent is allowed to do unsupervised, and what happens when the guardrail itself goes down, is a large part of the agent work I do — [see recent projects](/work).

## FAQ

### What does 'Auto mode check unavailable' mean in Claude Code?

It's the spinner Claude Code shows, with a countdown, while it waits before retrying an action whose auto mode safety check got no answer from Anthropic's servers. Your command wasn't judged dangerous; the check itself failed. Press Esc to interrupt, or wait: after ten responses in a row with no verdict, auto mode stops the turn with 'Auto mode is unavailable'. Sending another message resets the count.

### Is the Claude classifier down?

Check status.claude.com, which has a Claude Code component; there's no separate entry for the auto mode classifier, so a classifier problem can show up there as a Claude Code incident or not at all. If several sessions on different networks fail at once, it's on Anthropic's side and usually clears within minutes to tens of minutes. If only you see it for hours, look at your LLM gateway or proxy.

### What does 'the server-side auto mode classifier gave no verdict' mean?

In auto mode, a second model checks shell commands, network calls and other risky actions before they run. On many connections that check now happens on Anthropic's servers. 'No verdict' means the check failed to come back — it timed out, the response ended early, or it couldn't be read — so Claude Code refused the action rather than run it unchecked. It is not a judgement that your command was dangerous.

### Why does Claude Code block pwd and ls but still let Claude read files?

The Read tool, searches and edits inside your working directory skip the classifier. Shell commands do not: in a session with server-side review, even read-only shell commands like pwd, ls and git log wait for the server's check. When the check fails, they are blocked along with everything else that goes through Bash.

### How do I stop the auto mode classifier error?

Send another message, which resets the count. If it keeps happening, start Claude Code with CLAUDE_CODE_AUTO_MODE_SERVER=0 so it uses its own classifier requests instead of the server's check (requires v2.1.281 or later on a direct Anthropic API connection), or switch out of auto mode with Shift+Tab and approve actions yourself. If your traffic goes through an LLM gateway or proxy, check that it isn't cutting streaming responses short.

### Does CLAUDE_CODE_AUTO_MODE_SERVER=0 cost more?

It depends on your account. Server-side checks are free. Claude Code's own classifier requests count toward token usage on Enterprise plans, Claude API accounts, and Amazon Bedrock, Google Cloud's Agent Platform and Microsoft Foundry. Anthropic describes the variable as temporary and says it may be removed in a later release.

## Sources

- [Claude Code changelog (2.1.296 to 2.1.314)](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md)
- [Choose a permission mode — Claude Code docs](https://code.claude.com/docs/en/permission-modes)
- [Error reference — Claude Code docs](https://code.claude.com/docs/en/errors)
- [Auto mode classifier request charges — Claude Code docs](https://code.claude.com/docs/en/auto-mode-classifier-billing)
- [Auto mode: server-side safety classifier intermittently returns no verdict (anthropics/claude-code #97854)](https://github.com/anthropics/claude-code/issues/97854)
- [Auto mode classifier unavailable blocks Bash/Edit calls (anthropics/claude-code #97766)](https://github.com/anthropics/claude-code/issues/97766)
- [Claude Code v2.1.302 release notes](https://github.com/anthropics/claude-code/releases/tag/v2.1.302)
- [How we built Claude Code auto mode — Anthropic Engineering](https://www.anthropic.com/engineering/claude-code-auto-mode)
- [Building a harness with Jev — LangChain](https://www.langchain.com/blog/building-a-harness-with-jev)
- [Jev (AI model) — Wikipedia](https://en.wikipedia.org/wiki/Jev_(AI_model))
