Claude Code 2.1.224 Adds Cross-Session Messaging for Parallel Development Workflows

Introduction

Anthropic has added a new coordination layer to Claude Code: independent coding sessions can now send messages directly to one another.

The capability arrived in Claude Code v2.1.224, released on August 7, 2026. Anthropic calls it cross-session messaging.

Instead of manually copying findings between terminal windows, developers can let one Claude Code session tell another that a dependency changed, a migration finished, a bug was fixed, or a decision has been made.

The original AIBase article highlights the feature as a major improvement for developers working on several tasks at once. That description is directionally correct, but Anthropic’s official documentation adds several important details.

Cross-session messaging:

• Requires Claude Code v2.1.224 or later
• Runs on macOS and Linux, including Linux under WSL 2
• Is not available on native Windows
• Exchanges text messages rather than full conversation histories or files
• Uses ListAgents to discover reachable sessions
• Uses SendMessage to deliver a message
• Can work between sessions on the same machine
• Can also reach supported sessions on other machines or Claude Code on the web
• Includes inbound controls for accepting, holding, or refusing messages

As of August 10, the official changelog has already advanced beyond v2.1.224. Version 2.1.225 improved cross-machine initiation, and v2.1.227 is listed as the latest release in Anthropic’s changelog at the time this article was prepared.

The important point is that v2.1.224 introduced the capability, while later releases refine how it behaves.

Claude Code Sessions Can Now Talk to Each Other

Before cross-session messaging, a developer running several Claude Code sessions often became the communication layer between them.

Imagine three terminals:

Session A: Refactor authentication
Session B: Update payments API
Session C: Run migration and integration tests

If Session A changed a shared interface that Session B depended on, the developer had to notice the change and explain it manually.

If Session C finished a long migration, the developer had to check the terminal and report the result to whichever session was waiting.

With cross-session messaging, Claude can pass that information directly.

A simplified workflow becomes:

Session A
  │
  │ "Auth interface changed; use createSessionV2()"
  ▼
Session B

Session C
  │
  │ "Migration finished successfully"
  ▼
Session A

Anthropic’s documentation gives two representative examples.

One session can warn another when a change breaks something the other is building on. A session that settles a question can also send the answer to another session that is blocked on it.

That sounds simple, but it changes how parallel Claude Code workflows can be organized.

Messages Are Text, Not Shared Context

One of the most important technical details is what cross-session messaging does not do.

A message is just a piece of text written by one Claude session and delivered to another.

It does not automatically send:

• The sender’s full conversation history
• Files
• Tool outputs
• Hidden context
• The complete repository state
• Permission approvals

If a developer wants another terminal to continue the same conversation with the same context, Anthropic recommends resuming the session instead.

Cross-session messaging is better suited to short coordination messages such as:

The payments integration now expects `customer_id` instead of `user_id`.
Update your branch before running the full test suite.

or:

The database migration finished successfully.
All 214 integration tests passed.
You can continue with deployment validation.

This design keeps messaging lightweight.

It also reduces the risk that one session silently receives a large amount of unrelated context from another.

Claude Uses ListAgents and SendMessage

Developers do not normally call the messaging tools directly.

Claude Code uses two internal tools:

• ListAgents
• SendMessage

ListAgents lets Claude discover which supported sessions it can currently reach.

SendMessage delivers a text message to one of those sessions.

A developer can simply ask Claude in natural language.

For example:

Ask the session running in my other terminal whether the migration finished.

Claude discovers the relevant session and writes the actual message.

Another example:

Explain the authentication changes we just made to the session working on the payments API.

The developer does not need to manually compose a machine-readable message or pass a session ID into a low-level API.

That keeps the interaction consistent with normal Claude Code usage.

Four Main Use Cases Highlighted by Anthropic

Anthropic’s documentation identifies several situations where cross-session messaging is especially useful.

1. Hand Off a Finding

A session may discover something another session needs.

Examples include:

• A breaking API change
• A database constraint
• A dependency version requirement
• A new implementation decision
• A root cause found during debugging
• A test failure caused by another module

Without messaging, the developer becomes the relay.

With messaging, the session can summarize the finding and send it directly.

Example:

Session A finds:
"The OAuth callback now requires PKCE verification."

Session A sends to Session B:
"The auth implementation now requires PKCE.
Please update the mobile callback flow before merging."

This is useful when several sessions are working on related parts of the same project.

2. Coordinate Parallel Git Worktrees

Git worktrees are a natural match for cross-session messaging.

A developer can create separate worktrees for independent tasks and run a Claude Code session in each one.

For example:

repo/
├── main
├── worktree-auth
├── worktree-payments
└── worktree-tests

