Claude Code New Features Deep Dive: Remote Control, Multi-Agent Parallelism, and Auto Memory

At a recent Anthropic tech talk held in London, Ralph from the Anthropic engineering team gave a systematic walkthrough of a series of new features densely packed into Claude Code over the past few months. In his own words, covering every update would require a seven-hour marathon session. This article distills the most practically valuable features across two categories — developer experience improvements and autonomy enhancements — to help you quickly get up to speed on the latest direction of this AI coding tool.

Background: Claude Code and the Generational Gap in AI Coding Tools Claude Code is Anthropic's AI coding assistant launched in 2025, built on the Claude large language model and primarily running as a command-line interface (CLI) deeply integrated into developers' terminal workflows. Unlike GitHub Copilot, Cursor, and similar tools, Claude Code's core design philosophy is "Agentic Programming" — it doesn't just complete code, it can autonomously execute terminal commands, read and write files, call tools, and complete complex programming tasks spanning multiple steps. Anthropic positions it as an "AI software engineer" rather than a mere code completion tool, and this positioning difference is the starting point for every feature in this update cycle.

Developer Experience: Making the Tool Feel Natural

Anthropic repeatedly emphasizes that while Claude can handle a lot of work independently, the daily interaction experience developers have with the tool is equally critical. The goal of updates in this category is to make Claude Code more convenient and fluid to use.

Remote Control: Take Over Your Coding Session Anytime, Anywhere

Remote Control is a feature that was clearly underappreciated during the live demo — when Ralph asked how many people in the audience had used it, only a handful raised their hands. Its core value: you can start a session on your computer, then take over and continue from your phone app or any browser at any time.

Setup is incredibly simple — just type remote control and press Enter, and the session instantly syncs to the web and mobile interfaces. You can then go walk the dog, run errands, or step away from your desk, and Claude will push a notification through the app whenever it needs input. Ralph also shared a practical tip: configure remote control to be always-on by default in settings.json, so every session is remotely accessible at any time.

This feature reflects a broader macro trend: the "asynchronous programming paradigm." Traditional programming workflows require developers to maintain continuous attention at their IDE or terminal; as AI agent capabilities grow, more and more tasks can be "delegated and walked away from." This shares a philosophical root with the rise of message queues and event-driven architectures in system design — decoupling producers from consumers and letting work proceed asynchronously. Remote Control in Claude Code essentially turns "human attention" into an asynchronously schedulable resource, and this is the core concept threading through all the autonomy updates in this release.

Flicker-Free Fullscreen Mode

Developers who spend a lot of time in the terminal know this annoyance: when the terminal scroll history gets long, appending new content can trigger a full terminal redraw, causing noticeable flickering. Claude Code's new fullscreen mode solves this by virtualizing the entire terminal scroll region — only rendering what's currently visible, keeping memory usage stable even in very long sessions.

Enable it using the /tui command with the full screen parameter. Virtualization also brings bonus benefits: clickable elements now appear in the terminal, like buttons to expand text or jump to the bottom of a conversation, bringing the interaction experience closer to a GUI.

This approach borrows mature concepts from frontend frameworks — "Virtual DOM" and "Virtual List" — rendering only the rows visible in the current viewport and dynamically mounting/unmounting nodes during scrolling, rather than preserving the full rendered history. Frontend frameworks like React and terminal UI libraries like Ink and Blessed have long used similar techniques. The root cause of terminal "flickering" lies in the traditional terminal's full-repaint mechanism: every time content updates, the entire visible area needs to be recalculated and rerendered. Virtualized rendering reduces complexity from O(n) to O(viewport height), fundamentally eliminating the performance bottleneck.

A Completely Redesigned Desktop App

