---
title: Proteger sua implantação do Managed Agents
url: https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment
description: As configurações que limitam o que seus agentes podem alcançar e fazer, das mais importantes para as menos importantes.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Este guia lista as configurações que limitam o que um agente no Claude Managed Agents pode alcançar e fazer, das mais importantes para as menos importantes. Cada seção tem um link para a página que aborda a configuração por completo.
| Seção | Configuração ou decisão | Recomendado |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Escolher onde o agente é executado](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#choose-where-the-agent-runs) | Sandbox em nuvem ou auto-hospedado | Nuvem, a menos que as ferramentas precisem ser executadas em uma infraestrutura que você controla |
| [Limitar a rede](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#limit-the-network) | `networking.type` do ambiente | `limited`, apenas com os hosts de que o agente precisa |
| [Manter as credenciais em vaults](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#keep-credentials-in-vaults) | `injection_location` e `networking` em cada credencial de variável de ambiente | Apenas cabeçalhos de requisição, e rede `limited` apenas com os hosts aos quais a chave se destina |
| [Restringir a pesquisa na web e a busca na web](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#restrict-web-search-and-web-fetch) | `allowed_domains` em cada ferramenta web | Uma lista de permissões em cada ferramenta. Em `web_fetch`, liste apenas os sites de que o agente precisa. Em `web_search`, liste os sites dos quais você quer resultados |
| [Aprovar ações arriscadas](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#approve-risky-actions) | `permission_policy` em cada ferramenta | `auto` em `bash`, `write`, `edit`, `web_fetch` e ferramentas MCP que apenas leem dados. Use `always_ask` em uma ferramenta se você não puder desfazer suas alterações fora do sandbox, ou se o texto de usuário final repassado, por si só, não deve fazê-la ser executada |
| [Dar ao agente o menor conjunto de ferramentas](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) | `default_config.enabled` no toolset do agente | `false`, e então habilite as ferramentas de que o agente precisa |
| [Manter entradas não confiáveis longe de ferramentas poderosas](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#keep-untrusted-input-away-from-powerful-tools) | Quais ferramentas e credenciais um agente possui quando lê entradas não confiáveis | Nenhum agente que lê entradas não confiáveis tem uma ferramenta em `always_allow` que grava arquivos, executa comandos ou altera registros |
| [Definir limites e uma forma de parar](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#set-limits-and-a-way-to-stop) | `budget` em cada sessão e implantação | Um teto dimensionado para o custo que você espera de uma execução |
| [Opcionalmente, fazer um revisor offline ler cada transcrição](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment-monitoring#optionally-have-an-offline-reviewer-read-every-transcript) | Um job de revisão offline que você executa e que lê os eventos de cada sessão | Opcional. Uma revisão de cada sessão que ficou ociosa ou foi encerrada, de forma agendada |
| [Monitorar sessões e revisar a retenção](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention) | Webhooks e exclusão de sessões | Um alerta quando uma sessão fica ociosa, atinge seu orçamento ou é encerrada, e uma verificação do motivo pelo qual ficou ociosa. Armazene os eventos que você quer manter em seus próprios logs e exclua as sessões de que você não precisa mais |
[Riscos de segurança e limites do sandbox](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment-risks) explica por que essas configurações são importantes e contra o que elas não protegem. Para revisar e monitorar sessões, consulte [Revisar e monitorar sessões de agentes](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment-monitoring).
## Escolher onde o agente é executado
O local onde as ferramentas do agente são executadas decide quem protege o sandbox: a Anthropic, com um ambiente em nuvem, ou você, com um sandbox auto-hospedado. Para escolher entre eles e saber o que chega à Anthropic em cada caso, consulte [Escolhendo um ambiente de agente](https://platform.claude.com/docs/pt-BR/managed-agents/choosing-an-environment).
Se você usa um [sandbox auto-hospedado](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes), tenha em mente estes quatro pontos:
* **Rede:** [Limitar a rede](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#limit-the-network) se aplica a ambientes em nuvem. Para um sandbox auto-hospedado, defina os limites equivalentes sobre o tráfego dele em seu próprio firewall. Seu firewall não limita os servidores MCP que um agente declara, então revise-os, assim como quaisquer servidores que sua aplicação defina para uma sessão.
* **Ferramentas web:** As ferramentas web são executadas nos servidores da Anthropic, então seu firewall não as limita. Limite-as com suas listas de domínios. Consulte [Restringir a pesquisa na web e a busca na web](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#restrict-web-search-and-web-fetch).
* **Credenciais:** Credenciais de variável de ambiente ainda não são compatíveis com sandboxes auto-hospedados.
* **Isolamento e hardening:** Você é responsável por ambos. Consulte o [Modelo de segurança](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes-security).
Nenhuma das opções altera a cobertura de conformidade do Managed Agents nem por quanto tempo ele mantém o histórico de sessões. Consulte [Monitorar sessões e revisar a retenção](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention).
## Limitar a rede
Defina `networking.type` como `limited` e liste apenas os hosts de que o agente precisa em `allowed_hosts`. Uma requisição de criação de ambiente que omite `networking` pode receber `unrestricted`, então defina `networking` em toda requisição de criação. Consulte [Riscos da rede irrestrita](https://platform.claude.com/docs/pt-BR/managed-agents/environments#risks-of-unrestricted-networking).
Arquivos, memory stores e repositórios do GitHub que você anexa permanecem disponíveis para o agente independentemente de `allowed_hosts`.
Os exemplos desta página usam um agente de suporte. Ele lê o ticket de um cliente, consulta o pedido, lê sua central de ajuda e redige uma resposta. Sua aplicação executa a consulta do pedido, que não precisa de nenhum host, então este ambiente permite um host, a central de ajuda, para `web_fetch`:
```bash cURL
curl -fsS https://api.anthropic.com/v1/environments \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "support-agent",
"config": {
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"]
}
}
}'
```
```bash CLI
ant apply environment.yaml
```
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
name: support-agent
config:
type: cloud
networking:
type: limited
allowed_hosts:
- help.example.com
```
```python Python
environment = client.beta.environments.create(
name="support-agent",
config={
"type": "cloud",
"networking": {
"type": "limited",
"allowed_hosts": ["help.example.com"],
},
},
)
```
```typescript TypeScript
const environment = await client.beta.environments.create({
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
});
```
```csharp C#
using Anthropic.Models.Beta.Environments;
var environment = await client.Beta.Environments.Create(new()
{
Name = "support-agent",
Config = new BetaCloudConfigParams
{
Networking = new BetaLimitedNetworkParams
{
AllowedHosts = ["help.example.com"],
},
},
});
```
```go Go
environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
Name: "support-agent",
Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
OfCloud: &anthropic.BetaCloudConfigParams{
Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
OfLimited: &anthropic.BetaLimitedNetworkParams{
AllowedHosts: []string{"help.example.com"},
},
},
},
},
})
if err != nil {
panic(err)
}
_ = environment
```
```java Java
import com.anthropic.models.beta.environments.*;
import java.util.List;
var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
.name("support-agent")
.config(BetaCloudConfigParams.builder()
.networking(BetaLimitedNetworkParams.builder()
.allowedHosts(List.of("help.example.com"))
.build())
.build())
.build());
```
```php PHP
$environment = $client->beta->environments->create(
name: 'support-agent',
config: [
'type' => 'cloud',
'networking' => [
'type' => 'limited',
'allowed_hosts' => ['help.example.com'],
],
],
);
```
```ruby Ruby
environment = client.beta.environments.create(
name: "support-agent",
config: {
type: "cloud",
networking: {
type: "limited",
allowed_hosts: ["help.example.com"]
}
}
)
```
Um ambiente `limited` tem três configurações de rede:
| Configuração | O que ela abre para o código no sandbox | Recomendado |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowed_hosts` | Os hosts que você lista, para qualquer requisição | Apenas os hosts de que o agente precisa, incluindo o host de cada servidor MCP que você opera ou em que confia |
| `allow_package_managers` | Os [hosts de gerenciadores de pacotes](https://platform.claude.com/docs/pt-BR/managed-agents/environments#package-manager-hosts). Eles incluem todos os repositórios e caminhos em `github.com`, `gitlab.com` e `bitbucket.org`, onde qualquer pessoa pode publicar conteúdo e onde o código no sandbox pode fazer upload de arquivos | `false`, a menos que a configuração `packages` do ambiente liste pacotes, o que exige `true`. Se o agente instala pacotes durante a execução, liste em vez disso apenas os hosts de registro de que ele precisa em `allowed_hosts` |
| `allow_mcp_servers` | Nenhum host. O Managed Agents se conecta a servidores MCP a partir dos servidores da Anthropic | `false`, com o host de cada servidor MCP que você opera ou em que confia listado em `allowed_hosts` |
As configurações `allow_package_managers` e `allow_mcp_servers` não adicionam hosts para a pesquisa na web e a busca na web.
Deixe `allow_mcp_servers` desativado, que é o padrão, e liste o host de cada servidor MCP que você opera ou em que confia em `allowed_hosts`. Cada host que você lista também fica aberto ao código no sandbox. Com `allow_mcp_servers` desativado, uma verificação na criação da sessão rejeita a requisição se o host de um servidor MCP não estiver listado. Consulte [Fornecer autenticação na criação da sessão](https://platform.claude.com/docs/pt-BR/managed-agents/mcp-connector#provide-authentication-at-session-creation). A mesma verificação é executada quando uma atualização de sessão altera `mcp_servers`.
O acesso à rede é concedido por host, não por operação. O sandbox pode enviar qualquer requisição a um host permitido, incluindo uploads como `git push` e publicação de pacotes. Ele também pode usar qualquer credencial que o comando forneça, mesmo uma que alguém tenha escondido em um texto que o agente lê.
Ao escolher hosts para `allowed_hosts`, siga estas duas regras:
* Liste apenas hosts que você opera ou em que confia.
* Evite curingas `*.` e domínios de hospedagem compartilhada onde qualquer pessoa pode publicar conteúdo.
Se o agente mantiver `bash`, defina a [política de permissão](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies) da ferramenta `bash` conforme descrito em [Aprovar ações arriscadas](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#approve-risky-actions).
Depois de restringir um ambiente, inicie novas sessões e interrompa as que já estavam em execução. Uma sessão que já está em execução pode manter os limites antigos até terminar. Consulte [Definir limites e uma forma de parar](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#set-limits-and-a-way-to-stop).
Consulte [Configuração do ambiente em nuvem](https://platform.claude.com/docs/pt-BR/managed-agents/environments#networking) para ver todas as configurações de rede.
## Manter as credenciais em vaults
Armazene todos os segredos em um vault. Para cada credencial de variável de ambiente, defina o local de injeção apenas como cabeçalhos de requisição e liste apenas os hosts aos quais o segredo se destina. O código no sandbox vê um placeholder em vez do segredo. O Managed Agents o substitui pelo segredo real apenas em requisições HTTPS de saída para os hosts que a credencial permite. Assim, o segredo fica fora do alcance direto do modelo, a menos que um serviço o envie de volta, como um endpoint que ecoa os cabeçalhos da requisição. Se o `networking` da credencial for `unrestricted`, o Managed Agents substitui o placeholder pelo segredo real em requisições para qualquer host que o ambiente permita ao sandbox alcançar. Para usar um vault, passe seu ID em `vault_ids` ao criar a sessão ou a implantação.
| Configuração | Defina como | Por quê | O que ela não faz |
| ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injection_location` | `{"header": true, "body": false}`, depois de verificar que o serviço lê a chave de um cabeçalho | Os corpos das requisições costumam ser construídos a partir de conteúdo que o agente lê, então uma chave em um corpo fica mais exposta. Especifique ambos os campos: uma requisição de criação que omite o objeto habilita ambos os locais, e uma atualização altera apenas os campos que você envia | O código ainda pode usar a chave em todos os hosts que a credencial permite. Um serviço que espera a chave no corpo recebe o placeholder e rejeita a requisição |
| `networking` na credencial | `limited`, com os hosts exatos aos quais a chave se destina | As respostas chegam ao sandbox sem redação, então evite curingas, domínios de hospedagem compartilhada e hosts que ecoam cabeçalhos de requisição | Ela não abre o host. O ambiente também precisa permiti-lo |
| As permissões da chave, no serviço que emitiu a chave | Apenas as permissões de que o agente precisa | O agente pode fazer qualquer coisa que a chave permita | Não se aplica |
| O token do GitHub de um repositório montado | Um [token de granularidade fina](https://platform.claude.com/docs/pt-BR/managed-agents/github#token-permissions) com as permissões mínimas | O código no sandbox pode fazer fetch e push no repositório montado com ele durante toda a sessão. Conceda acesso de escrita apenas se o agente precisar fazer push | Não se aplica |
O agente de suporte não precisa de nenhuma credencial de vault, porque sua aplicação mantém a chave de API da sua API de pedidos. Se o seu agente tiver uma credencial de vault, consulte [Adicionar uma credencial](https://platform.claude.com/docs/pt-BR/managed-agents/vaults#add-a-credential) para ver a requisição em todas as linguagens.
Mantenha as chaves fora de prompts do sistema, definições de agentes e mensagens. Não dê ao agente uma chave de API do Claude. Mesmo quando uma chave de API do Claude está em um vault, o código no sandbox pode usá-la para chamar a API do Claude diretamente. Ele pode fazer qualquer coisa que essa chave permita, como iniciar ou excluir sessões, ou usar a pesquisa na web e a busca na web. As configurações de ferramentas, as aprovações e o orçamento do agente não se aplicam a essas chamadas. Em um ambiente `limited`, o código só pode fazer essas chamadas se `allowed_hosts` permitir que o sandbox alcance `api.anthropic.com`.
Obtenha os tokens você mesmo e armazene-os no vault, porque um token que o código no sandbox obtém com um segredo armazenado retorna sem redação.
Mantenha vaults para cargas de trabalho com diferentes níveis de confiança em [workspaces](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces) separados, porque qualquer chave de API com acesso a um workspace pode referenciar seus vaults. Use chaves de API com escopo para um único workspace.
Consulte [Autenticar com vaults](https://platform.claude.com/docs/pt-BR/managed-agents/vaults) para credenciais MCP e rotação.
## Restringir a pesquisa na web e a busca na web
Defina `allowed_domains` em `web_fetch` com os sites de que o agente precisa. Qualquer URL que o agente busca pode levar dados ao site para o qual aponta, então essa lista é um controle de segurança. Em `web_search`, defina `allowed_domains` com os sites dos quais você quer resultados, para que os resultados venham apenas de sites em cuja precisão você confia. A lista não impede que a consulta de pesquisa chegue ao provedor de pesquisa. Os resultados de pesquisa incluem texto das páginas, então a lista também limita de quais sites o texto chega ao agente. Defina `allowed_domains` em ambas as ferramentas para todos os tipos de ambiente.
Uma lista `blocked_domains` bloqueia os hosts que você lista e seus subdomínios, e nenhum outro host. O mesmo conteúdo ainda pode chegar ao agente a partir de serviços de arquivamento da web, caches, espelhos ou domínios relacionados que você não listou. Não dependa de `blocked_domains` para segurança. Use `allowed_domains` e liste os hosts em que você confia.
Em um ambiente `limited`, a lista `allowed_hosts` de [Limitar a rede](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#limit-the-network) também limita as ferramentas web. Um ambiente `unrestricted` ou um sandbox auto-hospedado não limita as ferramentas web.
| Em um ambiente `limited` | Resultado |
| ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Uma entrada de `allowed_domains` em uma ferramenta web habilitada está fora de `allowed_hosts` | A criação de uma sessão falha com um erro 400, assim como uma atualização de sessão que adiciona tal entrada. Uma sessão que uma implantação inicia, em seu agendamento ou por uma execução manual, é criada mesmo assim. A ferramenta então não retorna nada de hosts fora de `allowed_hosts` |
| Uma ferramenta web não tem lista própria | A ferramenta retorna páginas e resultados apenas de hosts em `allowed_hosts`. Defina `allowed_domains` na ferramenta também |
| `allowed_hosts` não tem entradas | Nenhuma das ferramentas web retorna uma página ou um resultado de pesquisa |
| Você adiciona um host a `allowed_hosts` para uma ferramenta web | O host também fica aberto ao código no sandbox |
As duas listas fazem a correspondência de hosts de forma diferente:
| Lista | Entrada | Corresponde a | Não corresponde a |
| ---------------------------------- | --------------- | ------------------------------------ | ----------------- |
| `allowed_hosts` (ambiente) | `example.com` | `example.com` | `www.example.com` |
| `allowed_hosts` (ambiente) | `*.example.com` | Todos os subdomínios | `example.com` |
| `allowed_domains` (ferramenta web) | `example.com` | `example.com` e todos os subdomínios | Outros domínios |
Se o agente precisa de um site e de todos os seus subdomínios, liste tanto `example.com` quanto `*.example.com` em `allowed_hosts`; caso contrário, liste hosts exatos. Se uma ferramenta lista `example.com` e `allowed_hosts` lista apenas `*.example.com`, a sessão é criada. A verificação na criação da sessão considera `example.com` como dentro de `*.example.com`, mas a ferramenta não retorna nada do próprio `example.com`. Consulte [Definir listas de domínios em um agente](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions#set-domain-lists-on-an-agent) para ver como as duas listas fazem a correspondência.
A ferramenta `web_fetch` também abre apenas URLs que já apareceram na sessão:
| Onde a URL aparece | `web_fetch` pode abri-la |
| -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| O texto de uma mensagem de usuário, incluindo texto de usuário final que você repassa | Sim |
| A descrição de um evento `user.define_outcome` | Sim |
| O endereço de um resultado de pesquisa na web | Sim |
| O texto de uma página que `web_fetch` retornou anteriormente (não um PDF), onde a URL completa é exibida | Sim |
| O texto do resultado de uma ferramenta personalizada, quando o Claude chamou a ferramenta diretamente | Sim, a menos que o resultado esteja marcado com `is_error: true` |
| O prompt do sistema | Não |
| A configuração do agente, incluindo entradas de `allowed_domains` | Não |
| A própria saída do Claude | Não |
| Saída de `bash` e das outras ferramentas do sandbox | Não |
| Um resultado de ferramenta MCP | Não |
| Um arquivo anexado a uma mensagem de usuário | Não |
Em uma sessão multiagente, `web_fetch` abre uma URL vinda de outro agente apenas se ela chegou a esse agente por meio de uma fonte marcada com Sim. O resultado de uma ferramenta personalizada a partir de uma chamada direta conta como uma fonte marcada com Sim. Isso vale mesmo que o Claude tenha escrito o texto, por exemplo, quando a ferramenta repete sua entrada. Uma URL pode contar mesmo quando escrita sem `https://`, como `example.com/docs`. A ferramenta `web_fetch` nem sempre consegue abrir um link que mostra palavras em vez de sua URL, como "Fale com o suporte". Se o agente precisar buscar uma URL que não apareceu na sessão, envie-a em uma mensagem de usuário.
Essa regra reduz a chance de que um texto injetado construa uma URL que carregue dados privados. Texto de usuário final, resultados de pesquisa, páginas buscadas e resultados de ferramentas personalizadas ainda podem adicionar URLs, então mantenha `allowed_domains` definido. A Messages API aplica uma regra semelhante com uma lista diferente de fontes. Consulte [Validação de URL](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#url-validation).
Uma lista de domínios em `web_fetch` não limita a ferramenta `bash`. [Limite a rede](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#limit-the-network) também. Consulte [Regras da lista de domínios](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions#domain-list-rules).
## Aprovar ações arriscadas
Defina `auto` em `bash`, `write`, `edit` e `web_fetch`, e em ferramentas MCP que apenas leem dados. Use `always_ask` em uma ferramenta se você não puder desfazer suas alterações fora do sandbox. Use-o também em uma ferramenta que não deve ser executada só porque um texto de usuário final que você repassa pede isso. Uma [política de permissão](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies) determina se uma chamada de ferramenta é executada, aguarda sua aprovação ou é avaliada pelo servidor.
| Ferramenta | Política recomendada | Por quê |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------- |
| `read`, `glob`, `grep` | `always_allow` | Elas leem arquivos no sandbox e não alteram nada |
| `bash`, `write`, `edit` | `auto`. Use `always_ask` em uma ferramenta se você não puder desfazer suas alterações fora do sandbox. Use `always_ask` em `bash` se você repassa texto de usuário final | O padrão do toolset do agente é `always_allow`, que executa todas as chamadas sem aprovação |
| `web_fetch` | `auto` | Uma URL que o agente busca pode levar dados ao site para o qual aponta |
| `web_search` | `always_ask` se o agente lida com dados que você não gostaria que fossem enviados em uma consulta de pesquisa. Caso contrário, `always_allow` | `allowed_domains` limita de quais sites os resultados vêm, não o que a consulta contém |
| Ferramentas MCP que apenas leem dados | `auto`, definido para cada ferramenta nos `configs` do toolset | O padrão do toolset permanece `always_ask`, então uma ferramenta que o servidor MCP adicionar depois ainda aguarda aprovação |
| Ferramentas MCP que alteram dados | `always_ask` | Este é o padrão do toolset MCP. Mantenha-o |
| Ferramentas personalizadas | Seu código decide se cada chamada é executada | As políticas de permissão não se aplicam |
O toolset em [Dar ao agente o menor conjunto de ferramentas](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) aplica essas políticas.
A [política `auto`](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto) permite que o servidor execute uma chamada, a negue ou pause para aprovação. Uma pessoa não consegue aprovar todas as chamadas em uma execução longa, então o servidor verifica cada uma em seu lugar. Combine `auto` com rede limitada, uma chave com permissões restritas, um orçamento e um alerta para sessões ociosas. `auto` não é um ponto de verificação humano, então, se uma pessoa precisar revisar as chamadas de uma ferramenta antes de serem executadas, configure `always_ask` nessa ferramenta.
`auto` trata o texto em eventos `user.message` e a descrição em um evento `user.define_outcome` como sua instrução, incluindo texto de usuário final que você repassa.
Uma sessão pausada aguarda indefinidamente, então uma sessão sem supervisão precisa de um cliente que responda às chamadas pausadas ou interrompa a sessão.
Revise cada chamada pausada antes de permiti-la. Um cliente que permite todas as chamadas sem mostrá-las a uma pessoa é o mesmo que `always_allow`. Consulte [Responder a solicitações de confirmação](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies#respond-to-confirmation-requests) e [Ver como cada chamada foi avaliada](https://platform.claude.com/docs/pt-BR/managed-agents/permission-policies#see-how-each-call-was-evaluated).
## Dar ao agente o menor conjunto de ferramentas
Defina `default_config.enabled` como `false` e [habilite apenas as ferramentas de que o agente precisa](https://platform.claude.com/docs/pt-BR/managed-agents/tools#enabling-only-specific-tools). O toolset do agente habilita todas as oito ferramentas integradas por padrão.
| Ferramenta | O que ela faz |
| ------------------------- | -------------------------------------------------------------------------------------- |
| `bash` | Executa qualquer comando, incluindo requisições a hosts permitidos |
| `write`, `edit` | Alteram arquivos no sandbox |
| `read`, `glob`, `grep` | Leem arquivos no sandbox |
| `web_fetch`, `web_search` | Retornam páginas e resultados de pesquisa da web, por meio dos servidores da Anthropic |
O agente de suporte precisa de três ferramentas integradas: `read` e `write` para seu rascunho, e `web_fetch` para a central de ajuda. Ele consulta pedidos por meio de uma [ferramenta personalizada](https://platform.claude.com/docs/pt-BR/managed-agents/tools#custom-tools), `lookup_order`, que sua aplicação executa. Sua aplicação mantém a chave de API da sua API de pedidos, então o agente não precisa nem de `bash` nem de uma credencial.
O exemplo a seguir limita `web_fetch` a `help.example.com` com `allowed_domains`. Ele define `auto` em `write` e `web_fetch`, como recomenda [Aprovar ações arriscadas](https://platform.claude.com/docs/pt-BR/managed-agents/secure-deployment#approve-risky-actions). Se o ticket de um cliente levar o agente a usar essas ferramentas, o agente só pode alterar arquivos no sandbox ou abrir páginas da central de ajuda. É por isso que nenhuma das ferramentas precisa de `always_ask`. O exemplo também define `always_ask` em `default_config`, para que uma ferramenta que você habilitar depois sem política própria use `always_ask`:
```bash cURL
tools='[
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": false,
"permission_policy": {"type": "always_ask"}
},
"configs": [
{"name": "read", "enabled": true, "permission_policy": {"type": "always_allow"}},
{"name": "write", "enabled": true, "permission_policy": {"type": "auto"}},
{
"name": "web_fetch",
"enabled": true,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"}
}
]
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {"type": "string", "description": "The order ID from the ticket"}
},
"required": ["order_id"]
}
}
]'
```
```bash CLI
ant apply agent.md
```
```markdown
---
name: Support Agent
model: claude-opus-5-5
tools:
- type: agent_toolset_20260401
default_config:
enabled: false
permission_policy:
type: always_ask
configs:
- name: read
enabled: true
permission_policy:
type: always_allow
- name: write
enabled: true
permission_policy:
type: auto
- name: web_fetch
enabled: true
allowed_domains: [help.example.com]
permission_policy:
type: auto
- type: custom
name: lookup_order
description: Look up one order by its ID. Returns the status, the items, and the delivery date.
input_schema:
type: object
properties:
order_id:
type: string
description: The order ID from the ticket
required:
- order_id
---
```
```python Python
tools = [
{
"type": "agent_toolset_20260401",
"default_config": {
"enabled": False,
"permission_policy": {"type": "always_ask"},
},
"configs": [
{
"name": "read",
"enabled": True,
"permission_policy": {"type": "always_allow"},
},
{
"name": "write",
"enabled": True,
"permission_policy": {"type": "auto"},
},
{
"name": "web_fetch",
"enabled": True,
"allowed_domains": ["help.example.com"],
"permission_policy": {"type": "auto"},
},
],
},
{
"type": "custom",
"name": "lookup_order",
"description": "Look up one order by its ID. Returns the status, the items, and the delivery date.",
"input_schema": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "The order ID from the ticket",
},
},
"required": ["order_id"],
},
},
]
```
```typescript TypeScript
const tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: { type: "always_ask" }
},
configs: [
{
name: "read",
enabled: true,
permission_policy: { type: "always_allow" }
},
{
name: "write",
enabled: true,
permission_policy: { type: "auto" }
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: { type: "auto" }
}
]
},
{
type: "custom",
name: "lookup_order",
description:
"Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {
order_id: { type: "string", description: "The order ID from the ticket" }
},
required: ["order_id"]
}
}
] satisfies Anthropic.Beta.AgentCreateParams["tools"];
```
```csharp C#
using System.Text.Json;
using Anthropic.Models.Beta.Agents;
using Tool = Anthropic.Models.Beta.Agents.Tool;
Tool[] tools =
[
new BetaManagedAgentsAgentToolset20260401Params
{
Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
DefaultConfig = new()
{
Enabled = false,
PermissionPolicy = new BetaManagedAgentsAlwaysAskPolicy { Type = "always_ask" },
},
Configs =
[
new BetaManagedAgentsReadToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAlwaysAllowPolicy { Type = "always_allow" },
},
new BetaManagedAgentsWriteToolConfigParams
{
Enabled = true,
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
new BetaManagedAgentsWebFetchToolConfigParams
{
Enabled = true,
AllowedDomains = ["help.example.com"],
PermissionPolicy = new BetaManagedAgentsAutoPolicy(),
},
],
},
new BetaManagedAgentsCustomToolParams
{
Type = "custom",
Name = "lookup_order",
Description = "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema = new()
{
Properties = new Dictionary
{
["order_id"] = JsonSerializer.SerializeToElement(
new { type = "string", description = "The order ID from the ticket" }
),
},
Required = ["order_id"],
},
},
];
```
```go Go
tools := []anthropic.BetaAgentNewParamsToolUnion{{
OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
DefaultConfig: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParams{
Enabled: anthropic.Bool(false),
PermissionPolicy: anthropic.BetaManagedAgentsAgentToolsetDefaultConfigParamsPermissionPolicyUnion{
OfAlwaysAsk: &anthropic.BetaManagedAgentsAlwaysAskPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAskPolicyTypeAlwaysAsk,
},
},
},
Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
{OfRead: &anthropic.BetaManagedAgentsReadToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsReadToolConfigParamsPermissionPolicyUnion{
OfAlwaysAllow: &anthropic.BetaManagedAgentsAlwaysAllowPolicyParam{
Type: anthropic.BetaManagedAgentsAlwaysAllowPolicyTypeAlwaysAllow,
},
},
}},
{OfWrite: &anthropic.BetaManagedAgentsWriteToolConfigParams{
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWriteToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
AllowedDomains: []string{"help.example.com"},
Enabled: anthropic.Bool(true),
PermissionPolicy: anthropic.BetaManagedAgentsWebFetchToolConfigParamsPermissionPolicyUnion{
OfAuto: &anthropic.BetaManagedAgentsAutoPolicyParam{},
},
}},
},
},
}, {
OfCustom: &anthropic.BetaManagedAgentsCustomToolParams{
Type: anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
Name: "lookup_order",
Description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
InputSchema: anthropic.BetaManagedAgentsCustomToolInputSchemaParam{
Properties: map[string]any{
"order_id": map[string]any{
"type": "string",
"description": "The order ID from the ticket",
},
},
Required: []string{"order_id"},
},
},
}}
_ = tools
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.agents.*;
import java.util.List;
import java.util.Map;
var tools = List.of(
AgentCreateParams.Tool.ofAgentToolset20260401(
BetaManagedAgentsAgentToolset20260401Params.builder()
.type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
.defaultConfig(
BetaManagedAgentsAgentToolsetDefaultConfigParams.builder()
.enabled(false)
.permissionPolicy(
BetaManagedAgentsAlwaysAskPolicy.builder()
.type(BetaManagedAgentsAlwaysAskPolicy.Type.ALWAYS_ASK)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsReadToolConfigParams.builder()
.enabled(true)
.permissionPolicy(
BetaManagedAgentsAlwaysAllowPolicy.builder()
.type(BetaManagedAgentsAlwaysAllowPolicy.Type.ALWAYS_ALLOW)
.build()
)
.build()
)
.addConfig(
BetaManagedAgentsWriteToolConfigParams.builder()
.enabled(true)
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.addConfig(
BetaManagedAgentsWebFetchToolConfigParams.builder()
.enabled(true)
.allowedDomains(List.of("help.example.com"))
.permissionPolicy(BetaManagedAgentsAutoPolicy.builder().build())
.build()
)
.build()
),
AgentCreateParams.Tool.ofCustom(
BetaManagedAgentsCustomToolParams.builder()
.type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
.name("lookup_order")
.description("Look up one order by its ID. Returns the status, the items, and the delivery date.")
.inputSchema(
BetaManagedAgentsCustomToolInputSchema.builder()
.properties(
BetaManagedAgentsCustomToolInputSchema.Properties.builder()
.putAdditionalProperty("order_id", JsonValue.from(Map.of(
"type", "string",
"description", "The order ID from the ticket")))
.build()
)
.addRequired("order_id")
.build()
)
.build()
)
);
```
```php PHP
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolsetDefaultConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAllowPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAlwaysAskPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsAutoPolicy;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolInputSchema;
use Anthropic\Beta\Agents\BetaManagedAgentsCustomToolParams;
use Anthropic\Beta\Agents\BetaManagedAgentsReadToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
use Anthropic\Beta\Agents\BetaManagedAgentsWriteToolConfigParams;
$tools = [
BetaManagedAgentsAgentToolset20260401Params::with(
type: 'agent_toolset_20260401',
defaultConfig: BetaManagedAgentsAgentToolsetDefaultConfigParams::with(
enabled: false,
permissionPolicy: BetaManagedAgentsAlwaysAskPolicy::with(type: 'always_ask'),
),
configs: [
BetaManagedAgentsReadToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAlwaysAllowPolicy::with(type: 'always_allow'),
),
BetaManagedAgentsWriteToolConfigParams::with(
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
BetaManagedAgentsWebFetchToolConfigParams::with(
allowedDomains: ['help.example.com'],
enabled: true,
permissionPolicy: BetaManagedAgentsAutoPolicy::with(),
),
],
),
BetaManagedAgentsCustomToolParams::with(
type: 'custom',
name: 'lookup_order',
description: 'Look up one order by its ID. Returns the status, the items, and the delivery date.',
inputSchema: BetaManagedAgentsCustomToolInputSchema::with(
properties: ['order_id' => ['type' => 'string', 'description' => 'The order ID from the ticket']],
required: ['order_id'],
),
),
];
```
```ruby Ruby
tools = [
{
type: "agent_toolset_20260401",
default_config: {
enabled: false,
permission_policy: {type: "always_ask"}
},
configs: [
{
name: "read",
enabled: true,
permission_policy: {type: "always_allow"}
},
{
name: "write",
enabled: true,
permission_policy: {type: "auto"}
},
{
name: "web_fetch",
enabled: true,
allowed_domains: ["help.example.com"],
permission_policy: {type: "auto"}
}
]
},
{
type: "custom",
name: "lookup_order",
description: "Look up one order by its ID. Returns the status, the items, and the delivery date.",
input_schema: {
type: "object",
properties: {order_id: {type: "string", description: "The order ID from the ticket"}},
required: ["order_id"]
}
}
]
```
Uma [atualização de agente](https://platform.claude.com/docs/pt-BR/managed-agents/agent-setup#update-semantics) substitui todo o array `tools`, então envie todas as entradas que você quer manter.
Uma atualização de agente alcança apenas novas sessões, então verifique também as implantações, os agentes que listam este agente e as sessões existentes:
* Uma implantação fixa uma versão do agente, então aponte cada implantação para a nova versão.
* Um agente que lista este em [`subagents.predefined_agents`](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration#list-the-subagents) ou `workflows.predefined_agents` mantém a versão que fixou, então atualize esse agente também.
* Para restringir uma sessão que já existe, [atualize as ferramentas dessa sessão](https://platform.claude.com/docs/pt-BR/managed-agents/session-operations#updating-the-agent-configuration). A sessão precisa estar `idle`, e a atualização substitui todo o array `tools`. Em uma sessão multiagente, novas listas `allowed_domains` e `blocked_domains` nas ferramentas web do agente que a sessão executa também se aplicam a todos os outros agentes. Elas se aplicam a partir do próximo turno de cada agente. As ferramentas habilitadas e as políticas de permissão desses agentes não mudam. Para alterá-las, atualize cada agente e então inicie uma nova sessão.
Limite também os servidores MCP e as ferramentas personalizadas ao que o agente precisa:
* **Servidores MCP:** Um toolset MCP habilita por padrão todas as ferramentas que o servidor expõe. Defina `default_config.enabled` como `false` e habilite ferramentas pelo nome, para que as ferramentas que um servidor adicionar depois permaneçam desativadas. Remova os servidores que o agente não usa. Consulte [Conector MCP](https://platform.claude.com/docs/pt-BR/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).
* **Ferramentas personalizadas:** Sua aplicação as executa, e as políticas de permissão não se aplicam. Valide a entrada de cada chamada em sua aplicação e limite o que a ferramenta pode acessar.
## Manter entradas não confiáveis longe de ferramentas poderosas
Verifique quais ferramentas e credenciais um agente possui sempre que ele lê entradas não confiáveis, que são textos que alguém de fora da sua equipe pode escrever. Esta seção usa dois termos:
* **Entrada não confiável:** Páginas web, resultados de pesquisa, tickets de suporte, e-mails, arquivos de repositórios, uploads, resultados de servidores MCP e mensagens de usuários finais que você repassa.
* **Ferramentas poderosas:** `bash`, `write`, `edit`, `web_fetch`, `web_search`, ferramentas MCP e ferramentas personalizadas que gravam ou enviam dados, e qualquer ferramenta que use uma credencial.
Um texto em uma entrada não confiável pode instruir o agente a usar uma ferramenta poderosa que ele possui. O agente de suporte lê tickets, então ele alcança sua API de pedidos apenas por meio da ferramenta personalizada `lookup_order`. Sua aplicação verifica se o pedido pertence ao remetente do ticket.
| Entrada que o agente lê | Poder que ele também tem | Faça isto |
| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tickets, e-mails ou uploads | `bash` com uma credencial | Substitua `bash` por uma ferramenta personalizada que faça uma única coisa. Se o agente precisar manter `bash`, aprove cada chamada com `always_ask` |
| Páginas web ou resultados de pesquisa | Gravar arquivos ou alterar registros | Desative as ferramentas web ou limite-as a sites que você opera ou em que confia |
| Resultados MCP ou arquivos de repositórios | Ferramentas MCP que gravam | Mantenha o toolset MCP em `always_ask` e habilite apenas as ferramentas de que o agente precisa |
| Um repositório do GitHub montado | Qualquer ferramenta | Monte apenas repositórios em que você confia. Um agente com `read` carrega skills do diretório `.claude/skills` do repositório como instruções do agente, sem etapa de revisão. Consulte [Carregar skills de um repositório GitHub](https://platform.claude.com/docs/pt-BR/managed-agents/skills#load-skills-from-a-github-repository) |
| Qualquer entrada não confiável | Gravar em um [memory store](https://platform.claude.com/docs/pt-BR/managed-agents/memory#attach-a-memory-store-to-a-session) | Anexe o store como `read_only`, a menos que o agente precise gravar. O padrão é `read_write`, e sessões posteriores leem o texto salvo como memória confiável |
Em um ambiente em nuvem, ler um arquivo com `read` também pode carregar arquivos `CLAUDE.md` e `AGENTS.md` como instruções. Eles são carregados do diretório do arquivo e de seus diretórios pais, até o diretório de trabalho do sandbox. Arquivos que eles referenciam com `@` e um caminho, como `@docs/setup.md`, também são carregados, até cinco níveis de referência. Uma referência pode apontar para qualquer lugar no sandbox, por exemplo `@/etc/hosts`. Nenhuma configuração desativa isso, exceto desabilitar `read`, então trate um repositório, pacote ou arquivo compactado que alguém de fora da sua equipe pode escrever como entrada não confiável.
Quando um agente precisa ler entradas não confiáveis e também agir, este guia recomenda um de três designs:
* **Separe a leitura da ação.** Em uma sessão multiagente, um [agente líder](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration#list-the-subagents) atribui tarefas a um buscador, que lê a web, e a um escritor, que altera arquivos ou registros.
* **Dê ao agente uma única ferramenta personalizada restrita.** Sua aplicação executa a ferramenta, verifica sua entrada e mantém a credencial. O agente de suporte usa este design, não a separação. Consulte [Responder a chamadas de ferramenta que pausam a sessão](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).
* **Mantenha uma pessoa no processo.** Use `always_ask` na ferramenta poderosa para que uma pessoa aprove cada chamada.
A separação usa três agentes:
| Agente | Lê | Possui | Repassa |
| ------------------------------------- | ------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| Líder (o agente que a sessão executa) | Sua mensagem e o que os outros agentes enviam de volta | Nenhuma ferramenta integrada. Sua lista `subagents.predefined_agents` nomeia o buscador e o escritor | Uma tarefa para cada agente |
| Buscador | Páginas web e resultados de pesquisa | Apenas `web_fetch` e `web_search`, cada uma com `allowed_domains` | Resultados curtos, em um formato que você solicita no prompt do sistema dele |
| Escritor | A tarefa do líder | As ferramentas que gravam arquivos, executam comandos ou alteram registros, em `auto` ou `always_ask`. Nenhuma ferramenta web | Seu resultado |
Os resultados do buscador são construídos a partir de páginas não confiáveis, e o líder pode repassar o texto deles ao escritor. Mantenha `auto` ou `always_ask` nas ferramentas do escritor. O buscador ainda pode enviar parte do que lê aos sites em sua lista de `web_fetch` e ao provedor de pesquisa em suas consultas.
Os agentes em uma sessão multiagente [compartilham o sandbox](https://platform.claude.com/docs/pt-BR/managed-agents/multiagent-orchestration#how-it-works), seus arquivos e as credenciais do vault, então essa separação isola apenas suas ferramentas e conversas. Para uma separação mais forte, use duas sessões com ambientes e vaults separados. Faça sua aplicação repassar apenas campos fixos, como um ID de pedido, entre as duas sessões.
## Definir limites e uma forma de parar
Defina um orçamento ao criar cada sessão e decida com antecedência como você vai parar um agente.
| Controle | O que ele faz |
| ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Orçamento da sessão | Um teto de gastos com base nos preços de lista públicos. No teto, a sessão e cada [thread](https://platform.claude.com/docs/pt-BR/managed-agents/session-threads) pausam. Requisições em andamento podem terminar e suas chamadas de ferramentas ainda são executadas, então os gastos podem ultrapassar o teto. Consulte [Quando uma sessão atinge seu orçamento](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#when-a-session-reaches-its-budget) |
| Orçamento da implantação | O mesmo teto, aplicado a cada sessão que uma implantação inicia |
| [Evento `user.interrupt`](https://platform.claude.com/docs/pt-BR/managed-agents/events-and-streaming#interrupt-the-agent) | Interrompe a resposta do modelo imediatamente. Uma chamada de ferramenta em execução pode terminar primeiro. A sessão fica `idle`, a menos que uma execução de workflow a mantenha `running`, e é retomada na sua próxima mensagem. Uma interrupção não encerra nenhuma execução de workflow |
| Arquivar ou excluir uma sessão | Arquivar mantém o histórico e bloqueia novos eventos. Excluir remove o registro, os eventos e o sandbox |
| Pausar ou arquivar uma implantação | Pausar interrompe novas execuções agendadas, mas ainda permite execuções manuais. Arquivar encerra o agendamento permanentemente. As sessões já em execução continuam em execução |
| Arquivar ou excluir um vault ou uma credencial | Remove o segredo das sessões em execução sem reinicialização. Considere um atraso. As sessões continuam em execução, então interrompa-as também. Um token que o agente já obteve com o segredo permanece no sandbox |
Para parar um agente em execução, siga estas etapas:
1. Envie `user.interrupt` sozinho.
2. Para um agente agendado, pause também a implantação para que nenhuma nova execução agendada seja iniciada. Para encerrar o agendamento permanentemente, arquive a implantação.
3. Se uma chave puder estar exposta, faça a rotação dela no serviço que a emitiu.
4. Se o agente tiver execuções de workflow abertas, envie também uma `user.message` pedindo que ele as interrompa, porque uma interrupção não encerra nenhuma execução. Consulte [Interromper uma sessão com execuções abertas](https://platform.claude.com/docs/pt-BR/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) para ver as chamadas de ferramentas a cancelar primeiro.
5. Aguarde a sessão ficar `idle`. Uma sessão em execução não pode ser arquivada nem excluída.
6. Arquive a sessão para manter seu histórico. Exclua-a quando não precisar mais do histórico.
Uma interrupção não desfaz o que o agente já fez ou enviou. Arquivar um agente não interrompe suas sessões em execução.
O `max_list_cost.amount` de um orçamento é um número inteiro de centavos de dólar americano escrito como string, então `"125"` significa $1,25. Consulte [Definir um orçamento na criação da sessão](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#set-a-budget-at-session-creation).
Você não pode adicionar um orçamento a uma sessão criada sem um. Para alterar ou remover um teto, consulte [Retomar uma sessão em seu orçamento](https://platform.claude.com/docs/pt-BR/managed-agents/budgets#resume-a-session-at-its-budget). Depois de remover o teto de uma sessão, você não pode definir um novo.
Um orçamento limita os gastos, mas não limita o que o agente faz antes de atingir o teto. Para manter separadas cargas de trabalho com diferentes níveis de confiança, use [workspaces](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces) separados. Dê a cada carga de trabalho uma chave de API com escopo para um único workspace, porque uma chave que pode alcançar vários workspaces pode agir em qualquer um deles.
Consulte [Orçamentos de sessão](https://platform.claude.com/docs/pt-BR/managed-agents/budgets), [Operações de sessão](https://platform.claude.com/docs/pt-BR/managed-agents/session-operations#archiving-a-session) e [Implantações agendadas](https://platform.claude.com/docs/pt-BR/managed-agents/scheduled-deployments#managing-deployment-lifecycle).
## Próximos passos
Modos de rede, hosts permitidos e gerenciadores de pacotes.
Políticas de aprovação e solicitações de confirmação.
Tipos de credenciais, locais de injeção e rotação.
Tetos, retomada em um orçamento e orçamentos em implantações.