Claude Mods: How to Connect Sessions, Route Tasks, and Visualize Work

Claude Mods can extend Claude Code with cross-session coordination, custom model-routing rules, and visual panels that show observed work. A well-designed mod can help sessions exchange findings, direct suitable tasks to cheaper models, and make a complex workflow easier to supervise.

These capabilities are building blocks. Installing a mod does not automatically create a team, split every task correctly, or guarantee lower costs. The coordination, routing policy, and display must be provided by the mod and the surrounding workflow.

Anthropic announced mods on October 1, 2026. They give users and developers deeper ways to customize the assistant’s environment. This guide explains the practical benefits, who they suit, how to try a sample, and how to judge whether a custom workflow actually helps.

What Are Claude Mods?

A Claude mod is an extension for Claude Code, built with JavaScript or TypeScript functions that respond to events inside the application. Those events can include a submitted prompt, a tool call, or part of the interface being drawn.

Think of a mod as a small piece of software that can participate in how your assistant works. It can display information, adjust an interaction, or return its own result at a particular point.

For example, “show me which branch I am working on” can become a persistent display. “Let me review this action first” can become a targeted interruption in an identified workflow.

Mods are distributed through plugins. A plugin is the package; a mod is one type of functionality it can contain. Anthropic’s plugin documentation explains how instructions, tools, hooks, and mods can ship together.

Three Practical Ways to Use Claude Mods

The most useful way to understand mods is through the workflows they can support: session collaboration, model routing, and visual supervision. These are applications of the framework, not three preset switches. Their usefulness depends on the mod you install or build.

1. Connect Claude Code Sessions and Coordinate Work

Yes: a mod can help two Claude Code sessions send and receive messages while working on a shared objective.

The mods API provides $.session.send for sending messages and events for observing incoming and outgoing messages. Targets can include another of your sessions, a subagent, or an agent-team teammate.

Consider a website update. One session works on an API response while another updates the page that consumes it. When the first changes a field name, it can tell the second what changed. The second can acknowledge the message or flag a dependency before continuing.

The benefit is less manual copying between terminals and fewer decisions made using outdated assumptions. A coordination mod could add a shared-looking status view, standardize handoff messages, or ask another session for a progress update.

An important distinction: Claude Code already has cross-session messaging. A mod can customize a workflow around it; installing a mod is not required simply to message another supported session.

Messages carry plain text. They do not automatically merge session histories, transfer files, or reconcile code changes. Each receiving session retains its own access and inbound-message controls. Reaching sessions beyond the current machine has additional Remote Control and authentication requirements.

To try the underlying messaging before building a mod, identify the target in /list-agents, then ask Claude to send a specific update—for example, ask the session working on the API to confirm the response fields the page should use. Check that it replies with the relevant finding.

For structured coordination, agent teams provide related features such as task sharing and direct teammate communication. They are a separate, currently experimental capability that a mod can complement.

Custom build prompt:

Design a Claude Code mod for coordinating two sessions I explicitly select. Show their assigned work and last acknowledged update. Let each send a concise handoff with a task identifier, finding, dependency, and requested response. Distinguish queued, acknowledged, failed, and unknown delivery states. Prevent repeated message loops. Keep file merging and final approval separate.

Check the result: Send an update and require a reply containing its task identifier. Then test a session that refuses messages. A queued message must not be shown as evidence that the recipient completed the requested work.

2. Route Suitable Tasks to Cheaper Models

A custom mod can apply rules that choose models for delegated work. That makes it possible to reserve more capable, higher-cost models for difficult work while assigning suitable bounded tasks to a cheaper option.

The mods reference documents an agent.spawn hook that can change the model when a subagent or teammate starts. The API also supports separate model requests. These are building blocks for routing; task decomposition and difficulty assessment still need instructions or custom logic.

That hook applies when a worker starts. It does not rerun simply because an existing subagent resumes, so a routing design should not assume that every resumed task will be reassessed automatically.

For example, a proposed website workflow could assign extracting headings from a small file or labeling a short issue to a cheaper model, while keeping architecture decisions and ambiguous debugging with a stronger model. That is a proposed policy, not a benchmark showing which model will succeed on every task.

Choose tasks by bounded scope, clear inputs, and an inexpensive way to check the result. A request that sounds simple can hide difficult dependencies. “Fix the login button” may involve authentication behavior, accessibility, and security-sensitive code.

There are also two different forms of delegation. A standalone model request can return a classification or summary; it is not automatically a worker with tools and the full project context. A configured subagent can perform a larger delegated task. Pick the form that matches the work.

Custom build prompt:

Design a routing mod using capabilities available in my installed Claude Code version. Start with an explicit allowlist of bounded tasks eligible for a cheaper model. Show the chosen model and reason. Keep ambiguous or consequential work with the main model. Define a verification check and a retry or escalation limit. Log actual usage where available; label estimates clearly. Do not claim savings before measurement.