Ralph openly admitted that the Claude Code desktop app from a few months ago wasn't appealing — many people, including himself, preferred the CLI. But the team has done a complete overhaul. The new version supports grouping sessions by project (GitHub repository), making it easy to manage large numbers of parallel sessions; you can view implementation steps generated in Plan mode and add comments directly on the plan as feedback to Claude; view code diffs and add line-by-line annotations requesting explanations; and it integrates with GitHub workflows. For certain task scenarios, the desktop app experience is noticeably better than pure command line.

Autonomy: Getting Claude to Interrupt You Less

Every feature in this section addresses the same pain point: you kick off a session that should run autonomously for a long time, come back, and find Claude stuck waiting on some permission request or an insignificant confirmation. As model capabilities improve, Claude has gotten better at judging when it truly needs your intervention.

Auto Mode: Intelligently Deciding When Authorization Is Needed

Auto Mode is a new operating mode specifically designed to solve the "frequent permission interruptions" problem. It works by introducing a classifier that performs two checks on every operation that would normally require stopping to ask for permission:

• Is it destructive? Would this action cause consequences that are hard to reverse later?
• Does it look like prompt injection? Is there any suspicion of an injection attack in this content?

If both checks pass, Claude executes directly on your behalf. If either check fails, Claude first tries to find an alternative path to work around it; only when it genuinely cannot avoid the issue does it actually come back to request authorization. This mechanism gives Claude more autonomy and aligns with the "asynchronous programming" philosophy mentioned throughout the talk.

The second check — targeting "Prompt Injection" — deserves special explanation, as it's a security threat unique to the large language model era. Attackers embed text disguised as system instructions inside code comments, documentation, web content, or even filenames to trick AI agents into executing malicious operations — for example, sending codebase contents to an external server or silently modifying critical configuration files. This type of attack is especially dangerous for AI agents with tool-calling capabilities, since they can actually carry out these instructions. Anthropic's injection-detection classifier built into Auto Mode is one of the first attempts in the industry to systematically integrate prompt injection defense into an AI coding tool, representing a "Secure by Default" design orientation.

Native Work Tree Support

Work Tree is a long-standing Git feature used to let multiple Claude instances work on the same repository in parallel without interfering with each other — each session operates on an isolated subdirectory copy. Previously, manually managing these temporary directories was quite tedious. Claude Code now provides native support: simply start a session with claude --worktree and Claude will automatically copy the repository to an isolated directory and work within it. The desktop app and other interfaces now have built-in Work Tree options as well. For heavy parallel users, this is an indispensable improvement.

Git Work Tree was introduced in Git 2.5 (2015), allowing multiple working directories to be checked out from the same Git repository, sharing the same .git metadata (including commit history and object store) but each with its own independent working files and current branch. This makes parallel development across different branches possible without cloning multiple repository copies, saving disk space while preserving history integrity. In the Claude Code context, Work Trees provide a natural isolation sandbox for multiple AI agent instances: each agent freely reads and writes within its own work tree, runs tests, without interference, and results are eventually merged through standard Git workflows — a perfect fit for a "parallel agents" architecture.

Auto Memory: No More Starting from Scratch Every Time

Many users complain that starting a new session feels like facing a blank slate, having to repeatedly tell Claude the same background information. Auto Memory automates a solution to this: Claude automatically records your coding style, architectural choices, debugging experiences, and other key information during a session, saves it to a Memory.md file, and loads it alongside claude.md at the start of every new session.

Ralph used a clever analogy to distinguish the two: claude.md is like the operations manual you hand Claude on its first day, while Memory.md is the notes Claude jots down during actual work. Interestingly, Memory.md itself is kept compact — it primarily serves as an index pointing to specific memory files, loaded via progressive discovery to avoid context bloat. All memory files are stored locally only and will not be uploaded to the cloud or GitHub; you can audit them at any time with the /memory command.

The "progressive discovery" loading strategy used by Auto Memory is essentially a lightweight implementation of Retrieval-Augmented Generation (RAG) for personal memory scenarios. Loading all historical memories in full would rapidly bloat the context window, increasing inference costs and potentially diluting information relevant to the current task. By designing Memory.md as an index layer, Claude can retrieve specific memory files on demand when needed — similar to a database's lazy loading mechanism. Anthropic's research suggests that context length and reasoning quality are not linearly correlated; precise retrieval often outperforms piling on large amounts of content.