Each worktree can progress independently.

When one session changes something that affects another branch, Claude can notify the relevant session.

This reduces one of the common risks of parallel development: multiple branches moving forward based on outdated assumptions.

Cross-session messaging does not merge code automatically.

It helps the agents coordinate before the human reaches the merge stage.

3. Get Status From Long-Running Work

Some coding tasks take much longer than a normal interactive turn.

Examples include:

• Large migrations
• Full integration-test suites
• Long builds
• Static analysis
• Large refactors
• Repository-wide code generation
• Dependency upgrades

A developer may leave one session running while working in another.

Cross-session messaging lets the long-running worker report back.

For example:

Session A:
Run the full migration and test suite.
Send the result to the architecture session when finished.

The developer can continue working elsewhere instead of repeatedly checking the long-running terminal.

4. Communicate Across Machines

Anthropic also supports messaging beyond sessions on the same computer.

Supported workflows can include:

• Another Claude Code session on one of your machines
• Claude Code on the web
• Remote Control-connected sessions

There is an important version detail.

Claude Code v2.1.224 introduced cross-session messaging and included cross-machine support, but Anthropic’s current documentation says that starting a new conversation with a session on another machine by name requires v2.1.225 or later.

Before v2.1.225, a session could reply to a message that had arrived from another machine, but initiating the cross-machine conversation was more limited.

For developers who want the most complete behavior, updating beyond 2.1.224 is therefore recommended.

Same-Machine Messages Stay Local

Cross-session messaging uses different delivery paths depending on where the receiving session runs.

Anthropic documents the following behavior:

Destination	Delivery Path
Another session on the same machine	Per-session local socket
Session on another machine	Through Anthropic servers and Remote Control infrastructure
Claude Code on the web	Through Anthropic servers to the cloud session

The same-machine case is especially notable.

Anthropic says messages between local sessions travel through a per-session socket and do not pass through Anthropic servers.

Each supported session registers itself locally and creates an inbox socket.

Other sessions discover it through local session information.

This also creates a filesystem boundary.

If two Claude Code sessions cannot see the same session-registration files, they may not be able to discover each other.

For example, a session running inside a container and a session running directly on the host normally have separate filesystems.

Two sessions inside the same container can still message one another if the feature is available there.

How Incoming Messages Are Delivered

An incoming message does not interrupt a tool that is already running.

Anthropic says the receiving Claude reads the message between tool calls during an active turn.

If the session is idle, Claude Code can start a new turn with the incoming message.

Depending on configuration, a message can end in one of three states:

Result	Meaning
Delivered	The message is passed to the receiving Claude
Held	The message waits for approval or a later settings change
Refused	The message is dropped

This matters because cross-session communication is not an unlimited remote-control channel.

The receiving session has its own security and permission state.

One Session Cannot Approve Permissions for Another

Anthropic deliberately limits what incoming messages can do.

A message from another session cannot count as user consent.

That means another Claude session cannot use messaging to approve a dangerous action that is waiting for permission.

For example:

Session A:
"Approve the shell command waiting in Session B."

That message does not become an approval.

The user still controls the relevant permission decision.

Anthropic also says an incoming message cannot instruct the receiving Claude to change key configuration such as:

• Permission settings
• CLAUDE.md
• Other protected configuration

Commands embedded in message text are also treated as plain text.

For example:

/compact

does not execute automatically just because another session sent it.

These constraints are important because direct agent-to-agent communication can otherwise create unintended permission chains.

Inbound Messaging Can Be Controlled

Claude Code includes a crossSessionInbound setting for controlling how a session handles messages from other independent sessions.

Supported values are:

Value	Behavior
accept	Deliver incoming messages
hold	Hold messages without delivering them until allowed
refuse	Drop incoming messages

A configuration can therefore explicitly allow messages:

{
  "crossSessionInbound": "accept"
}

or hold them:

{
  "crossSessionInbound": "hold"
}

or refuse them:

{
  "crossSessionInbound": "refuse"
}

Anthropic also applies default behavior based on the permission modes of the sending and receiving sessions.

In higher-risk configurations, an incoming message may require explicit approval.

This prevents two sessions with different permission profiles from automatically creating an unsafe escalation path.

Held Messages Can Expire

When an incoming message is held for approval, Claude Code can display an approval dialog showing:

• The sender
• A preview of the message

The user can approve or deny it.

Anthropic’s documentation says the default approval deadline is five minutes.

If the message is not approved before the configured dialogExpiry, it can be dropped.

Claude Code also limits the number of held messages, preventing a session from accumulating an unlimited backlog.

