--- title: "Claude Code v2.1.301–302: Unattended Retries, a Pickable Auto Mode Classifier, and Fork Subagents Everywhere" date: 2026-10-17 tags: ["claude-code","auto-mode","subagents","hooks","changelog","autonomous-agents"] categories: ["Guides"] summary: "Claude Code v2.1.301 (Oct 15) and v2.1.302 (Oct 16) cap how long unattended retries wait on a usage limit, let you choose the client-side auto mode classifier's model, turn fork subagents on by default outside the terminal, and limit concurrent prompt/agent hooks to 12 per event." --- ![Claude Code v2.1.301–302: Unattended Retries, a Pickable Auto Mode Classifier, and Fork Subagents Everywhere](/images/claude-code-v2-1-301-v2-1-302-unattended-retries-auto-mode-classifier-fork-subagents.png) Two releases in two days, and neither is flashy. Both are about the same thing: making Claude Code behave when nobody is watching. If you run agents overnight, in CI, or through the Agent SDK, these are the changes to read. Everything below comes from the [official changelog](https://code.claude.com/docs/en/changelog); I did not install either release. ## Unattended retries get a ceiling Claude Code has an unattended retry mode, enabled with `CLAUDE_CODE_RETRY_WATCHDOG`. v2.1.301 adds `CLAUDE_CODE_RETRY_WATCHDOG_MAX_USAGE_LIMIT_WAIT_MS`. Per the changelog, it makes the mode "end a request at a usage limit that resets too far away instead of waiting." That fixes a real failure mode. An agent that patiently sleeps until a limit resets is fine when the reset is twenty minutes away. It's a silent stall when the reset is days away and your pipeline is holding a runner open. Now you choose the maximum wait, and past it the request ends and your orchestration can react: fail the job, page someone, or fall back to another model. A sketch of how I'd wire it for an overnight job: ```bash export CLAUDE_CODE_RETRY_WATCHDOG=1 # give up if the usage limit resets more than 30 minutes from now export CLAUDE_CODE_RETRY_WATCHDOG_MAX_USAGE_LIMIT_WAIT_MS=1800000 claude -p "Work through specs/migration.md and open a PR" ``` The value is mine; the changelog gives no recommended number. The point is that "wait forever" is no longer your only option. ## Choose the model that judges your agent v2.1.302 adds `CLAUDE_CODE_AUTO_MODE_MODEL`, which selects the model the **client-side** auto mode classifier uses. The changelog is explicit that it "does not change the model for server-side auto mode." Auto mode is the feature that lets the agent act without a prompt for each tool call while a classifier screens for risky ones. Until now you took whatever classifier you were given. Being able to pin it matters for two reasons: cost (a cheaper model screening thousands of calls) and predictability (a classifier you've pinned doesn't shift under you when defaults change; model defaults did move recently, e.g. [Haiku 5.5 became the default Haiku](/posts/claude-haiku-5-5-subagent-model-pricing-effort-levels/)). I'd treat this the way you'd treat a linter version: pin it, and re-evaluate on purpose. A cheaper classifier that waves through something it shouldn't is a bad trade, and the changelog gives no benchmark for classifier accuracy by model. Test on your own tool-call traffic before switching. Related: with the server-side classifier, a conversation too long for the safety check is now compacted, "instead of every checked tool call being denied." Long sessions that used to grind to a wall of denials should now keep moving. v2.1.302 also adds `classifier_verdict`, `permission_mode` and `classifier_category` to OpenTelemetry `tool_decision` events (the category requires `OTEL_LOG_TOOL_DETAILS=1`), so you can tell classifier blocks from permission-rule blocks in your traces. If you run auto mode at any scale, wire that into your dashboards. A classifier you can't audit is just vibes with extra steps. ## Fork subagents are now default everywhere Fork subagents (`subagent_type: "fork"`) were already on in the terminal. v2.1.302 turns them on by default in `claude -p`, the Agent SDK, the desktop app and VS Code. `CLAUDE_CODE_FORK_SUBAGENT=0` turns them off, and `claude mcp serve` never offers them. Two companion changes: - The desktop app and VS Code now always run the main conversation's subagents in the background, as the terminal does, rather than letting Claude choose. - A subagent's own Agent calls in `claude -p`, the SDK, the desktop app and VS Code now run in the foreground by default. If you have SDK scripts that assumed a particular subagent shape, re-run them. Behavior that changes silently on upgrade is exactly what breaks a nightly job. Also note a related default: `claude -p` and SDK sessions with no permission mode now start in `default` mode on third-party providers, with telemetry off, or on a fresh install. `--permission-mode auto` keeps auto. If a script relied on the old starting mode on Bedrock or Vertex, say so explicitly. ## Hooks: a concurrency cap Prompt and agent hooks now run at most 12 of one event at a time; the rest queue. Hooks are where teams encode policy, and prompt/agent hooks are model-backed, so they're slow and cost money. A cap prevents a burst of tool calls from spawning an unbounded pile of hook agents. It also means a very hook-heavy setup may see added latency. If you run more than a dozen model-backed hooks on one event, you probably have a design problem, but check anyway. ## Smaller quality-of-life items worth knowing - **Model switching**: switching to a model with a smaller context window now has the *previous* model summarize an overlong conversation first. A matching fix stops that from spending usage credits without asking. - **Fable alias fallback**: the `fable` and `best` aliases now retry once on the previous Fable model when the newest isn't available to your organization, instead of erroring. - **Image reads**: the Read tool now refuses image sources over 128 MB rather than loading them into memory. - **Idle compaction toggle**: `/config` gains an Idle compaction row, following [idle compaction in v2.1.299](/posts/claude-code-v2-1-299-mcp-allow-rules-fail-closed-hooks-idle-compaction/). - **Claude Design**: `/design-sync` and `/design-login` now warn that standalone Claude Design (claude.ai/design) closes December 14, 2026. ## What this says about the product Compare this to an IDE-first tool. A retry watchdog with a wait ceiling, a separately pinnable safety classifier, and telemetry that distinguishes classifier blocks from rule blocks are features for software that runs without a human at the keyboard. Nobody builds those for an autocomplete panel. This is the point of terminal-native agents: the interesting engineering is in failure handling, auditability and cost control, not in the chat box. It is also a reminder that autonomy has a maintenance cost. Every one of these defaults can move under you, so pin versions in CI and read changelogs the way you read dependency updates. ## What I couldn't verify I haven't run v2.1.301 or v2.1.302. The changelog lists 37 bug fixes for v2.1.301 and 43 for v2.1.302 along with several features specific to Claude Tag, cloud sessions and the VS Code extension; I covered only the items relevant to local and unattended use. The changelog doesn't give a default for the retry watchdog's wait ceiling or say which model the client-side classifier uses by default. ## Sources - [Claude Code changelog, v2.1.301 and v2.1.302](https://code.claude.com/docs/en/changelog)