Release notes
You can now use your mouse to click through fullscreen menus, comply with corporate startup rules effortlessly, and enjoy new settings tailored for assistive tools and Vim users. If you are accustomed to the Vim editor, you can now map two-key combinations like jj to act as the Escape key for exiting insert mode. For users relying on accessibility tools, the new screen reader mode (a setting that renders the terminal interface as plain text so screen reading software can parse it) can be enabled via a command flag, an environment variable, or your settings file. For enterprise environments, the system now honors a process wrapper (an interceptor program that applies corporate rules before the actual application starts), ensuring every background task launch runs through your company's required launcher. It's like upgrading a vehicle's dashboard with more versatile controls—whether you prefer a standard steering wheel, a joystick, or specialized accessibility pedals, you can now drive exactly the way you want.
You no longer have to manually toggle fast mode back on every time you switch between different AI models. Fast mode (an operational state that trades a tiny bit of precision for blazing-fast response generation) is a great setting for saving wait time. Previously, if you had this mode enabled in your settings but temporarily switched to a model that didn't support it, the system would understandably turn it off. However, the frustrating part was that when you switched back to a supported model, the system would forget your preference and leave it disabled, forcing you to manually turn it back on. This amnesia has been fixed: as long as it is enabled in your settings, fast mode will now automatically restore itself the moment you select a compatible model. It is exactly like a car's sport mode—it might turn off automatically when you detour onto a rugged dirt road, but now, the moment you steer back onto the smooth highway, the car remembers your preference and kicks sport mode back on without you lifting a finger.
Your typed replies and ongoing tasks handed off to background agents will no longer vanish into thin air just because of a connection hiccup. A background agent (an AI assistant running long tasks silently out of sight) can sometimes fail to receive a message if the network drops. Previously, any carefully crafted reply you typed during such a failure would simply evaporate; now, the system securely saves your text and automatically delivers it as soon as the session restarts. Additionally, if the system auto-updated and replaced its underlying binary files while you had a session running, the background daemon (a hidden, always-running service that keeps things operating behind the scenes) used to panic, throwing a "Couldn't start" error and permanently locking you out of your session. This temporary disconnect is no longer a fatal error. It is like sliding a note under a coworker's door while they work in the next room: if the door was stuck, the note used to blow away, but now it waits safely on the mat. And even if the building management replaces the front door locks overnight, the coworker inside won't be permanently trapped in their office anymore.
You will no longer suffer a heart attack from a false "capacity full" warning when resuming a massive conversation right after a system update. The total amount of information an AI model can hold in its active memory during a single chat is called the context window (think of it as the model's short-term working memory). Previously, whenever the command-line interface finished a background auto-update, this capacity ceiling would briefly glitch and reset to an older, smaller 200k limit. If you were in the middle of a massive, long-context session, reconnecting would trigger a false red alert screaming "100% context used". This bug even caused the auto-compact indicator (a feature that condenses older chat history into a summary to free up space when you near the limit) to light up erratically. Both of these dashboard gauges have now been fixed and will hold their correct readings across updates. It is like driving a long-haul truck equipped with an extended fuel tank; previously, a quick pit stop for a software patch would make the dashboard glitch and measure your fuel against a tiny sedan's tank, terrifying you into thinking you were running on empty. Now, the fuel gauge reads your massive tank accurately at all times, no matter how many updates run in the background.
Your long-running tasks will no longer spectacularly crash just because a web server unexpectedly decided to close its connection. During routine network communications, servers sometimes need to perform maintenance or clean up connections, doing so by sending a GOAWAY signal (literally a farewell message declaring that the current line is shutting down) via HTTP/2 (a modern network protocol designed for more efficient data transfer). Previously, if your supervised tasks or background sessions happened to be mid-request when this sudden farewell arrived, the entire session would panic and crash on the spot, unable to handle the abrupt cutoff. The system has now been reinforced to understand this signal properly; it treats the closure as a manageable, recoverable disconnect rather than a fatal error. It is like talking to a customer service agent on the phone—previously, if the agent suddenly said, "Sorry, this line is undergoing maintenance," and hung up, the physical paperwork you were filling out would spontaneously combust in your hands. Now, you simply put the phone down, redial a different line, and continue filling out your forms completely undisturbed.
When you pipe Claude's output into other automated programs, you will no longer receive corrupted data fragments, nor will the system grossly misread your large configuration numbers. If you asked the system to output in stream-json (a format that streams data out piece by piece so other programs can consume it on the fly), massive responses used to get arbitrarily chopped off mid-pipe, leaving you with missing result messages and mangled data. Another hidden trap occurred when you set environment variables to limit output length: if you used scientific notation out of convenience (like typing 1e6 to mean one million), the system used to be notoriously bad at math. It would blindly read only the mantissa (the significant digit before the exponent e, which is just 1), silently shrinking your "one million" token allowance down to a microscopic "1". The data pipes have now been reinforced to deliver gigantic payloads fully intact, and the system finally understands scientific notation correctly. It's like hiring a courier to deliver a long model train: previously, they would drop half the carriages on the highway, and if you wrote "10 to the power of 6" grams on the manifest, the clerk would only read the "1" and charge you for a feather. Now, the entire train arrives flawlessly, and the shipping clerk finally knows how to read math.
Your computer will no longer freeze from memory exhaustion when Claude generates massive tables. Previously, if a Markdown (a lightweight formatting syntax for plain text) table exceeded 200 rows, the system would attempt to render the entire thing at once, stalling the display and devouring memory. Now, it smartly shows only the first 200 rows and appends a helpful "… N more rows" notice at the bottom. It is like opening a massive phone directory to the first page for you to read, rather than trying to physically unfold thousands of pages all at once to cram onto your small desk.
Your file processing tools now explain their failures accurately instead of throwing confusing or misleading errors. Previously, the Edit tool would flat-out refuse to modify a file if it had been altered after reading, even if your target text was still a unique match; now it safely edits it as long as the match holds. The other tools have also stopped bluffing: Read no longer misreports completely empty files as "shorter than offset" (a number specifying where to start reading), Grep won't silently lie that "No files found" when you feed it invalid regex patterns (a syntax using special characters to search for text patterns), and it correctly tallies the total in paginated (split across multiple pages) mode instead of under-reporting. Furthermore, Glob (a tool for matching file paths) will no longer crash with a cryptic error if the pattern, path, or working directory happens to contain a null byte (a special hidden zero-value character used by programs to mark the end of a string). It is like a librarian who finally learned to communicate properly: instead of claiming "you looked too far" when a shelf is simply empty, or shrugging "no such book" when you mispronounced the title rules, they now point out the exact issue.
You will finally see the real root causes of connection issues instead of chasing misleading ghosts. Previously, if the apiKeyHelper (a helper script that fetches your API key) failed, the system would silently retry about ten times before shrugging with a generic 401 (the standard HTTP code for unauthorized access); it now surfaces the script's actual error within three attempts. Furthermore, if your AWS Bedrock streaming requests (the connection method where the AI streams its answer word-by-word) were altered mid-flight by a corporate gateway (a network node that forwards traffic between services), it used to spit out a completely misleading "Truncated event message received" error. Now, it accurately identifies the content-type (a label indicating the format of network data) that went wrong and correctly points the finger at the proxy (the intermediary server handling your requests). It is like visiting the doctor and finally seeing the actual X-ray showing the exact fractured bone, rather than the receptionist just turning you away with a vague "you are not feeling well" note.
Your background automations and internal processes are now highly resilient and will no longer halt or spam you over minor hiccups. First, if your browser fails to open, typing /upgrade (the command to upgrade the system) now simply prints the upgrade URL instead of bizarrely throwing you back to a login screen. For Windows developers, processing stream-json (a format for programs to consume JSON data in small chunks) is now immune to completely crashing the session just because it encountered a blank line with CRLF (Carriage Return Line Feed, the two hidden characters Windows uses for line breaks). Furthermore, headless (running purely in the background without a visual interface) sessions will no longer hang permanently if a control request contains a malformed set_model (an internal directive used to switch the AI model) payload; the CLI now cleanly answers with an error. Finally, when you resume your work, any orphaned background tasks (leftover tasks abandoned after an interruption) will quietly collapse into a single clean summary rather than endlessly spamming "No completion record was found." It is like a train's autopilot receiving a massive upgrade: it no longer slams the emergency brakes just because a single leaf fell on the tracks or it received a slightly garbled radio signal, keeping your journey smooth and uninterrupted.
Remote connections and AI team collaborations are now instantly synchronized and communicative. Previously, when your Remote Control clients (the mobile or web interfaces you use to connect back to your host) attached to a terminal-hosted session (the core process running directly in your computer's black terminal window), you were kept completely blind to background agents and workflow progress until a task either started or stopped to trigger an update; it now synchronizes the exact state the moment you connect. Additionally, when using the Agent tool (the function used to summon helper AIs), if a subagent's (a subordinate AI called upon to handle specific tasks) tools list (a catalog telling the AI what commands it can use) resolved to entirely unrecognized garbage, the system would bizarrely launch it anyway with an entirely empty toolbox. Now, it smartly halts and returns a clear error explicitly naming the entries it couldn't recognize. It is like a boss calling the office while traveling and instantly getting a full status board, instead of awkward silence until someone finishes a job; and when that boss hands a new worker a list of requested tools that don't exist, the worker immediately speaks up saying "I can't find these wrenches," instead of showing up to the construction site empty-handed and standing around doing nothing.
Several annoying interface quirks have been squashed so the system no longer feeds you outdated maps. First, typing /usage (the command to check your token usage) will no longer paste stale cached bars (old graph data the system kept around to save effort) over your fresh API data; and if you edit settings in /mcp (the command to manage server connections), the system will properly reclassify placeholder servers (names keeping a reserved spot in the config file) instead of treating them as dead ends forever. If you are using SDK hosts (outer shell programs like Claude Desktop that run the AI), you can now successfully use the "Change directory" option during idle sessions (when you aren't actively prompting the AI), even if a background task is running, instead of getting a stubborn "A turn is in progress" rejection. The workflow save dialog will now correctly point to your CLAUDE_CONFIG_DIR (your specified primary configuration directory) instead of hardcoding a default path. Lastly, if you expand "Show all" in /release-notes (the command to read updates), the system will no longer aggressively inject the entire massive changelog (the update history) into the model's context (the AI's short-term memory limit), which previously bloated every single subsequent request you made. It is like a car navigation system that finally uses live traffic instead of yesterday's maps, allows you to change the radio station while waiting at a red light, and stops forcefully taping the entire vehicle owner's manual to your windshield.
When you keep Claude running for extended conversations or massive file processing, it will no longer gradually slow down or devour your system memory. Previously, several memory leaks plagued long sessions: pasted images in the agent view (the interface showing the AI's working state) would remain in memory for the screen's lifetime; MCP (Model Context Protocol, the standard for connecting models to external tools) servers would accumulate up to 64 MB of stderr (standard error output) per server; LSP (Language Server Protocol, the standard providing features like autocomplete) documents would stay open indefinitely (now capped at 50); and headless (operating without a visual interface) or SDK (Software Development Kit) sessions would grow unboundedly from large tool-result payloads. Additionally, async hook (code triggered by specific events) outputs were retained after backgrounding, and SDK sessions could lose initialized agents if a plugin (an add-on extending capabilities) refreshed before the client attached. Now, these issues are fixed: images are released after sending, and strict boundaries are set for various records. Furthermore, if you have many permission deny or ask rules, the system now pre-compiles and caches them, preventing multi-second delays per turn. When reading files with extremely long single lines using offset/limit (parameters specifying the start and end of a read), it now returns a clean error instead of blowing up memory by loading the entire line. It is like an office where workers used to indefinitely pile every read document and received fax on their desks until they could barely turn around; now they file or shred things immediately, keeping the workspace perpetually clear.
When you load up on tools or perform extensive file edits, the interface will now feel much snappier while consuming significantly fewer computer resources. Previously, when the agent updated the task list, it blindly re-rendered the entire UI (user interface), making typing feel sluggish; now it only redraws what actually changed. If you use many MCP (Model Context Protocol, the standard for external tool connections) tools, the system now caches the assembly of the tool-pool (the collection of tools available for the model to choose), speeding up tool rounds by up to seven times. For memory management, the file edit read cache is now strictly capped at 16 MB, rather than pinning up to 1,000 full files in memory. The system also actively prunes superseded file-history backups, significantly shrinking checkpoint (saved conversation state) disk usage and reducing transcript (complete conversation record) sizes by up to 79x in edit-heavy sessions. Additionally, resuming sessions with background agents or forks (independent processes branching off from an existing conversation) spawned from massive conversations now uses far less memory. It is like an auto mechanic who used to unpack and repack his entire toolbox every time he needed a wrench, while hoarding every scrap of replaced metal in the garage; now he keeps essential tools at hand and routinely throws out the scrap, keeping the shop running at peak efficiency.
You can now reliably trace completed background tasks and safely manage parallel working copies without fearing accidental data loss. Previously, background agents (AI assistants working silently behind the scenes) would vanish from the list the moment they finished, leaving you wondering if the job was done; they now stay put in /tasks until you explicitly clean them up. When you attach to a stopped background task, you will no longer stare at a blank "Session is starting" screen while it warms up; it instantly displays the previous conversation transcript (complete conversation record). Regarding daemons (services running quietly in the background), an older daemon will no longer stubbornly force workers (child processes executing tasks) spawned by a newer version to restart on the old binary (executable file). In the Agent view (the interface showing the AI's working state), when using Ctrl+X to delete a worktree (a Git feature that lets you open multiple parallel copies of the same project), it now correctly handles renamed branches and strictly protects your unpushed commits (saved records of code changes) from destruction. If a worktree is kept, its session row remains, and reused worktree names properly reset to the current base. It is like sending an assistant on an errand—they used to vanish upon returning so you never knew if they bought the items, but now they leave the receipt on your desk; and your multiple craft projects spread across different rooms will no longer be thrown in the trash just because someone was sweeping the hallway.
Even when running in auto or bypass modes, the system now accurately intercepts deeply hidden catastrophic commands, shielding your computer from accidental erasure. Previously, if you were in auto mode (fully automatic mode) or running with skip-permissions (a dangerous setting allowing the system to execute commands without asking), devastating commands like rm -rf ~ (which deletes your entire user folder) could slip right through the safety checks if they were wrapped inside command substitution syntax (methods like $(), backticks, or <() that feed one command's output into another). Now, no matter how deeply these dangerous commands are nested, the system extracts them and forces a manual confirmation prompt, matching the behavior of plainly written threats. This does not hinder ordinary automation; it simply closes a critical security loophole. It is like airport security: previously, if a dangerous item was packed inside a set of Russian nesting dolls, the X-ray machine might only check the outer shell and wave it through; with the upgraded scanners, no matter how many boxes you wrap it in, the contraband inside is instantly detected and seized.
You will no longer run into baffling errors or dead ends when managing system settings or checking your usage. First, the system no longer permits /install-github-app or /mcp settings menus to open within a background session (a conversation running invisibly behind the scenes), preventing interactive prompts from triggering where you cannot see them. When your MCP (Model Context Protocol, the standard for connecting models to external tools) server configuration has an empty URL (web address), the /mcp list now politely displays it as "not configured" rather than throwing an alarming config error. When checking your usage, if the endpoint (the server address providing the data) hits a rate-limit (being temporarily blocked by the server due to too many simultaneous requests), /usage now gracefully displays your last successfully fetched bar charts with an "as of" timestamp, instead of slapping you with an error screen. Additionally, if you use AWS SSO to log into Bedrock and your sso_region (the region for single sign-on) differs from your Bedrock service region, the system will no longer falsely block you with a "Session token not found" error, fixing a recent regression. It is like visiting a library: previously, if the computer system was busy when you asked for your checkout history, the clerk would just slam the window shut; now, they pull out the morning's backup ledger to show your status as of then, and they no longer kick you out just because the address on your ID does not match your current zip code.
Original changelog
Original changelogMouse clicks, corporate wrappers, screen reading, and Vim shortcuts
Added screen reader mode: opt-in plain-text rendering for screen reader users. Run `claude --ax-screen-reader`, set CLAUDE_AX_SCREEN_READER=1, or add "axScreenReader": true to settings.
Added `vimInsertModeRemaps` setting: map two-key insert-mode sequences like `jj` to Escape in vim mode
Added `CLAUDE_CODE_PROCESS_WRAPPER`: agent view and the background service now honor a corporate launcher by running every Claude Code self-spawn through a required wrapper executable
Added mouse-click support for multi-select menus and "Other" input rows in fullscreen mode
Original changelogFast mode remembers your setting and restores automatically
Fixed fast mode staying off after switching back to a model that supports it — it now restores automatically when enabled in settings
Original changelogNo more lost replies or permanent lockouts for background agents
Fixed replies typed to a background agent being lost when delivery fails — the text is now saved and delivered when the session restarts
Fixed background-session attach failing permanently ("Couldn't start the background daemon") after an update replaced the binary a running `claude agents` process was launched fromOriginal changelogUpdates no longer trigger false alarms, context gauge stays accurate
Fixed the context window (and auto-compact indicator) briefly resetting to 200k after the CLI auto-updates, causing a false "100% context used" when resuming long-context sessions
Original changelogServer disconnects no longer crash in-flight background tasks
Fixed supervised and background sessions crashing when a server closed an HTTP/2 connection with a GOAWAY while requests were in flight
Original changelogStreaming data arrives intact, and scientific notation is finally understood
Fixed truncated stream-json/JSON output and missing result message when piping large responses from `claude -p`
Fixed `CLAUDE_CODE_MAX_OUTPUT_TOKENS` and similar env vars silently using the mantissa of scientific-notation values (`1e6` became `1`)
Original changelogHuge tables now paginate instead of eating memory
Fixed very large markdown tables stalling rendering or using excessive memory; tables over 200 rows show the first 200 with a "… N more rows" notice
Original changelogFile tools now explain failures instead of bluffing
Fixed the Edit tool failing on files modified after reading when the target text still matches uniquely
Fixed Read reporting empty files as "shorter than offset", Grep silently returning "No files found" for invalid regex patterns, Grep count mode under-reporting totals when paginated, and Glob crashing with an unclear error when the pattern, path, or working directory contained a null byte
Original changelogLogin and Bedrock failures finally show the real cause
Fixed `apiKeyHelper` script failures being hidden behind a generic 401 after ~10 silent retries; the script's own error is now shown within 3 attempts
Fixed Bedrock streaming requests failing with a misleading "Truncated event message received" when a gateway transforms the response — the error now names the content-type and points at the proxy
Original changelogUpgrade, streaming protocol, and background recovery lose their blind spots
Fixed `/upgrade` showing a login flow instead of the upgrade URL when the browser fails to open
Fixed stream-json input killing the session on blank CRLF or whitespace-only lines from Windows-style SDK hosts
Fixed headless stream-json sessions hanging permanently when a `control_request` carried a non-string `set_model` payload; the CLI now answers with an error response
Fixed repeated "No completion record was found" notices on session resume — orphaned background tasks now collapse into a single summary
Original changelogRemote control and subagents can finally see each other
Fixed Remote Control clients attaching to a terminal-hosted session not seeing background agents and workflow progress until a task started or stopped
Fixed the Agent tool launching with no tools when a subagent's `tools` list resolves to nothing — it now returns a clear error naming the unrecognized entries
Original changelogSettings and interfaces catch up with current state
Fixed `/usage` showing stale cached bars over fresher data, and `/mcp` not reclassifying placeholder servers after config edits
Fixed "Change directory" in SDK hosts (e.g. Claude Desktop) failing with "A turn is in progress" on idle sessions that have a running background task
Fixed the workflow save dialog showing `~/.claude/workflows/` instead of the `CLAUDE_CONFIG_DIR` location for user-scope saves
Fixed `/release-notes` adding the viewed notes to the model's context — "Show all" previously injected the entire changelog into every subsequent request
Original changelogLong sessions stop bogging down and leaking memory
Fixed a memory leak in the agent view where pasted images were retained for the screen's lifetime after sending peek replies
Fixed SDK sessions losing agents defined via the initialize request when a plugin refresh ran before the client attached
Fixed several memory leaks in long sessions: MCP stdio server stderr accumulating up to 64 MB per server, LSP documents staying open indefinitely (now LRU with 50-doc cap), async hook output retained after backgrounding, and unbounded growth in headless/SDK sessions from large tool-result payloads
Fixed a memory blowup when reading files with extremely long single lines using offset/limit — the read now returns a clean error instead of loading the whole line
Fixed multi-second per-turn slowdowns in sessions with many permission deny/ask rules — rule matchers are now compiled once and cached
Original changelogSmoother UI and lighter memory footprints with massive toolsets
Improved input responsiveness while agent task lists update — task updates no longer re-render the entire UI
Reduced per-tool-call CPU overhead in print/SDK sessions with many MCP tools by caching tool-pool assembly (up to 7x faster tool rounds at high tool counts)
Reduced memory usage by bounding the file edit read cache to 16 MB instead of pinning up to 1,000 full files
Reduced session transcript size (up to 79x in edit-heavy sessions) and bounded checkpoint disk usage by pruning superseded file-history backups
Reduced memory usage when resuming sessions with background agents or forks spawned from large conversations
Original changelogBackground tasks stick around, and Git worktrees are protected
Completed background agents now stay listed in `/tasks` until cleanup instead of vanishing the moment they finish
Attaching to a stopped background agent now shows its transcript immediately while the session warms up, instead of a blank "Session is starting" screen
Background sessions: an older daemon no longer silently restarts workers spawned by a newer version onto the older binary
Agent view: Ctrl+X now deletes renamed-branch worktrees, never destroys unpushed commits, keeps the session row when a worktree is kept, and reused worktree names reset to the current base
Original changelogSneaky catastrophic commands can no longer bypass safety checks
Catastrophic removals (e.g. `rm -rf ~`) in commands containing `$(…)`/backticks/`<(…)` now prompt in `--dangerously-skip-permissions` and auto mode, matching the plain form
Original changelogSetting menus stay put, and usage/Bedrock flows get smarter
`/install-github-app` and the `/mcp` settings menu no longer open in background sessions
MCP servers configured with an empty URL now show as "not configured" in `/mcp` instead of a config error
`/usage` now shows your last-known usage bars with an "as of" note when the usage endpoint is rate-limited, instead of an error screen
Fixed Bedrock auth failing with "Session token not found or invalid" for AWS SSO profiles whose sso_region differs from the Bedrock region (2.1.207 regression)