Check the result: Compare representative tasks with the original workflow. Record accepted outputs, verification failures, retries, latency, and total usage. Check what happens when the selected model is unavailable.

The useful measure is cost per accepted result. A cheaper first attempt may cost more overall if it needs several retries and a stronger model to repair it. Extra model calls can also consume a subscription’s usage allowance even when you do not see an itemized API charge.

3. Visualize What Agents Are Doing

Mods can make observed activity visible through panels, status displays, and interactive controls. The interface guide documents panes, buttons, inputs, and other drawing locations; support varies by surface.

A custom supervision panel could show the worker assigned to a task, its selected model, its last observed action, and the latest verification result. That helps the user identify blocked work or inspect a failure without switching repeatedly between conversations.

The key design question is what the display actually knows. A worker saying “complete,” a tool returning successfully, and the requested behavior passing verification are different kinds of evidence.

A useful panel might use the following interpretation:

These are proposed dashboard states, not an included Claude Mods interface. Across separate sessions, each worker would need to supply relevant observations or make them available through an explicit integration. One mod does not automatically gain a complete live view of every other session.

The panel can show actions and reported results. It does not expose hidden model reasoning, and a clean dashboard does not prove the work is correct.

Custom build prompt:

Build a supervision pane for explicitly tracked tasks and workers. Show the task, chosen model, last observed action, dependency, and verification evidence with timestamps. Separate worker-reported completion from verified completion. Mark stale data and disconnected workers. Provide text fallbacks where the visual surface is unavailable. Document activity the mod cannot capture.

Check the result: Disconnect a worker, deny an edit, and change a file after its test passes. The display should show uncertainty, a failed or denied attempt, and stale verification rather than continuing to show an unqualified success.

Worked Example: One Website Update, Several Coordinated Workers

Imagine asking Claude Code to improve a product page: fix a layout issue, update its data mapping, and verify the result. The following is a proposed custom workflow combining the three capabilities.

1. Define the outcome. The page should display the required fields and work at the specified screen sizes. Agree on the checks before delegation.

2. Separate the work. One session owns the data contract; another owns the page implementation. A bounded inspection task, such as extracting current headings, may be eligible for a cheaper model under the routing policy.

3. Exchange dependencies. The data session sends the final field names and relevant commit identifier. The page session acknowledges what it will use. Neither assumes it received the other session’s full context.

4. Show progress and evidence. A custom panel records assignments, messages, observed actions, and checks. A worker’s “done” message appears as reported completion until the defined verification succeeds.

5. Review the combined result. The coordinator checks that both changes integrate correctly. Later edits make earlier affected checks stale. The user reviews the final result before publication.

Keep ownership explicit: who may change each file, who combines the work, and who resolves a conflict. Separate worktrees can help isolate parallel changes, but they do not merge themselves. Two workers changing the same area without coordination can create more work than they save.

This arrangement is worth exploring when work has genuinely separable parts and coordination costs are manageable. A small change in one file may be faster with a single session.

Who Are Claude Mods For?

Mods fit people already using Claude Code for recurring tasks. The strongest candidates have an identifiable interruption or repeated decision.

• Developers: coordinate separate workstreams, route bounded delegated tasks, and inspect changes.

• Website owners working with code: coordinate data and page changes, keep environments visible, and review the combined result.

• Agencies: reduce confusion when switching between clients and repositories.

• Engineering teams: standardize task-routing policies and bring build and verification evidence into the working environment.

• Learners: inspect what the assistant attempted and connect edits to requirements.

If your main use is occasional writing, brainstorming, or questions in regular Claude chat, start with the features available there. A coding extension becomes useful when your problem depends on coding-session events or an integrated interface.

For broader context on providers and agent-building platforms, Whathetech’s guide to AI agent companies places Anthropic’s coding tools within the wider ecosystem.

Three Real Claude Mods Examples Worth Understanding

Anthropic publishes Token Weather, Blast Radius, and Replay Theater in its playground repository. They are sample code shared as-is, with no promise of product support or maintenance. Read their individual requirements before using them.

Token Weather: See How Much Context Your Session Uses

Token Weather displays context usage above the prompt, including a percentage, token figures, and recent growth. It updates after a turn and does not call a language model itself.

This is useful during a long investigation. If the session has just read several large files, the display helps you notice how much information you are bringing into the task. You might narrow the next request or write a concise handoff before moving to a fresh session.

The display is an awareness tool, not an accuracy score. A nearly full context window does not prove the answer is wrong. A mostly empty one does not prove it is right.

One subtle limitation: its percentage measures the full context window. Claude Code’s own compaction notice can use a different reference point, so the figures can differ without either being broken. The sample README also specifies terminal use; do not assume a sample’s interface works everywhere the mods framework runs.