Code Review and Ultra Review: Multi-Agent Automated Code Review

Code Review is a feature that was battle-tested by Anthropic's internal teams before being productized. Whenever you create a PR, Claude kicks off a multi-agent, multi-stage review process: the first stage dispatches different agents to separately check for errors, bugs, security vulnerabilities, and logic issues; the second stage cross-references these findings against the actual code to verify that conclusions are genuine. Logic flaws that previously might take hours to find can now be located in minutes. It can be triggered automatically via the GitHub App or executed manually with the /ultra-review command.

This multi-agent, multi-stage architecture echoes the classic software engineering principle of "Separation of Concerns": having different agents focus on distinct dimensions like errors, security, and logic, then having a verification layer cross-check the results — essentially automating the best practice of "multi-round review + independent verification" from human code review. The second-stage "verification layer" design is particularly critical — it addresses the large language model "hallucination" problem: AI might confidently report a bug that doesn't actually exist in the code. The two-stage architecture significantly reduces false positive rates by forcing verification against the original code, echoing the "proof-checking" separation philosophy in formal verification.

Routines: Automated Workflows Without Manual Triggering

Routines (still in research preview) allow you to create Claude Code sessions that don't require manual triggering — they can be started by timers, webhooks, or API calls from external systems. It natively supports GitHub but can also connect to any API.

Ralph demonstrated two examples live: one that checks a specified repository for new commits and issues daily and generates a report; another that automatically performs a code review and posts a comment whenever a PR is created. He also improvised by creating an Issue triage Routine in the voice of a "medieval knight" — automatically triggered whenever a new Issue is opened in the repository. Critically, these tasks run in the cloud and continue executing even when your computer is off, truly enabling asynchronous workflows.

The Routines feature marks a paradigm shift in AI coding tools from "reactive" to "proactive." Traditional AI assistants are triggered by human input (Reactive); Routines based on timers, webhooks, and API calls make Claude Code a first-class citizen in event-driven systems — operating at the same abstraction level as Zapier, GitHub Actions, AWS Lambda, and other automation infrastructure. Cloud-based persistent execution means AI agents are beginning to break free from the lifecycle constraints of "terminal sessions," evolving into long-running background services. This has profound implications for team collaboration: an individual's AI agent workflows can be consolidated into shared team automation pipelines, reducing the cost of knowledge transfer and repetitive work.

Agents View: Unified Management of Parallel Sessions

For power users who habitually run large numbers of parallel sessions simultaneously, Agents View provides a unified dashboard to see all sessions by status (waiting for input, completed, needs intervention, etc.). After launching with claude --agents, sessions run in the background without needing to keep a terminal open. You can send a prompt directly to a background session (press the space bar) or drill into a specific session for details. This feature is now in public preview.

Enterprise and Team Improvements

Beyond the features above, Anthropic has also released several capabilities targeted at team and enterprise deployments: improved Windows support, deployment wizards for Google Cloud Platform and AWS, and native binaries installable directly from governance pipelines.

Summary

From Remote Control to multi-agent automated reviews, from Auto Memory to cloud-based Routines, the through-line of this Claude Code update cycle is clear: simultaneously improving everyday interaction experience while continuously expanding AI's autonomous execution capabilities, freeing developers from tedious confirmations and repetitive operations. These features collectively point to a deeper architectural shift — AI coding tools are evolving from "advanced code completers" into "delegatable asynchronous agents," and the relationship between developers and AI is migrating from "real-time collaboration" toward "task delegation + result review." As emphasized at the end of the talk, the continued evolution of these features depends on real-world usage and feedback from users. For those using AI coding tools today, now may be the perfect time to reassess your workflows and embrace the asynchronous programming paradigm.

Key Takeaways