Version 2.1.225 fixed several cases where held cross-session messages could remain parked without the expected notice or expiry in headless sessions.

That is another reason to avoid treating v2.1.224 as the final implementation simply because it introduced the feature.

Availability Requirements

Cross-session messaging has specific platform and provider requirements.

According to Anthropic’s current documentation:

Supported Operating Systems

• macOS
• Linux
• Linux inside WSL 2

Not Supported

• Native Windows

This distinction matters.

Claude Code itself supports Windows, but the cross-session messaging feature is not currently offered on native Windows.

Provider Restrictions

Anthropic says cross-session messaging is not available when Claude Code is running through several external provider paths, including:

• Amazon Bedrock
• Claude Platform on AWS
• Google Cloud’s Agent Platform
• Microsoft Foundry

Availability can also depend on feature-flag evaluation and environment settings.

For that reason, developers should verify the feature in the actual environment they intend to use.

How to Check Your Claude Code Version

Anthropic’s official changelog recommends checking the installed version with:

claude --version

Cross-session messaging requires:

Claude Code 2.1.224 or later

Because subsequent releases contain fixes and cross-machine improvements, using the current supported release is generally preferable to pinning specifically to v2.1.224 unless an organization has a controlled deployment policy.

How to Update Claude Code

For the native Claude Code installation, Anthropic supports:

claude update

Native installations normally check for updates and install them in the background.

The new version takes effect the next time Claude Code starts.

Anthropic also documents:

claude doctor

for checking installation and update status.

Package-manager installations can require separate update commands.

For example, Homebrew installations can be updated with:

brew upgrade claude-code

or, when tracking the latest channel:

brew upgrade claude-code@latest

The exact update method depends on how Claude Code was installed.

Example: Two Sessions Working on Related Features

Imagine a developer is building an application with two related tasks.

Terminal 1

Goal:
Refactor the authentication service and update session creation.

Terminal 2

Goal:
Update the payments API to use the new authenticated user object.

Terminal 1 discovers that the interface changed from:

createSession(userId)

to:

createSession({ userId, organizationId })

Instead of waiting for the developer to notice, Terminal 1 can send a message to the other session explaining the change.

The receiving session can then update its own work before completing the payments implementation.

This is exactly the kind of small coordination event that becomes expensive when many AI coding sessions are running independently.

Example: Parallel Investigation

Cross-session messaging is also useful for debugging.

A developer might run three sessions:

Session A:
Investigate the API error.

Session B:
Inspect database logs.

Session C:
Check the last deployment and configuration changes.

Suppose Session B finds that database connections began failing immediately after a credential rotation.

It can notify the other sessions.

Session A no longer needs to keep investigating unrelated request parsing.

Session C can focus on whether the deployment picked up the new secret.

The system does not automatically create a fully managed multi-agent team.

The developer still starts and steers independent sessions.

Messaging simply reduces the cost of moving useful findings between them.

Cross-Session Messaging Is Not the Same as Agent Teams

Claude Code now has several ways to work with multiple agents or sessions.

They solve different problems.

Feature	Best For
Cross-session messaging	Independent sessions you start and steer yourself
Resume	Continuing the same conversation and its context
Agent teams	Coordinated agents Claude spawns and supervises
Agent view	Monitoring and steering many sessions from one place
Remote Control	Controlling a session yourself from another device
Channels	Sending external events such as CI or chat messages into a session

This distinction matters because “multiple Claude instances talking to one another” can describe several different architectures.

Cross-session messaging is specifically the lightweight communication layer between independent Claude Code sessions.

What the Feature Changes for Large Projects

The AIBase article argues that the update can reduce the manual coordination burden in large projects.

That is the most important practical implication.

A developer can divide a project into several independent workstreams:

Authentication
Payments
Frontend
Database migration
Testing
Documentation

Each session can focus on one area.

When a decision or change affects another area, the relevant information can move directly between sessions.

This can reduce:

• Copy-pasting between terminals
• Repeated explanations
• Delayed dependency warnings
• Duplicate investigation
• Constant status checking

It does not eliminate integration work.

Independent sessions can still:

• Make conflicting edits
• Misunderstand a message
• Use stale repository state
• Reach different technical conclusions
• Pass incorrect findings to another session

The developer still needs testing, code review, version control, and appropriate permission boundaries.

Best Practices for Cross-Session Messaging

For practical use, a few habits can make the feature more reliable.

Keep Messages Focused

A useful message should state:

• What changed
• Why it matters
• Which component is affected
• What the other session should verify

For example:

The database migration renamed `billing_customer_id` to `customer_id`.
Your branch still references the old field in two queries.
Please update those queries before running integration tests.