Blast Radius: Inspect Certain Commands Before Execution

Blast Radius pauses recognized risky Bash commands, prepares an impact preview, and offers a choice to continue or cancel. Examples include certain deletion commands, resets, force pushes, and migrations.

Imagine asking Claude to clean a project. A preview of files targeted for deletion gives you a chance to spot an unexpected folder before you approve the command.

Its detection has boundaries. The sample reads command text and misses routes such as aliases, wrapper scripts, or shell substitutions. It watches Bash calls, rather than every way a file can change. Its migration preview may load project code while checking status, before you choose to proceed.

Use it as an additional inspection aid. Keep backups and independently configured access restrictions for important systems. The README documents the limits; “a warning did not appear” is not evidence that an action is harmless.

Replay Theater: Inspect the Sequence of Attempted Edits

Replay Theater records Edit and Write calls and provides a /replay command for stepping through the last editing turn.

Suppose a refactor touches an exported function, its callers, and its tests. Looking at the sequence can help you understand how those pieces relate. This is especially useful when you are learning or reviewing unfamiliar code.

There is an important qualification: recording happens when a tool is called. An edit that later fails or is denied can still appear in the replay. Its previews are also shortened, and the replay is held in session memory.

Check the actual files, final Git diff, and verification results before accepting the work. Replay is a review aid, not a durable audit log, proof of successful edits, or an undo mechanism.

How Claude Mods Work Under the Hood

At the event-handler level, a mod can observe, rewrite, or answer. These are the mechanics behind applications such as coordination, routing, and supervision.

In technical terms, a handler receives an event and a continuation function called next. Calling next(e) passes the event onward. Passing a modified copy rewrites it. Returning an answer without calling next handles it directly.

Handlers can also act after an operation by waiting for its result. When several mods handle the same event, their order matters. The event-handling guide documents this chain.

For everyday use, start with the question you want answered. Visibility often needs observation. Changing behavior needs rewriting or taking over an event, which introduces more interaction to test.

Claude Mods vs. Skills, Hooks, MCP, and Plugins

Choose the mechanism that matches the problem. A new interface is useful only when an interface solves the difficulty.

The mods comparison explains these boundaries. For example, editorial instructions belong naturally in a skill; access to a publishing service may belong in an MCP integration; an always-visible review panel is a reason to consider a mod.

Before investing in customization, make sure the underlying tool fits your work. Whathetech’s AI comparison tool can help you explore products and plans around your priorities.

How to Try Claude Mods: A Concrete First Walkthrough

This terminal walkthrough uses Anthropic’s published Token Weather sample. You need Git, an authenticated Claude Code installation, and a directory you are comfortable using for a trial. The commands are checked against the published repository; they have not been executed as a live Claude session for this article.

Step 1: Check Claude Code

Run this in your terminal:

claude --version

Use v2.1.287 or later for this walkthrough. The mods overview separately lists Desktop support from its bundled v2.1.286 and VS Code interface support from extension v2.1.299, subject to the documented session conditions. Check requirements in the application you actually use.

Step 2: Download and Review the Sample

Clone the repository into your chosen trial directory:

git clone https://github.com/anthropics/claude-code-playground.git

cd claude-code-playground/claude-code/mods

Read the Token Weather README and source before loading it. The sample collection’s installation instructions provide the upstream reference.

Step 3: Validate Before Loading

claude plugin validate ./token-weather

Inspect the reported hooks and API calls. Validation exposes supported structure and call patterns; a passing result is not a security certification.

Step 4: Load It for One Session

claude --plugin-dir ./token-weather

This loads the local plugin for that session. Ask Claude to read a small README or list the trial files. The sample’s context display updates after turns; it is not a live meter of every intermediate operation.

Step 5: Keep It Only If It Helps

From the same mods directory, the repository documents permanent user installation through its local marketplace:

claude plugin marketplace add ./

claude plugin install token-weather@claude-code-playground-mods --scope user

Keep that clone in place: the local marketplace depends on it. If you install from a shell while another session is open, use /reload-plugins in that session. The plugin installation guide explains scopes and updates.

For a different mod, use its actual publisher’s instructions. Plugin names and marketplace names are not interchangeable.

Can Claude Build a Mod for You?

Yes. In an interactive Claude Code session, describe the behavior you want. A small request is easier to review:

Build a display-only mod showing my current Git branch. Handle detached HEAD and directories outside Git. Explain its access, validate it, and test both missing-repository and normal cases. Use no model calls or network access.

Claude uses its built-in authoring guidance. Review the files and approve the hot-reload request if you want to run them. Then inspect /plugin and try the result.

The creation guide explains that generated mods initially belong to their originating session. Copy the directory to a persistent location before relying on it across sessions; the session-mods folder is subject to cleanup.

