---
title: Protege tu implementación de Managed Agents
url: https://platform.claude.com/docs/es/managed-agents/secure-deployment
description: Las opciones de configuración que limitan lo que tus agentes pueden alcanzar y hacer, de la más importante a la menos importante.
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Esta guía enumera las opciones de configuración que limitan lo que un agente en Claude Managed Agents puede alcanzar y hacer, de la más importante a la menos importante. Cada sección enlaza a la página que cubre la configuración en detalle.
| Sección | Configuración o decisión | Recomendado |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Elige dónde se ejecuta el agente](https://platform.claude.com/docs/es/managed-agents/secure-deployment#choose-where-the-agent-runs) | Sandbox en la nube o autoalojado | En la nube, a menos que las herramientas deban ejecutarse en infraestructura que tú controlas |
| [Limita la red](https://platform.claude.com/docs/es/managed-agents/secure-deployment#limit-the-network) | `networking.type` del entorno | `limited`, solo con los hosts que el agente necesita |
| [Guarda las credenciales en vaults](https://platform.claude.com/docs/es/managed-agents/secure-deployment#keep-credentials-in-vaults) | `injection_location` y `networking` en cada credencial de variable de entorno | Solo encabezados de solicitud, y red `limited` solo con los hosts para los que es la clave |
| [Restringe la búsqueda web y la obtención web](https://platform.claude.com/docs/es/managed-agents/secure-deployment#restrict-web-search-and-web-fetch) | `allowed_domains` en cada herramienta web | Una lista de permitidos en cada herramienta. En `web_fetch`, incluye solo los sitios que el agente necesita. En `web_search`, incluye los sitios de los que quieres obtener resultados |
| [Aprueba las acciones riesgosas](https://platform.claude.com/docs/es/managed-agents/secure-deployment#approve-risky-actions) | `permission_policy` en cada herramienta | `auto` en `bash`, `write`, `edit`, `web_fetch` y las herramientas MCP que solo leen datos. En su lugar, `always_ask` en una herramienta si no puedes deshacer sus cambios fuera del sandbox, o si el texto de usuario final que retransmites no debería bastar por sí solo para que se ejecute |
| [Dale al agente el conjunto de herramientas más pequeño](https://platform.claude.com/docs/es/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) | `default_config.enabled` en el conjunto de herramientas del agente | `false`, y luego habilita las herramientas que el agente necesita |
| [Mantén la entrada no confiable lejos de las herramientas potentes](https://platform.claude.com/docs/es/managed-agents/secure-deployment#keep-untrusted-input-away-from-powerful-tools) | Qué herramientas y credenciales tiene un agente cuando lee entrada no confiable | Ningún agente que lea entrada no confiable tiene en `always_allow` una herramienta que escriba archivos, ejecute comandos o modifique registros |
| [Establece límites y una forma de detenerlo](https://platform.claude.com/docs/es/managed-agents/secure-deployment#set-limits-and-a-way-to-stop) | `budget` en cada sesión e implementación | Un tope dimensionado según lo que esperas que cueste una ejecución |
| [Opcionalmente, haz que un revisor sin conexión lea cada transcripción](https://platform.claude.com/docs/es/managed-agents/secure-deployment-monitoring#optionally-have-an-offline-reviewer-read-every-transcript) | Un trabajo de revisión sin conexión que ejecutas tú y que lee los eventos de cada sesión | Opcional. Una revisión programada de cada sesión que quedó inactiva o terminó |
| [Supervisa las sesiones y revisa la retención](https://platform.claude.com/docs/es/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention) | Webhooks y eliminación de sesiones | Una alerta cuando una sesión queda inactiva, alcanza su presupuesto o termina, y una comprobación de por qué quedó inactiva. Almacena los eventos que quieras conservar en tus propios registros y elimina las sesiones que ya no necesites |
[Riesgos de seguridad y límites del sandbox](https://platform.claude.com/docs/es/managed-agents/secure-deployment-risks) explica por qué importa esta configuración y contra qué no protege. Para revisar y supervisar sesiones, consulta [Revisar y supervisar sesiones de agentes](https://platform.claude.com/docs/es/managed-agents/secure-deployment-monitoring).
## Elige dónde se ejecuta el agente
El lugar donde se ejecutan las herramientas del agente decide quién protege el sandbox: Anthropic, con un entorno en la nube, o tú, con un sandbox autoalojado. Para elegir entre ellos y saber qué llega a Anthropic con cada uno, consulta [Elegir un entorno para el agente](https://platform.claude.com/docs/es/managed-agents/choosing-an-environment).
Si usas un [sandbox autoalojado](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes), ten en cuenta estos cuatro puntos:
* **Red:** [Limita la red](https://platform.claude.com/docs/es/managed-agents/secure-deployment#limit-the-network) se aplica a los entornos en la nube. Para un sandbox autoalojado, establece los límites equivalentes sobre su tráfico en tu propio firewall. Tu firewall no limita los servidores MCP que declara un agente, así que revísalos, junto con los que tu aplicación establezca para una sesión.
* **Herramientas web:** Las herramientas web se ejecutan en los servidores de Anthropic, por lo que tu firewall no las limita. Limítalas con sus listas de dominios. Consulta [Restringe la búsqueda web y la obtención web](https://platform.claude.com/docs/es/managed-agents/secure-deployment#restrict-web-search-and-web-fetch).
* **Credenciales:** Las credenciales de variables de entorno aún no son compatibles con los sandboxes autoalojados.
* **Aislamiento y endurecimiento:** Eres responsable de ambos. Consulta el [Modelo de seguridad](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-security).
Ninguna de las dos opciones cambia la cobertura de cumplimiento de Managed Agents ni el tiempo que conserva el historial de la sesión. Consulta [Supervisa las sesiones y revisa la retención](https://platform.claude.com/docs/es/managed-agents/secure-deployment-monitoring#monitor-sessions-and-review-retention).
## Limita la red
Establece `networking.type` en `limited` e incluye en `allowed_hosts` solo los hosts que el agente necesita. Una solicitud de creación de entorno que omite `networking` podría obtener `unrestricted`, así que establece `networking` en cada solicitud de creación. Consulta [Riesgos de las redes sin restricciones](https://platform.claude.com/docs/es/managed-agents/environments#risks-of-unrestricted-networking).
Los archivos, los almacenes de memoria y los repositorios de GitHub que adjuntes siguen disponibles para el agente independientemente de `allowed_hosts`.
Los ejemplos de esta página usan un agente de soporte. Lee el ticket de un cliente, busca el pedido, lee tu centro de ayuda y redacta una respuesta. Tu aplicación ejecuta la búsqueda del pedido, que no necesita ningún host, así que este entorno permite un solo host, el centro de ayuda, 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"]
}
}
)
```
Un entorno `limited` tiene tres opciones de red:
| Opción | Qué abre al código en el sandbox | Recomendado |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowed_hosts` | Los hosts que incluyas, para cualquier solicitud | Solo los hosts que el agente necesita, incluido el host de cada servidor MCP que operas o en el que confías |
| `allow_package_managers` | Los [hosts de gestores de paquetes](https://platform.claude.com/docs/es/managed-agents/environments#package-manager-hosts). Incluyen todos los repositorios y rutas de `github.com`, `gitlab.com` y `bitbucket.org`, donde cualquiera puede publicar contenido y donde el código en el sandbox puede subir archivos | `false`, a menos que la opción `packages` del entorno incluya paquetes, lo que requiere `true`. Si el agente instala paquetes mientras se ejecuta, incluye en su lugar en `allowed_hosts` solo los hosts de registro que necesita |
| `allow_mcp_servers` | Ningún host. Managed Agents se conecta a los servidores MCP desde los servidores de Anthropic | `false`, con el host de cada servidor MCP que operas o en el que confías incluido en `allowed_hosts` |
Las opciones `allow_package_managers` y `allow_mcp_servers` no añaden hosts para la búsqueda web ni la obtención web.
Deja `allow_mcp_servers` desactivado, que es el valor predeterminado, e incluye en `allowed_hosts` el host de cada servidor MCP que operas o en el que confías. Cada host que incluyas también queda abierto al código en el sandbox. Con `allow_mcp_servers` desactivado, una comprobación al crear la sesión rechaza la solicitud si el host de un servidor MCP no está en la lista. Consulta [Proporcionar autenticación al crear la sesión](https://platform.claude.com/docs/es/managed-agents/mcp-connector#provide-authentication-at-session-creation). La misma comprobación se ejecuta cuando una actualización de sesión cambia `mcp_servers`.
El acceso a la red se concede por host, no por operación. El sandbox puede enviar cualquier solicitud a un host permitido, incluidas subidas como `git push` y la publicación de paquetes. También puede usar cualquier credencial que proporcione el comando, incluso una que alguien haya ocultado en un texto que lee el agente.
Cuando elijas hosts para `allowed_hosts`, sigue estas dos reglas:
* Incluye solo hosts que operas o en los que confías.
* Evita los comodines `*.` y los dominios de alojamiento compartido donde cualquiera puede publicar contenido.
Si el agente conserva `bash`, establece la [política de permisos](https://platform.claude.com/docs/es/managed-agents/permission-policies) de la herramienta `bash` como se describe en [Aprueba las acciones riesgosas](https://platform.claude.com/docs/es/managed-agents/secure-deployment#approve-risky-actions).
Después de restringir un entorno, inicia sesiones nuevas y detén las que ya estaban en ejecución. Una sesión que ya está en ejecución puede conservar los límites anteriores hasta que termine. Consulta [Establece límites y una forma de detenerlo](https://platform.claude.com/docs/es/managed-agents/secure-deployment#set-limits-and-a-way-to-stop).
Consulta [Configuración del entorno en la nube](https://platform.claude.com/docs/es/managed-agents/environments#networking) para ver todas las opciones de red.
## Guarda las credenciales en vaults
Almacena cada secreto en un vault. Para cada credencial de variable de entorno, establece la ubicación de inyección solo en los encabezados de solicitud e incluye solo los hosts para los que es el secreto. El código en el sandbox ve un marcador de posición en lugar del secreto. Managed Agents sustituye el marcador de posición por el secreto real solo en las solicitudes HTTPS salientes a los hosts que permite la credencial. Así, el secreto queda fuera del alcance directo del modelo, a menos que un servicio lo devuelva, como un endpoint que repite los encabezados de la solicitud. Si el `networking` de la credencial es `unrestricted`, Managed Agents sustituye el marcador de posición por el secreto real en las solicitudes a cualquier host al que el entorno permita que acceda el sandbox. Para usar un vault, pasa su ID en `vault_ids` cuando crees la sesión o la implementación.
| Opción | Establécela en | Por qué | Lo que no hace |
| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `injection_location` | `{"header": true, "body": false}`, después de comprobar que el servicio lee la clave desde un encabezado | Los cuerpos de las solicitudes suelen construirse a partir del contenido que lee el agente, así que una clave en un cuerpo está más expuesta. Indica ambos campos: una solicitud de creación que omite el objeto habilita ambas ubicaciones, y una actualización cambia solo los campos que envías | El código aún puede usar la clave en todos los hosts que permite la credencial. Un servicio que espera la clave en el cuerpo recibe el marcador de posición y rechaza la solicitud |
| `networking` en la credencial | `limited`, con los hosts exactos para los que es la clave | Las respuestas llegan al sandbox sin redactar, así que evita los comodines, los dominios de alojamiento compartido y los hosts que repiten los encabezados de la solicitud | No abre el host. El entorno también debe permitirlo |
| Los permisos de la clave, en el servicio que la emitió | Solo los permisos que el agente necesita | El agente puede hacer cualquier cosa que la clave permita | No aplica |
| El token de GitHub de un repositorio montado | Un [token de grano fino](https://platform.claude.com/docs/es/managed-agents/github#token-permissions) con los permisos mínimos | El código en el sandbox puede usarlo para hacer fetch y push en el repositorio montado durante toda la sesión. Concede acceso de escritura solo si el agente debe hacer push | No aplica |
El agente de soporte no necesita ninguna credencial de vault, porque tu aplicación tiene la clave de API de tu API de pedidos. Si tu agente sí tiene una credencial de vault, consulta [Agregar una credencial](https://platform.claude.com/docs/es/managed-agents/vaults#add-a-credential) para ver la solicitud en todos los lenguajes.
Mantén las claves fuera de las indicaciones del sistema, las definiciones de agentes y los mensajes. No le des al agente una clave de API de Claude. Incluso cuando una clave de API de Claude está en un vault, el código en el sandbox puede usarla para llamar directamente a la API de Claude. Puede hacer cualquier cosa que esa clave permita, como iniciar o eliminar sesiones, o usar la búsqueda web y la obtención web. La configuración de herramientas, las aprobaciones y el presupuesto del agente no se aplican a esas llamadas. En un entorno `limited`, el código puede hacer estas llamadas solo si `allowed_hosts` permite que el sandbox llegue a `api.anthropic.com`.
Obtén los tokens tú mismo y guárdalos en el vault, porque un token que el código en el sandbox obtiene con un secreto almacenado vuelve sin redactar.
Mantén los vaults de cargas de trabajo con distintos niveles de confianza en [espacios de trabajo](https://platform.claude.com/docs/es/manage-claude/workspaces) separados, porque cualquier clave de API con acceso a un espacio de trabajo puede hacer referencia a sus vaults. Usa claves de API limitadas a un solo espacio de trabajo.
Consulta [Autenticar con vaults](https://platform.claude.com/docs/es/managed-agents/vaults) para las credenciales de MCP y la rotación.
## Restringe la búsqueda web y la obtención web
Establece `allowed_domains` en `web_fetch` con los sitios que el agente necesita. Cualquier URL que obtenga el agente puede llevar datos al sitio al que apunta, así que esta lista es un control de seguridad. En `web_search`, establece `allowed_domains` con los sitios de los que quieres obtener resultados, para que los resultados provengan solo de sitios en cuya exactitud confías. La lista no impide que la consulta de búsqueda llegue al proveedor de búsqueda. Los resultados de búsqueda incluyen texto de las páginas, así que la lista también limita de qué sitios llega texto al agente. Establece `allowed_domains` en ambas herramientas para todo tipo de entorno.
Una lista `blocked_domains` bloquea los hosts que incluyes y sus subdominios, y ningún otro host. El mismo contenido aún puede llegar al agente desde archivos históricos de la web, cachés, espejos o dominios relacionados que no incluiste. No dependas de `blocked_domains` para la seguridad. Usa `allowed_domains` e indica los hosts en los que confías.
En un entorno `limited`, la lista `allowed_hosts` de [Limita la red](https://platform.claude.com/docs/es/managed-agents/secure-deployment#limit-the-network) también limita las herramientas web. Un entorno `unrestricted` o un sandbox autoalojado no limita las herramientas web.
| En un entorno `limited` | Resultado |
| ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Una entrada de `allowed_domains` en una herramienta web habilitada está fuera de `allowed_hosts` | La creación de una sesión falla con un error 400, y también una actualización de sesión que añade una entrada así. Una sesión que inicia una implementación, según su programación o mediante una ejecución manual, se crea de todos modos. La herramienta entonces no devuelve nada de los hosts fuera de `allowed_hosts` |
| Una herramienta web no tiene lista propia | La herramienta devuelve páginas y resultados solo de los hosts en `allowed_hosts`. Establece también `allowed_domains` en la herramienta |
| `allowed_hosts` no tiene entradas | Ninguna de las herramientas web devuelve una página ni un resultado de búsqueda |
| Añades un host a `allowed_hosts` para una herramienta web | El host también queda abierto al código en el sandbox |
Las dos listas coinciden con los hosts de forma diferente:
| Lista | Entrada | Coincide con | No coincide con |
| ----------------------------------- | --------------- | ------------------------------------- | ----------------- |
| `allowed_hosts` (entorno) | `example.com` | `example.com` | `www.example.com` |
| `allowed_hosts` (entorno) | `*.example.com` | Todos los subdominios | `example.com` |
| `allowed_domains` (herramienta web) | `example.com` | `example.com` y todos los subdominios | Otros dominios |
Si el agente necesita un sitio y todos sus subdominios, incluye tanto `example.com` como `*.example.com` en `allowed_hosts`; de lo contrario, incluye hosts exactos. Si una herramienta incluye `example.com` y `allowed_hosts` incluye solo `*.example.com`, la sesión se crea. La comprobación al crear la sesión considera que `example.com` está dentro de `*.example.com`, pero la herramienta no devuelve nada del propio `example.com`. Consulta [Establecer listas de dominios en un agente](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions#set-domain-lists-on-an-agent) para ver cómo coinciden las dos listas.
La herramienta `web_fetch` además solo abre URLs que ya han aparecido en la sesión:
| Dónde aparece la URL | `web_fetch` puede abrirla |
| ---------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| El texto de un mensaje de usuario, incluido el texto de usuario final que retransmites | Sí |
| La descripción de un evento `user.define_outcome` | Sí |
| La dirección de un resultado de búsqueda web | Sí |
| El texto de una página que `web_fetch` devolvió antes (no un PDF), donde se muestra la URL completa | Sí |
| El texto del resultado de una herramienta personalizada, cuando Claude llamó a la herramienta directamente | Sí, a menos que el resultado esté marcado con `is_error: true` |
| La indicación del sistema | No |
| La configuración del agente, incluidas las entradas de `allowed_domains` | No |
| La propia salida de Claude | No |
| La salida de `bash` y de las demás herramientas del sandbox | No |
| El resultado de una herramienta MCP | No |
| Un archivo adjunto a un mensaje de usuario | No |
En una sesión multiagente, `web_fetch` abre una URL de otro agente solo si llegó a ese agente a través de una fuente marcada con Sí. El resultado de una herramienta personalizada de una llamada directa cuenta como una fuente marcada con Sí. Esto se cumple incluso si Claude escribió su texto, por ejemplo cuando la herramienta repite su entrada. Una URL puede contar incluso cuando está escrita sin `https://`, como `example.com/docs`. La herramienta `web_fetch` no siempre puede abrir un enlace que muestra palabras en lugar de su URL, como "Contactar con soporte". Si el agente debe obtener una URL que no ha aparecido en la sesión, envíala en un mensaje de usuario.
Esta regla reduce la probabilidad de que un texto inyectado construya una URL que lleve datos privados. El texto de usuario final, los resultados de búsqueda, las páginas obtenidas y los resultados de herramientas personalizadas aún pueden añadir URLs, así que mantén `allowed_domains` establecido. La Messages API aplica una regla similar con una lista de fuentes diferente. Consulta [Validación de URLs](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#url-validation).
Una lista de dominios en `web_fetch` no limita la herramienta `bash`. [Limita la red](https://platform.claude.com/docs/es/managed-agents/secure-deployment#limit-the-network) también. Consulta [Reglas de las listas de dominios](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions#domain-list-rules).
## Aprueba las acciones riesgosas
Establece `auto` en `bash`, `write`, `edit` y `web_fetch`, y en las herramientas MCP que solo leen datos. Usa `always_ask` en su lugar en una herramienta si no puedes deshacer sus cambios fuera del sandbox. Úsalo también en una herramienta que no debería ejecutarse solo porque lo pida el texto de usuario final que retransmites. Una [política de permisos](https://platform.claude.com/docs/es/managed-agents/permission-policies) determina si una llamada a una herramienta se ejecuta, espera tu aprobación o la evalúa el servidor.
| Herramienta | Política recomendada | Por qué |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read`, `glob`, `grep` | `always_allow` | Leen archivos en el sandbox y no cambian nada |
| `bash`, `write`, `edit` | `auto`. Usa `always_ask` en una herramienta si no puedes deshacer sus cambios fuera del sandbox. Usa `always_ask` en `bash` si retransmites texto de usuario final | El valor predeterminado del conjunto de herramientas del agente es `always_allow`, que ejecuta cada llamada sin aprobación |
| `web_fetch` | `auto` | Una URL que obtiene el agente puede llevar datos al sitio al que apunta |
| `web_search` | `always_ask` si el agente maneja datos que no querrías que se enviaran en una consulta de búsqueda. De lo contrario, `always_allow` | `allowed_domains` limita de qué sitios provienen los resultados, no lo que contiene la consulta |
| Herramientas MCP que solo leen datos | `auto`, establecido para cada herramienta en los `configs` del conjunto de herramientas | El valor predeterminado del conjunto de herramientas sigue siendo `always_ask`, así que una herramienta que el servidor MCP añada más adelante sigue esperando aprobación |
| Herramientas MCP que modifican datos | `always_ask` | Es el valor predeterminado del conjunto de herramientas MCP. Consérvalo |
| Herramientas personalizadas | Tu código decide si se ejecuta cada llamada | Las políticas de permisos no se aplican |
El conjunto de herramientas de [Dale al agente el conjunto de herramientas más pequeño](https://platform.claude.com/docs/es/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set) aplica estas políticas.
La [política `auto`](https://platform.claude.com/docs/es/managed-agents/permission-policies#let-the-server-evaluate-each-call-with-auto) permite que el servidor ejecute una llamada, la deniegue o se detenga para pedir aprobación. Una persona no puede aprobar cada llamada en una ejecución larga, así que el servidor comprueba cada una en su lugar. Combina `auto` con red limitada, una clave con permisos reducidos, un presupuesto y una alerta sobre sesiones inactivas. `auto` no es un punto de control humano, así que si una persona debe revisar las llamadas de una herramienta antes de que se ejecuten, configura `always_ask` en esa herramienta.
`auto` trata el texto de los eventos `user.message` y la descripción de un evento `user.define_outcome` como tu instrucción, incluido el texto de usuario final que retransmites.
Una sesión en pausa espera indefinidamente, así que una sesión desatendida necesita un cliente que responda a las llamadas en pausa o interrumpa la sesión.
Revisa cada llamada en pausa antes de permitirla. Un cliente que permite cada llamada sin mostrársela a una persona equivale a `always_allow`. Consulta [Responder a solicitudes de confirmación](https://platform.claude.com/docs/es/managed-agents/permission-policies#respond-to-confirmation-requests) y [Ver cómo se evaluó cada llamada](https://platform.claude.com/docs/es/managed-agents/permission-policies#see-how-each-call-was-evaluated).
## Dale al agente el conjunto de herramientas más pequeño
Establece `default_config.enabled` en `false` y [habilita solo las herramientas que el agente necesita](https://platform.claude.com/docs/es/managed-agents/tools#enabling-only-specific-tools). El conjunto de herramientas del agente habilita las ocho herramientas integradas de forma predeterminada.
| Herramienta | Qué hace |
| ------------------------- | --------------------------------------------------------------------------------------------- |
| `bash` | Ejecuta cualquier comando, incluidas solicitudes a hosts permitidos |
| `write`, `edit` | Modifican archivos en el sandbox |
| `read`, `glob`, `grep` | Leen archivos en el sandbox |
| `web_fetch`, `web_search` | Devuelven páginas y resultados de búsqueda de la web, a través de los servidores de Anthropic |
El agente de soporte necesita tres herramientas integradas: `read` y `write` para su borrador, y `web_fetch` para el centro de ayuda. Busca pedidos mediante una [herramienta personalizada](https://platform.claude.com/docs/es/managed-agents/tools#custom-tools), `lookup_order`, que ejecuta tu aplicación. Tu aplicación tiene la clave de API de tu API de pedidos, así que el agente no necesita ni `bash` ni una credencial.
El siguiente ejemplo limita `web_fetch` a `help.example.com` con `allowed_domains`. Establece `auto` en `write` y `web_fetch`, como recomienda [Aprueba las acciones riesgosas](https://platform.claude.com/docs/es/managed-agents/secure-deployment#approve-risky-actions). Si el ticket de un cliente lleva al agente a usar estas herramientas, el agente solo puede modificar archivos en el sandbox o abrir páginas del centro de ayuda. Por eso ninguna de las dos herramientas necesita `always_ask`. El ejemplo también establece `always_ask` en `default_config`, de modo que una herramienta que habilites más adelante sin su propia política 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"]
}
}
]
```
Una [actualización del agente](https://platform.claude.com/docs/es/managed-agents/agent-setup#update-semantics) reemplaza todo el arreglo `tools`, así que envía todas las entradas que quieras conservar.
Una actualización del agente solo llega a las sesiones nuevas, así que revisa también las implementaciones, los agentes que incluyen a este agente y las sesiones existentes:
* Una implementación fija una versión del agente, así que apunta cada implementación a la nueva.
* Un agente que incluye a este en [`subagents.predefined_agents`](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration#list-the-subagents) o `workflows.predefined_agents` conserva la versión que fijó, así que actualiza también ese agente.
* Para restringir una sesión que ya existe, [actualiza las herramientas de esa sesión](https://platform.claude.com/docs/es/managed-agents/session-operations#updating-the-agent-configuration). La sesión debe estar `idle`, y la actualización reemplaza todo el arreglo `tools`. En una sesión multiagente, las nuevas listas `allowed_domains` y `blocked_domains` en las herramientas web del agente que ejecuta la sesión también se aplican a todos los demás agentes. Se aplican a partir del siguiente turno de cada agente. Las herramientas habilitadas y las políticas de permisos de esos agentes no cambian. Para cambiarlas, actualiza cada agente y luego inicia una sesión nueva.
Limita también los servidores MCP y las herramientas personalizadas a lo que el agente necesita:
* **Servidores MCP:** Un conjunto de herramientas MCP habilita de forma predeterminada todas las herramientas que expone el servidor. Establece `default_config.enabled` en `false` y habilita herramientas por nombre, para que las herramientas que un servidor añada más adelante permanezcan desactivadas. Elimina los servidores que el agente no usa. Consulta [Conector MCP](https://platform.claude.com/docs/es/managed-agents/mcp-connector#configure-which-mcp-tools-are-available).
* **Herramientas personalizadas:** Las ejecuta tu aplicación, y las políticas de permisos no se aplican. Valida la entrada de cada llamada en tu aplicación y limita lo que la herramienta puede tocar.
## Mantén la entrada no confiable lejos de las herramientas potentes
Comprueba qué herramientas y credenciales tiene un agente siempre que lea entrada no confiable, que es texto que puede escribir alguien ajeno a tu equipo. Esta sección usa dos términos:
* **Entrada no confiable:** Páginas web, resultados de búsqueda, tickets de soporte, correos electrónicos, archivos de repositorios, archivos subidos, resultados de servidores MCP y mensajes de usuarios finales que retransmites.
* **Herramientas potentes:** `bash`, `write`, `edit`, `web_fetch`, `web_search`, las herramientas MCP y las herramientas personalizadas que escriben o envían datos, y cualquier herramienta que use una credencial.
El texto de una entrada no confiable puede indicarle al agente que use una herramienta potente que tiene. El agente de soporte lee tickets, así que solo llega a tu API de pedidos a través de la herramienta personalizada `lookup_order`. Tu aplicación comprueba que el pedido pertenece al remitente del ticket.
| Entrada que lee el agente | Capacidad que también tiene | Haz esto |
| ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Tickets, correos electrónicos o archivos subidos | `bash` con una credencial | Reemplaza `bash` por una herramienta personalizada que haga una sola cosa. Si el agente debe conservar `bash`, aprueba cada llamada con `always_ask` |
| Páginas web o resultados de búsqueda | Escribir archivos o modificar registros | Desactiva las herramientas web o limítalas a sitios que operas o en los que confías |
| Resultados de MCP o archivos de repositorios | Herramientas MCP que escriben | Mantén el conjunto de herramientas MCP en `always_ask` y habilita solo las herramientas que el agente necesita |
| Un repositorio de GitHub montado | Cualquier herramienta | Monta solo repositorios en los que confías. Un agente con `read` carga skills desde el directorio `.claude/skills` del repositorio como instrucciones del agente, sin ningún paso de revisión. Consulta [Cargar skills desde un repositorio de GitHub](https://platform.claude.com/docs/es/managed-agents/skills#load-skills-from-a-github-repository) |
| Cualquier entrada no confiable | Escribir en un [almacén de memoria](https://platform.claude.com/docs/es/managed-agents/memory#attach-a-memory-store-to-a-session) | Adjunta el almacén como `read_only` a menos que el agente deba escribir. El valor predeterminado es `read_write`, y las sesiones posteriores leen el texto guardado como memoria de confianza |
En un entorno en la nube, leer un archivo con `read` también puede cargar archivos `CLAUDE.md` y `AGENTS.md` como instrucciones. Se cargan desde el directorio del archivo y sus directorios padre, hasta el directorio de trabajo del sandbox. Los archivos a los que hacen referencia con `@` y una ruta, como `@docs/setup.md`, también se cargan, hasta cinco niveles de referencias. Una referencia puede apuntar a cualquier lugar del sandbox, por ejemplo `@/etc/hosts`. Ninguna opción desactiva esto salvo deshabilitar `read`, así que trata como entrada no confiable un repositorio, paquete o archivo comprimido que pueda escribir alguien ajeno a tu equipo.
Cuando un agente debe leer entrada no confiable y también actuar, esta guía recomienda uno de tres diseños:
* **Separa la lectura de la acción.** En una sesión multiagente, un [agente principal](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration#list-the-subagents) asigna tareas a un agente de obtención, que lee la web, y a un agente de escritura, que modifica archivos o registros.
* **Dale al agente una única herramienta personalizada acotada.** Tu aplicación ejecuta la herramienta, comprueba su entrada y tiene la credencial. El agente de soporte usa este diseño, no la separación. Consulta [Responder a llamadas a herramientas que pausan la sesión](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#answer-tool-calls-that-pause-the-session).
* **Mantén a una persona en el proceso.** Usa `always_ask` en la herramienta potente para que una persona apruebe cada llamada.
La separación usa tres agentes:
| Agente | Lee | Tiene | Transmite |
| ------------------------------------------- | -------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| Principal (el agente que ejecuta la sesión) | Tu mensaje y lo que le devuelven los otros agentes | Ninguna herramienta integrada. Su lista `subagents.predefined_agents` nombra al agente de obtención y al de escritura | Una tarea a cada agente |
| Agente de obtención | Páginas web y resultados de búsqueda | Solo `web_fetch` y `web_search`, cada una con `allowed_domains` | Resultados breves, en un formato que pides en su indicación del sistema |
| Agente de escritura | La tarea del agente principal | Las herramientas que escriben archivos, ejecutan comandos o modifican registros, en `auto` o `always_ask`. Ninguna herramienta web | Su resultado |
Los resultados del agente de obtención se construyen a partir de páginas no confiables, y el agente principal puede transmitir su texto al agente de escritura. Mantén `auto` o `always_ask` en las herramientas del agente de escritura. El agente de obtención aún puede enviar parte de lo que lee a los sitios de su lista de `web_fetch`, y al proveedor de búsqueda en sus consultas.
Los agentes de una misma sesión multiagente [comparten el sandbox](https://platform.claude.com/docs/es/managed-agents/multiagent-orchestration#how-it-works), sus archivos y las credenciales del vault, así que esta separación solo aísla sus herramientas y conversaciones. Para una separación más fuerte, usa dos sesiones con entornos y vaults separados. Haz que tu aplicación transmita entre las dos sesiones solo campos fijos, como un ID de pedido.
## Establece límites y una forma de detenerlo
Establece un presupuesto al crear cada sesión y decide de antemano cómo detendrás a un agente.
| Control | Qué hace |
| ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Presupuesto de sesión | Un tope de gasto a precios de lista públicos. Al alcanzar el tope, la sesión y cada [hilo](https://platform.claude.com/docs/es/managed-agents/session-threads) se pausan. Las solicitudes en curso pueden terminar y sus llamadas a herramientas aún se ejecutan, así que el gasto puede superar el tope. Consulta [Cuando una sesión alcanza su presupuesto](https://platform.claude.com/docs/es/managed-agents/budgets#when-a-session-reaches-its-budget) |
| Presupuesto de implementación | El mismo tope, aplicado a cada sesión que inicia una implementación |
| [Evento `user.interrupt`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#interrupt-the-agent) | Detiene la respuesta del modelo de inmediato. Una llamada a herramienta en ejecución puede terminar primero. La sesión pasa a `idle`, a menos que una ejecución de flujo de trabajo la mantenga en `running`, y se reanuda con tu siguiente mensaje. Una interrupción no finaliza ninguna ejecución de flujo de trabajo |
| Archivar o eliminar una sesión | Archivar conserva el historial y bloquea los eventos nuevos. Eliminar borra el registro, los eventos y el sandbox |
| Pausar o archivar una implementación | Pausar detiene las nuevas ejecuciones programadas, pero sigue permitiendo las ejecuciones manuales. Archivar finaliza la programación de forma permanente. Las sesiones que ya están en ejecución siguen ejecutándose |
| Archivar o eliminar un vault o una credencial | Elimina el secreto de las sesiones en ejecución sin reiniciarlas. Ten en cuenta que puede haber un retraso. Las sesiones siguen ejecutándose, así que interrúmpelas también. Un token que el agente ya obtuvo con el secreto permanece en el sandbox |
Para detener un agente en ejecución, sigue estos pasos:
1. Envía `user.interrupt` por sí solo.
2. Para un agente programado, pausa también la implementación para que no se inicie ninguna nueva ejecución programada. Para finalizar la programación de forma permanente, archiva la implementación.
3. Si una clave podría estar expuesta, rótala en el servicio que la emitió.
4. Si el agente tiene ejecuciones de flujo de trabajo abiertas, envía también un `user.message` que le pida detenerlas, porque una interrupción no finaliza ninguna ejecución. Consulta [Interrumpir una sesión con ejecuciones abiertas](https://platform.claude.com/docs/es/managed-agents/workflow-runs#interrupt-a-session-with-runs-open) para ver las llamadas a herramientas que debes cancelar primero.
5. Espera a que la sesión pase a `idle`. Una sesión en ejecución no se puede archivar ni eliminar.
6. Archiva la sesión para conservar su historial. Elimínala cuando ya no necesites el historial.
Una interrupción no deshace lo que el agente ya hizo o envió. Archivar un agente no detiene sus sesiones en ejecución.
El `max_list_cost.amount` de un presupuesto es un número entero de centavos de dólar estadounidense escrito como cadena, así que `"125"` significa $1.25. Consulta [Establecer un presupuesto al crear la sesión](https://platform.claude.com/docs/es/managed-agents/budgets#set-a-budget-at-session-creation).
No puedes añadir un presupuesto a una sesión creada sin uno. Para cambiar o eliminar un tope, consulta [Reanudar una sesión en su presupuesto](https://platform.claude.com/docs/es/managed-agents/budgets#resume-a-session-at-its-budget). Después de eliminar el tope de una sesión, no puedes establecer uno nuevo.
Un presupuesto limita el gasto, pero no limita lo que hace el agente antes de alcanzar el tope. Para mantener separadas las cargas de trabajo con distintos niveles de confianza, usa [espacios de trabajo](https://platform.claude.com/docs/es/manage-claude/workspaces) separados. Dale a cada carga de trabajo una clave de API limitada a un solo espacio de trabajo, porque una clave que puede acceder a varios espacios de trabajo puede actuar en cualquiera de ellos.
Consulta [Presupuestos de sesión](https://platform.claude.com/docs/es/managed-agents/budgets), [Operaciones de sesión](https://platform.claude.com/docs/es/managed-agents/session-operations#archiving-a-session) e [Implementaciones programadas](https://platform.claude.com/docs/es/managed-agents/scheduled-deployments#managing-deployment-lifecycle).
## Próximos pasos
Modos de red, hosts permitidos y gestores de paquetes.
Políticas de aprobación y solicitudes de confirmación.
Tipos de credenciales, ubicaciones de inyección y rotación.
Topes, reanudación al alcanzar un presupuesto y presupuestos en implementaciones.