This is better than:

I changed some database stuff. Check it.

Do Not Treat Messages as Shared Memory

The receiving session does not inherit the sender’s entire reasoning process.

If the finding depends on a file, commit, log, or test result, identify it clearly.

Use Worktrees for Parallel Code Changes

When several sessions are actively editing the same repository, isolated Git worktrees can reduce file conflicts.

Cross-session messaging can coordinate the branches, while Git still handles code history and merging.

Keep Human Approval for High-Risk Actions

Agent-to-agent messaging is useful for coordination.

It should not become a way to bypass:

• Deployment approval
• Production access controls
• Destructive commands
• Security review
• Financial operations

Anthropic’s permission design already prevents one message from becoming user approval. Teams should preserve that separation in their broader workflow.

Update Beyond the Minimum Version

v2.1.224 introduced the feature, but later releases fixed message-handling behavior and improved cross-machine communication.

Unless an enterprise deployment requires a pinned build, the latest supported release is the safer baseline.

常见问题

What is Claude Code cross-session messaging?

Cross-session messaging lets one independent Claude Code session send a text message to another. It is intended for coordination between sessions working in parallel, such as handing off findings, reporting task status, or warning another session about a breaking change.

Which Claude Code version introduced cross-session messaging?

The feature was introduced in Claude Code v2.1.224, released on August 7, 2026. Anthropic’s current documentation requires v2.1.224 or later.

Does cross-session messaging share the full Claude conversation?

No. The receiving session gets the message text, sender identity, and normally a reply address—not the sender’s conversation history or files. Use session resume if you need to continue the full conversation context.

Can Claude Code sessions message each other across computers?

Yes, supported sessions can communicate across machines through Anthropic’s Remote Control infrastructure. Anthropic notes that initiating a new conversation with a session on another machine by name requires v2.1.225 or later; v2.1.224 had more limited cross-machine behavior.

Does cross-session messaging work on Windows?

It works on macOS and Linux, including Linux under WSL 2. Anthropic’s current documentation says the feature is not available on native Windows.

Are same-machine messages sent through Anthropic servers?

No. Anthropic says messages between sessions on the same machine use a per-session local socket and do not pass through Anthropic servers.

Can one Claude session approve a permission request for another?

No. An incoming cross-session message never counts as user consent. It also cannot force another session to change protected permission or configuration settings.

How do I update Claude Code?

For native installations, run claude update, then restart Claude Code. You can check the installed build with claude --version and diagnose update status with claude doctor.

相关工具

• Claude Code: Anthropic’s agentic coding environment for repository exploration, implementation, debugging, testing, and longer-running software tasks.
• Claude Code Cross-Session Messaging: Anthropic’s official guide to session discovery, delivery, cross-machine messaging, inbound controls, and limitations.
• Claude Code Agent Teams: Anthropic’s coordinated multi-agent workflow for tasks where Claude should spawn and supervise a team.
• Git Worktree: Git’s official mechanism for maintaining multiple working trees from one repository, useful for parallel Claude Code sessions.
• Claude Code Remote Control: Anthropic’s feature for steering a Claude Code session from another device.
• Claude Code Changelog: The official version history for Claude Code features, fixes, and release dates.

Related Links

• Cross-Session Messaging Documentation: The authoritative description of how sessions discover and message one another.
• Claude Code Changelog: Confirms that v2.1.224 was released on August 7, 2026 and added cross-session SendMessage.
• Claude Code Setup and Updates: Official installation, update-channel, package-manager, and claude update guidance.
• Claude Code CLI Reference: Official reference for commands such as claude, claude update, claude install, and claude agents.
• Claude Code Settings: Official settings reference, including configuration and organization-level controls.
• Git Worktree Documentation: Git’s official guide to creating isolated working trees for parallel development.
• Claude Code Documentation: Anthropic’s main documentation hub for Claude Code workflows and features.

Summary

Claude Code v2.1.224 introduced cross-session messaging, allowing independent Claude Code sessions to discover and send text messages to one another. The feature is designed for parallel work: handing off findings, coordinating worktrees, receiving updates from long-running tasks, and reducing the need for developers to manually relay information between terminals.

The implementation is intentionally limited. Messages do not contain full conversation history or files, one session cannot approve permissions for another, and inbound messages can be accepted, held, or refused. Same-machine messages stay local through per-session sockets.

Later releases already refine the original feature. In particular, v2.1.225 improves cross-machine initiation and fixes message-handling cases in headless sessions.

The real upgrade is not simply that two Claude windows can “chat”—it is that independent coding agents can now coordinate their work without making the developer act as the message bus between every parallel task.