AI Watch · Anthropic / Claude news
Claude Code Mods: from a tool you configure to a tool you program
On October 1, 2026, Anthropic opened Claude Code to "mods": small TypeScript or JavaScript modules that run inside the agent and can change what it does and what it draws. It's a big step in extensibility — and it comes with security fine print you should read before installing anything.
1. What a mod is
Until now, you could extend Claude Code from the outside: run a shell script on an event (hooks), hand it text and procedures (skills, instructions files), or give it tools (MCP servers). A mod is different: it is a function that Claude Code loads into its own process and calls when something happens — a tool call, a submitted prompt, a piece of the interface being drawn. The handler can watch, change or replace what happens next.
Key facts (as of Oct 2, 2026)
- Announced Oct 1, 2026 by Anthropic's developer account: "You can now mod Claude Code." Docs went live the same day.
- Mods are written in a few lines of TypeScript/JavaScript — or you can ask Claude to write one for you.
- They ship inside plugins and install the usual way (
/plugin in the CLI or desktop app).
- Requires Claude Code v2.1.287 or later; mods are on by default.
- Mod-drawn interface appears in the terminal and the Code tab of the desktop app; handlers can also run in other surfaces (e.g. the VS Code extension, headless runs) without drawing UI.
- Four mods already ship built in, including
/diff and one that loads AGENTS.md as project instructions.
2. Mods vs. hooks, skills, MCP and plugins
Claude Code already had several extension points. The new one fills a gap none of them covered.
| Mechanism | Runs where | Good for | Can't do |
|---|
| Skills / instructions | Text in the model's context | Teaching procedures and conventions | Enforce anything; change the UI |
| MCP servers | Separate process, over a protocol | Giving the agent new tools and data | Alter built-in behavior or rendering |
| Hooks | A shell command / HTTP call fired from outside | Reacting to events (run a linter, log, block) | Draw UI, share in-memory state |
| Mods | Inside Claude Code's process | Changing behavior and interface, with shared state | Change the permission prompt |
| Plugins | — | The package: bundles skills, commands, MCP, and now mods | (It's a container, not a mechanism) |
In short: skills and MCP add capabilities the model can use; hooks add reactions; mods let you reshape the harness itself.
3. What a mod can do
According to Anthropic's documentation (as summarized by independent coverage on launch day):
- Draw its own interface: a pane beside the transcript, or a band above the prompt with tabs, buttons and text fields.
- Restyle Claude Code's own interface: the row of a tool call, the spinner, the dialog where Claude asks you questions.
- Step into a tool call or a request: hold a call while it asks you something, answer it without running the tool at all, or send one request to a different model.
- Add slash commands that run your function immediately, with no Claude turn (so no tokens spent).
- Share data between handlers: e.g. count tool calls in one handler and show the count beside the spinner in another.
4. A mental model: middleware for an agent
If you've used Express or Koa, you already know the shape. Multiple mods run in registration order as an onion-style chain: earlier handlers wrap later ones, and each can pass the event along, modify it, or stop it. Instead of HTTP requests, the "requests" are agent events.
Generic example — pseudocode, not the real API
Imagine a mod called cost-guard. Conceptually it would do this (check the official Mods API docs for real names and signatures):
- On every model request: count tokens so far this session.
- On a tool call that matches a risky pattern (say, deleting many files): hold it and ask you first.
- On render: show a small band above the prompt with the running total.
- As a slash command
/budget: print the totals instantly, without spending a model turn.
That's the leap: behavior (guard the call), interface (the band) and state (the running total) living in one small module.
5. The security fine print
Anthropic's docs are blunt: "A mod is code that runs with your permissions." It is not sandboxed. Turning on Claude Code's sandboxing isolates the Bash commands the agent runs — not processes a mod starts.
| What a loaded mod can reach | What that means |
|---|
| Your machine | Read/write files, start programs, make network requests — as you |
| Your secrets | Environment variables and settings files, including API keys |
| Your session | Every prompt and tool call; it can rewrite them or submit prompts |
| Your approvals | It can approve a tool call before you're asked |
| Your usage | It can call a model on your plan or API key |
The one hard line: a mod can restyle much of the interface, but not the permission prompt. However, a mod that auto-approves tool calls can approve something a rule would otherwise have asked you about — so "the prompt is intact" is not the same as "I'm safe."
Controls Anthropic documents
claude plugin validate — inspect a mod before trusting it.--safe-mode — start a session with mods off.disableAllHooks — turn every mod off.- An administrator setting that limits which mods load (user-installed ones can be blocked while managed ones keep running).
6. How to approach mods in practice
- Treat a mod like an npm dependency with root-ish access to your session. Same supply-chain thinking: who wrote it, is the source readable, is it pinned to a version?
- Read the code before installing. A mod is "a few lines of TypeScript" — that's exactly why reviewing it is cheap.
- Prefer the lightest mechanism that works. If a skill or hook solves your problem, use that; reach for a mod only when you need UI, in-process state, or to intercept requests.
- Teams: decide the policy first. Use the admin setting to allow only vetted mods before people start installing from random marketplaces.
- Start by building your own tiny mod (a status band, a slash command). You'll understand both the power and the risk much better.
Why it matters: coding agents are becoming platforms. Extensions turned browsers into platforms — with the same trade: power arrives together with a new supply chain. Worth watching: a changelog entry, the first public mod marketplaces, security research on malicious mods, and whether competing agents ship a comparable in-process extension model.
Note: details above come from Anthropic's launch-day documentation as reported by independent sources; at the time of writing there was no public changelog entry yet and no community mod marketplace announced. APIs may change quickly.
IA Watch · Novidades Anthropic / Claude
Mods do Claude Code: de uma ferramenta que você configura para uma que você programa
Em 1º de outubro de 2026, a Anthropic abriu o Claude Code para "mods": pequenos módulos em TypeScript ou JavaScript que rodam dentro do agente e podem mudar o que ele faz e o que ele desenha na tela. É um passo grande em extensibilidade — e vem com letras miúdas de segurança que vale ler antes de instalar qualquer coisa.
1. O que é um mod
Até agora, você estendia o Claude Code por fora: rodando um script de shell num evento (hooks), entregando texto e procedimentos (skills, arquivos de instruções) ou dando ferramentas a ele (servidores MCP). Um mod é diferente: é uma função que o Claude Code carrega dentro do próprio processo e chama quando algo acontece — uma chamada de ferramenta, um prompt enviado, um pedaço da interface sendo desenhado. O handler pode observar, alterar ou substituir o que acontece em seguida.
Fatos-chave (em 02/10/2026)
- Anunciado em 01/10/2026 pela conta de desenvolvedores da Anthropic: "You can now mod Claude Code." A documentação saiu no mesmo dia.
- Mods são escritos em poucas linhas de TypeScript/JavaScript — ou você pede para o Claude escrever um.
- Eles vêm dentro de plugins e se instalam do jeito de sempre (
/plugin no CLI ou no app desktop).
- Exige Claude Code v2.1.287 ou superior; mods ficam ligados por padrão.
- A interface desenhada por mods aparece no terminal e na aba Code do app desktop; os handlers também podem rodar em outras superfícies (ex.: extensão do VS Code, execuções headless), mas sem desenhar UI.
- Quatro mods já vêm embutidos, incluindo o
/diff e um que carrega o AGENTS.md como instruções do projeto.
2. Mods vs. hooks, skills, MCP e plugins
O Claude Code já tinha vários pontos de extensão. O novo preenche uma lacuna que nenhum deles cobria.
| Mecanismo | Roda onde | Bom para | Não consegue |
|---|
| Skills / instruções | Texto no contexto do modelo | Ensinar procedimentos e convenções | Impor nada; mudar a UI |
| Servidores MCP | Processo separado, via protocolo | Dar novas ferramentas e dados ao agente | Alterar comportamento nativo ou renderização |
| Hooks | Comando de shell / chamada HTTP disparado de fora | Reagir a eventos (rodar linter, logar, bloquear) | Desenhar UI, manter estado em memória compartilhado |
| Mods | Dentro do processo do Claude Code | Mudar comportamento e interface, com estado compartilhado | Alterar o prompt de permissão |
| Plugins | — | O pacote: agrupa skills, comandos, MCP e agora mods | (É um contêiner, não um mecanismo) |
Resumindo: skills e MCP adicionam capacidades que o modelo usa; hooks adicionam reações; mods deixam você remodelar o próprio harness.
3. O que um mod pode fazer
Segundo a documentação da Anthropic (como resumida por coberturas independentes no dia do lançamento):
- Desenhar a própria interface: um painel ao lado da transcrição, ou uma faixa acima do prompt com abas, botões e campos de texto.
- Redesenhar a interface do próprio Claude Code: a linha de uma chamada de ferramenta, o spinner, o diálogo em que o Claude te faz perguntas.
- Entrar no meio de uma chamada de ferramenta ou de uma requisição: segurar a chamada para te perguntar algo, responder sem rodar a ferramenta, ou enviar uma requisição a outro modelo.
- Adicionar slash commands que executam sua função na hora, sem turno do Claude (ou seja, sem gastar tokens).
- Compartilhar dados entre handlers: por exemplo, contar chamadas de ferramenta num handler e mostrar o total ao lado do spinner em outro.
4. Modelo mental: middleware para um agente
Se você já usou Express ou Koa, já conhece o formato. Vários mods rodam na ordem de registro numa cadeia em camadas (estilo cebola): handlers anteriores envolvem os posteriores, e cada um pode repassar o evento, modificá-lo ou interrompê-lo. Em vez de requisições HTTP, as "requisições" são eventos do agente.
Exemplo genérico — pseudocódigo, não é a API real
Imagine um mod chamado cost-guard. Conceitualmente ele faria isto (consulte a documentação oficial da Mods API para nomes e assinaturas reais):
- A cada requisição ao modelo: somar os tokens da sessão.
- Numa chamada de ferramenta com padrão arriscado (por exemplo, apagar muitos arquivos): segurar e te perguntar antes.
- No render: mostrar uma faixa acima do prompt com o total corrente.
- Como slash command
/budget: imprimir os totais na hora, sem gastar um turno do modelo.
Esse é o salto: comportamento (proteger a chamada), interface (a faixa) e estado (o total) vivendo num único módulo pequeno.
5. As letras miúdas de segurança
A documentação da Anthropic é direta: "A mod is code that runs with your permissions." Ou seja, ele roda com as suas permissões e não é isolado (sandbox). Ligar o sandbox do Claude Code isola os comandos Bash que o agente executa — não os processos que um mod inicia.
| O que um mod carregado alcança | O que isso significa |
|---|
| Sua máquina | Ler/gravar arquivos, iniciar programas, fazer requisições de rede — como você |
| Seus segredos | Variáveis de ambiente e arquivos de configuração, incluindo chaves de API |
| Sua sessão | Todo prompt e toda chamada de ferramenta; pode reescrevê-los ou enviar prompts |
| Suas aprovações | Pode aprovar uma chamada de ferramenta antes de você ser perguntado |
| Seu uso | Pode chamar um modelo no seu plano ou na sua chave de API |
A única linha firme: um mod pode redesenhar boa parte da interface, mas não o prompt de permissão. Só que um mod que aprova chamadas automaticamente pode aprovar algo sobre o qual uma regra normalmente te perguntaria — então "o prompt está intacto" não significa "estou seguro".
Controles documentados pela Anthropic
claude plugin validate — inspecionar um mod antes de confiar nele.--safe-mode — iniciar uma sessão com mods desligados.disableAllHooks — desligar todos os mods.- Uma configuração de administrador que limita quais mods carregam (os instalados pelo usuário podem ser bloqueados enquanto os gerenciados continuam rodando).
6. Como abordar mods na prática
- Trate um mod como uma dependência npm com acesso quase total à sua sessão. Mesmo raciocínio de cadeia de suprimentos: quem escreveu, o código é legível, está fixado numa versão?
- Leia o código antes de instalar. Um mod são "algumas linhas de TypeScript" — é justamente por isso que revisar é barato.
- Prefira o mecanismo mais leve que resolve. Se uma skill ou hook resolve, use; recorra a um mod só quando precisar de UI, estado em processo ou interceptar requisições.
- Times: definam a política primeiro. Use a configuração de admin para liberar só mods avaliados antes de o pessoal instalar de marketplaces aleatórios.
- Comece construindo seu próprio mod pequeno (uma faixa de status, um slash command). Você entende muito melhor o poder e o risco.
Por que importa: agentes de código estão virando plataformas. Extensões transformaram navegadores em plataformas — com a mesma troca: o poder chega junto com uma nova cadeia de suprimentos. Vale acompanhar: uma entrada no changelog, os primeiros marketplaces públicos de mods, pesquisas de segurança sobre mods maliciosos e se agentes concorrentes lançam um modelo comparável de extensão em processo.
Nota: os detalhes acima vêm da documentação de lançamento da Anthropic, conforme relatada por fontes independentes; na hora da escrita não havia entrada pública no changelog nem marketplace comunitário de mods anunciado. As APIs podem mudar rápido.