For a plugin that includes tests, run:

claude plugin test ./my-mod

Here my-mod means your real plugin directory. The testing guide documents controlled event tests. Write meaningful cases for cancellation, missing information, failure, and interactions with another installed mod.

Where Do Claude Mods Work?

Framework support and an individual mod’s interface support are separate questions.

The availability documentation lists the terminal, Desktop’s Code tab, and supported VS Code sessions as visual surfaces. Existing hooks can also run in supported non-interactive, SDK, or cloud sessions without displaying a mod’s interface. Desktop WSL sessions are excluded in the current table.

A specific mod may rely on a terminal-only drawing location. The interface reference explains differences among panes, controls, and drawing surfaces. Follow the sample README and your installed version’s API types when adapting it.

Are Claude Mods Free, and Do They Use Tokens?

Separate the cost of access from the behavior of the extension.

Anthropic’s current pricing page lists Claude Code in paid plans and describes a pay-as-you-go API option. Plan usage is shared with other Claude activity. Check current terms and regional checkout pricing before choosing a subscription.

A mod that counts events or draws information can use ordinary program logic without making an extra language-model request. Token Weather is a documented example.

Other mods can call a model. The mods API documents model requests billed through the session’s credentials. External services can also introduce costs.

Ask whether a proposed mod sends model requests, adds prompt context, or repeatedly polls a paid service. “Mods use zero tokens” is too broad to be reliable.

Security Limits You Should Understand

Mods run with substantial access. They can read and write files, start processes, make requests, and inspect or alter session activity. Review them as software you are allowing to run under your account.

The plugin security guidance distinguishes Claude’s tool permissions from code an extension runs itself. A mod’s own processes run outside Claude Code’s Bash sandbox. Blocking Claude from reading a file through a tool is not a general guarantee that installed mod code cannot read it.

Before installing, check the publisher, code, requested access, update policy, and compatibility. “Display-only” describes intended behavior; it is not a separate permission boundary.

For organizations, the managed-mods guide explains execution restrictions and the built-in guard. That guard protects managed behavior but does not sandbox allowed mods. Teams should review access and keep an owner for each extension they distribute.

If a Claude Mod Does Not Work

Start with the smallest relevant check instead of reinstalling everything.

Anthropic’s troubleshooting guide describes debug-log reasons for refused or failed modules. To investigate whether installed customizations cause a problem, a session started with claude --safe-mode disables those customizations; it does not stop built-in mods.

How to Decide Whether a Mod Is Worth Keeping

Name one outcome before installing: less review time, fewer project mix-ups, or better visibility of failed checks. Compare similar tasks with and without the mod.

For example, saving three minutes on twenty weekly tasks produces sixty minutes of gross savings. If maintenance takes forty minutes, the net saving is twenty. This is an illustrative calculation, not a measured Claude result.

For a warning mod, also record false alarms and missed cases. An interruption is useful when it catches a mistake you would otherwise make; frequent irrelevant warnings can make the workflow worse.

This principle extends to a wider software stack. Whathetech’s guide to startup tools and workflows discusses organizing work before adding automation.

Choose your first mod around a repeated question: Which project is open? What was attempted? Which checks actually ran? Keep the extension when its answer consistently helps you act.

Frequently Asked Questions

Are Claude Mods the Same as Claude Modes?

No. Mods are software extensions for Claude Code. The three actions in this guide describe event handling; they are not three chat modes.

Do I Need to Know TypeScript to Use Claude Mods?

You can install an existing mod or ask Claude to create one from a description. Someone still needs to understand its access and check its behavior. JavaScript is supported too.

Do Claude Mods Make the Model Smarter?

They can improve the workflow around the model, including what you see and how actions are handled. They do not inherently improve the model’s reasoning or guarantee correct output.

Can I Install a Mod Into Normal Claude Web Chat?

The mods described here target Claude Code. Accessing a remote coding session through a web interface does not mean a mod’s custom interface will render inside ordinary chat. Check the supported session and surface.

Do Mods Automatically Split Work and Choose the Cheapest Model?

No. They provide ways to implement a routing policy. Task boundaries, model selection, verification, and escalation need to be designed and tested. Choose models based on the total cost and quality of accepted results.

Do Connected Sessions Share All Their Context?

No. Cross-session messages carry text. Each session needs the relevant instructions and access for its assignment. Sharing a message does not automatically transfer files or merge changes.

Which Claude Mod Should I Try First?

Start with one question you repeatedly need answered. A context display or activity view is a manageable first experiment. For collaboration, first confirm that native session messaging meets your needs; then build a mod only for the extra coordination or visualization you want.

Whathetech article draft · Research checked October 18, 2026 · Illustrations are conceptual, not product screenshots.