---
title: Implementaciones programadas
url: https://platform.claude.com/docs/es/managed-agents/scheduled-deployments
description: "Crea y administra implementaciones con la Claude API: ejecuta un agente según una programación cron recurrente e inspecciona su historial de ejecuciones."
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Una **"scheduled deployment"** (implementación programada) permite que un [agente](https://platform.claude.com/docs/es/managed-agents/agent-setup) inicie [sesiones](https://platform.claude.com/docs/es/managed-agents/sessions) de forma autónoma, lo que posibilita completar tareas con una cadencia predecible. Creas y administras las implementaciones con la Deployments API, que forma parte de la Claude API.
Para conocer el contexto del lanzamiento y ejemplos de lo que los equipos ejecutan de forma programada, consulta [scheduled deployments and vaults in Claude Managed Agents](https://claude.com/blog/whats-new-in-claude-managed-agents) en el blog.
## Crear una implementación programada
Al crear una implementación, pasas las [configuraciones de sesión](https://platform.claude.com/docs/es/managed-agents/sessions) necesarias para la ejecución, además de un `schedule` (csharp, go: `Schedule`).
* Las implementaciones requieren [configuración del agente](https://platform.claude.com/docs/es/managed-agents/agent-setup) y [configuración del entorno](https://platform.claude.com/docs/es/managed-agents/environments), y opcionalmente aceptan [archivos](https://platform.claude.com/docs/es/managed-agents/files), [GitHub](https://platform.claude.com/docs/es/managed-agents/github), [almacenes de memoria](https://platform.claude.com/docs/es/managed-agents/memory) y [bóvedas](https://platform.claude.com/docs/es/managed-agents/vaults). Una implementación que apunta a un [entorno autoalojado](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory) puede adjuntar almacenes de memoria; los recursos `file` y `github_repository` requieren un entorno en la nube. El formulario de implementación de Claude Console actualmente no ofrece almacenes de memoria para entornos autoalojados; adjúntalos mediante la API o un SDK en su lugar.
* Las implementaciones también requieren al menos un evento inicial, un `user.message` o `user.define_outcome`, que inicia el trabajo de cada sesión. En un archivo de implementación para `ant apply`, el texto debajo del frontmatter se convierte en ese `user.message`.
* En el `schedule` (csharp, go: `Schedule`), defines una `expression` (csharp, go: `Expression`) cron y una `timezone` (csharp, go: `Timezone`). La granularidad máxima admitida es a nivel de minuto.
En [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws), cada ejecución crea su sesión como un rol de IAM en tu cuenta de AWS. Antes de crear la implementación, establece `execution_identity` en el agente como `{"type": "aws_role", "role_arn": "arn:aws:iam::123456789012:role/example-role"}`. Crear una implementación para un agente sin este campo devuelve un error 400.
* **Política de confianza:** Permite que la entidad principal de servicio `aws-external-anthropic.amazonaws.com` llame a `sts:AssumeRole` y `sts:SetSourceIdentity`.
* **Permisos del rol:** Permite `aws-external-anthropic:CreateSession`, `sts:GetWebIdentityToken` y `sts:TagGetWebIdentityToken`.
* **Permisos del llamador:** La entidad principal de IAM que establece el rol en el agente necesita `iam:PassRole` sobre ese rol. El rol debe estar en la misma cuenta de AWS. Ninguna [política administrada](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions#managed-policies) otorga `iam:PassRole`.
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployments?beta=true" \
-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": "Weekly compliance scan",
"agent": "'"$AGENT_ID"'",
"environment_id": "'"$ENVIRONMENT_ID"'",
"initial_events": [
{"type": "user.message", "content": [{"type": "text", "text": "Run the weekly compliance scan."}]}
],
"schedule": {
"type": "cron",
"expression": "0 20 * * 5",
"timezone": "America/New_York"
}
}'
```
```bash CLI
ant apply deployment.md
```
```markdown
---
name: Weekly compliance scan
agent: agent_011CYm1BLqPXpQRk5khsSXrs
environment_id: env_01595EKxaaTTGwwY3kyXdtbs
schedule:
type: cron
expression: "0 20 * * 5"
timezone: America/New_York
---
Run the weekly compliance scan.
```
[`ant apply`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/apply) imprime el ID de la nueva implementación y lo registra en `claude-lock.json`. Para ver el objeto de implementación, ejecuta `ant beta:deployments retrieve`.
```python Python
deployment = client.beta.deployments.create(
name="Weekly compliance scan",
agent=agent.id,
environment_id=environment.id,
initial_events=[
{
"type": "user.message",
"content": [{"type": "text", "text": "Run the weekly compliance scan."}],
},
],
schedule={
"type": "cron",
"expression": "0 20 * * 5",
"timezone": "America/New_York",
},
)
```
```typescript TypeScript
const deployment = await client.beta.deployments.create({
name: "Weekly compliance scan",
agent: agent.id,
environment_id: environment.id,
initial_events: [
{
type: "user.message",
content: [{ type: "text", text: "Run the weekly compliance scan." }]
}
],
schedule: {
type: "cron",
expression: "0 20 * * 5",
timezone: "America/New_York"
}
});
```
```csharp C#
var deployment = await client.Beta.Deployments.Create(new()
{
Name = "Weekly compliance scan",
Agent = agent.ID,
EnvironmentID = environment.ID,
InitialEvents =
[
new BetaManagedAgentsUserMessageEventParams
{
Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
Content =
[
new BetaManagedAgentsTextBlock
{
Type = BetaManagedAgentsTextBlockType.Text,
Text = "Run the weekly compliance scan.",
},
],
},
],
Schedule = new BetaManagedAgentsScheduleParams
{
Type = BetaManagedAgentsScheduleParamsType.Cron,
Expression = "0 20 * * 5",
Timezone = "America/New_York",
},
});
```
```go Go
deployment, err := client.Beta.Deployments.New(ctx, anthropic.BetaDeploymentNewParams{
Name: "Weekly compliance scan",
Agent: anthropic.BetaDeploymentNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
EnvironmentID: environment.ID,
InitialEvents: []anthropic.BetaManagedAgentsDeploymentInitialEventParamsUnion{{
OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
OfText: &anthropic.BetaManagedAgentsTextBlockParam{
Type: anthropic.BetaManagedAgentsTextBlockTypeText,
Text: "Run the weekly compliance scan.",
},
}},
},
}},
Schedule: anthropic.BetaManagedAgentsScheduleParams{
Type: anthropic.BetaManagedAgentsScheduleParamsTypeCron,
Expression: "0 20 * * 5",
Timezone: "America/New_York",
},
})
if err != nil {
panic(err)
}
```
```java Java
var deployment = client.beta().deployments().create(
DeploymentCreateParams.builder()
.name("Weekly compliance scan")
.agent(agent.id())
.environmentId(environment.id())
.addInitialEvent(
BetaManagedAgentsUserMessageEventParams.builder()
.type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
.addTextContent("Run the weekly compliance scan.")
.build()
)
.schedule(
BetaManagedAgentsScheduleParams.builder()
.type(BetaManagedAgentsScheduleParams.Type.CRON)
.expression("0 20 * * 5")
.timezone("America/New_York")
.build()
)
.build()
);
```
```php PHP
$deployment = $client->beta->deployments->create(
name: 'Weekly compliance scan',
agent: $agent->id,
environmentID: $environment->id,
initialEvents: [
[
'type' => 'user.message',
'content' => [['type' => 'text', 'text' => 'Run the weekly compliance scan.']],
],
],
schedule: [
'type' => 'cron',
'expression' => '0 20 * * 5',
'timezone' => 'America/New_York',
],
);
```
```ruby Ruby
deployment = client.beta.deployments.create(
name: "Weekly compliance scan",
agent: agent.id,
environment_id: environment.id,
initial_events: [
{
type: "user.message",
content: [{type: "text", text: "Run the weekly compliance scan."}]
}
],
schedule: {
type: "cron",
expression: "0 20 * * 5",
timezone: "America/New_York"
}
)
```
La respuesta incluye un objeto de implementación con `schedule.upcoming_runs_at` completado con las próximas horas de activación, para confirmar que tu programación se configuró correctamente.
```json
{
"id": "depl_01xyz",
"status": "active",
"paused_reason": null,
"schedule": {
"type": "cron",
"expression": "0 20 * * 5",
"timezone": "America/New_York",
"last_run_at": null,
"upcoming_runs_at": [
"2026-05-09T00:00:00Z",
"2026-05-16T00:00:00Z",
"2026-05-23T00:00:00Z"
]
}
}
```
Las marcas de tiempo de las próximas ejecuciones reflejan exactamente la programación configurada. Sin embargo, para distribuir la carga, la ejecución real aplica un "jitter" (variación aleatoria) de hasta el 15% del intervalo entre ejecuciones, con un mínimo de 5 segundos y un máximo de 9 minutos.
Se admite un máximo de **1,000 implementaciones programadas** por organización. Contacta al soporte de Anthropic si necesitas más.
Consulta la [referencia de Create Deployment](https://platform.claude.com/docs/es/api/beta/deployments/create) para ver todos los parámetros y el esquema de respuesta.
### Semántica de cron y zona horaria
* **Expresión:** cron POSIX estándar (`minute hour day-of-month month day-of-week`). Puedes generar y validar estas expresiones cron en la [Claude Console](https://platform.claude.com/workspaces/default/deployments).
* **Zona horaria:** identificador de zona horaria IANA (por ejemplo, `"America/Los_Angeles"`).
* **Horario de verano (DST):** las programaciones cron usan coincidencia literal con la hora del reloj local, por lo que `"0 20 * * *"` en `America/New_York` se activa a las 8:00 PM hora local, independientemente de si está vigente EST o EDT.
Las horas del reloj local que no existen en un día de adelanto de horario (como las 2 AM) no se activan. Las horas del reloj local que ocurren dos veces en un día de atraso de horario se activan dos veces. Programa fuera de la ventana local de 1 a 3 AM, o usa UTC, cuando las ejecuciones omitidas o duplicadas sean inaceptables.
### Establecer un presupuesto para cada ejecución
Pasa el objeto opcional `budget` (csharp, go: `Budget`) cuando crees o actualices la implementación. Tiene la misma forma que un [presupuesto de sesión](https://platform.claude.com/docs/es/managed-agents/budgets). La implementación copia el límite en cada sesión que inicia, por lo que el presupuesto limita cada ejecución por separado en lugar de actuar como un tope acumulado entre ejecuciones: una implementación con un límite de `"2000"` puede gastar hasta unos $20 en cada ejecución.
Una sesión iniciada por la implementación se comporta exactamente como cualquier otra sesión con presupuesto: se pausa con `budget_reached` cuando su propio costo de lista [alcanza el límite](https://platform.claude.com/docs/es/managed-agents/budgets#when-a-session-reaches-its-budget). Cambiar el presupuesto de la implementación se aplica a las ejecuciones iniciadas después; una sesión que ya está en ejecución conserva el límite con el que comenzó, que puedes [cambiar a través de la propia sesión](https://platform.claude.com/docs/es/managed-agents/session-operations#updating-the-session-budget). A diferencia de un presupuesto de sesión, el presupuesto de una implementación se puede eliminar con `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`) y volver a establecerse más tarde.
El siguiente ejemplo establece un presupuesto en una implementación existente:
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID?beta=true" \
-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 '{
"budget": {
"type": "limit",
"max_list_cost": {"amount": "2000", "currency": "USD"}
}
}'
```
```bash CLI
ant apply deployment.md
```
```markdown
---
name: Weekly compliance scan
agent: agent_011CYm1BLqPXpQRk5khsSXrs
environment_id: env_01595EKxaaTTGwwY3kyXdtbs
schedule:
type: cron
expression: "0 20 * * 5"
timezone: America/New_York
budget:
type: limit
max_list_cost:
amount: "2000"
currency: USD
---
Run the weekly compliance scan.
```
```python Python
updated_deployment = client.beta.deployments.update(
deployment.id,
budget={
"type": "limit",
"max_list_cost": {"amount": "2000", "currency": "USD"},
},
)
print(updated_deployment.budget.max_list_cost.amount) # 2000
```
```typescript TypeScript
const updatedDeployment = await client.beta.deployments.update(deployment.id, {
budget: {
type: "limit",
max_list_cost: { amount: "2000", currency: "USD" }
}
});
console.log(updatedDeployment.budget?.max_list_cost.amount); // 2000
```
```csharp C#
var updatedDeployment = await client.Beta.Deployments.Update(deployment.ID, new()
{
Budget = new()
{
Type = BetaManagedAgentsBudgetLimitType.Limit,
MaxListCost = new() { Amount = "2000", Currency = BetaCurrency.Usd },
},
});
Console.WriteLine(updatedDeployment.Budget?.MaxListCost.Amount); // 2000
```
```go Go
updatedDeployment, err := client.Beta.Deployments.Update(ctx, deployment.ID, anthropic.BetaDeploymentUpdateParams{
Budget: anthropic.BetaManagedAgentsBudgetLimitParam{
Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit,
MaxListCost: anthropic.BetaMonetaryAmountParam{
Amount: "2000",
Currency: anthropic.BetaCurrencyUsd,
},
},
})
if err != nil {
panic(err)
}
fmt.Println(updatedDeployment.Budget.MaxListCost.Amount) // 2000
```
```java Java
var updatedDeployment = client.beta().deployments().update(
deployment.id(),
DeploymentUpdateParams.builder()
.budget(BetaManagedAgentsBudgetLimit.builder()
.type(BetaManagedAgentsBudgetLimit.Type.LIMIT)
.maxListCost(BetaMonetaryAmount.builder()
.amount("2000")
.currency(BetaCurrency.USD)
.build())
.build())
.build()
);
IO.println(updatedDeployment.budget().orElseThrow().maxListCost().amount()); // 2000
```
```php PHP
$updatedDeployment = $client->beta->deployments->update(
$deployment->id,
budget: [
'type' => 'limit',
'max_list_cost' => ['amount' => '2000', 'currency' => 'USD'],
],
);
echo "{$updatedDeployment->budget->maxListCost->amount}\n"; // 2000
```
```ruby Ruby
updated_deployment = client.beta.deployments.update(
deployment.id,
budget: {
type: "limit",
max_list_cost: {amount: "2000", currency: "USD"}
}
)
puts updated_deployment.budget.max_list_cost.amount # 2000
```
## Ejecuciones de implementación
Las implementaciones pueden no activarse por diversas razones: por ejemplo, si el recurso `environment` se ha archivado o si la creación de sesiones está sujeta a un límite de velocidad. Cada intento de ejecutar una implementación genera un registro de **"deployment run"** (ejecución de implementación), lo que te permite hacer seguimiento de los éxitos y fallos de forma independiente del ciclo de vida de la sesión.
Las implementaciones exitosas generan sesiones activas, y una ejecución de implementación exitosa contiene el `session_id` (java: `sessionId`; php: `sessionID`; csharp, go: `SessionID`) asociado. Para seguir el ciclo de vida de una sesión, haz seguimiento de los eventos de la sesión a través del [flujo de eventos](https://platform.claude.com/docs/es/managed-agents/events-and-streaming) o de [webhooks](https://platform.claude.com/docs/es/managed-agents/webhooks). Los cambios en el ciclo de vida de la implementación y el resultado de cada ejecución programada también se entregan como eventos de webhook, enumerados en las pestañas Deployment events y Deployment run events de [Tipos de eventos admitidos](https://platform.claude.com/docs/es/managed-agents/webhooks#supported-event-types).
Enumera todas las ejecuciones de una implementación de la siguiente manera:
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployment_runs?beta=true&deployment_id=$DEPLOYMENT_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployment-runs list --deployment-id "$DEPLOYMENT_ID"
```
```python Python
for run in client.beta.deployment_runs.list(
deployment_id=deployment.id,
):
print(run.created_at, run.session_id or run.error.type)
```
```typescript TypeScript
for await (const run of client.beta.deploymentRuns.list({
deployment_id: deployment.id
})) {
console.log(run.created_at, run.session_id ?? run.error?.type);
}
```
```csharp C#
var runs = await client.Beta.DeploymentRuns.List(
new() { DeploymentID = deployment.ID }
);
await foreach (var run in runs.Paginate())
{
// La unión Error expone .Message directamente; el discriminador se lee
// desde .Json hasta que se agregue un accesor común .Type.
var outcome = run.SessionID ?? run.Error!.Json.GetProperty("type").GetString();
Console.WriteLine($"{run.CreatedAt} {outcome}");
}
```
```go Go
runs := client.Beta.DeploymentRuns.ListAutoPaging(ctx, anthropic.BetaDeploymentRunListParams{
DeploymentID: anthropic.String(deployment.ID),
})
for runs.Next() {
run := runs.Current()
if run.SessionID != "" {
fmt.Println(run.CreatedAt.Format(time.RFC3339), run.SessionID)
} else {
fmt.Println(run.CreatedAt.Format(time.RFC3339), run.Error.Type)
}
}
if err := runs.Err(); err != nil {
panic(err)
}
```
```java Java
for (var run : client.beta().deploymentRuns().list(
DeploymentRunListParams.builder()
.deploymentId(deployment.id())
.build()).autoPager()) {
// La unión Error aún no expone los accesores comunes .type()/.message()
// .toString() incluye ambos.
IO.println(run.createdAt() + " "
+ run.sessionId().orElseGet(() -> run.error().orElseThrow().toString()));
}
```
```php PHP
foreach ($client->beta->deploymentRuns->list(
deploymentID: $deployment->id,
)->pagingEachItem() as $run) {
$outcome = $run->sessionID ?? $run->error->type;
echo "{$run->createdAt->format(DATE_ATOM)} {$outcome}\n";
}
```
```ruby Ruby
client.beta.deployment_runs.list(
deployment_id: deployment.id
).auto_paging_each do
puts "#{it.created_at} #{it.session_id || it.error.type}"
end
```
Además, puedes filtrar las ejecuciones de implementación con errores:
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployment_runs?beta=true&deployment_id=$DEPLOYMENT_ID&has_error=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployment-runs list --deployment-id "$DEPLOYMENT_ID" --has-error
```
```python Python
for run in client.beta.deployment_runs.list(
deployment_id=deployment.id,
has_error=True,
):
print(run.created_at, run.error.type, run.error.message)
```
```typescript TypeScript
for await (const run of client.beta.deploymentRuns.list({
deployment_id: deployment.id,
has_error: true
})) {
console.log(run.created_at, run.error?.type, run.error?.message);
}
```
```csharp C#
var failedRuns = await client.Beta.DeploymentRuns.List(
new() { DeploymentID = deployment.ID, HasError = true }
);
await foreach (var failedRun in failedRuns.Paginate())
{
var error = failedRun.Error!;
var errorType = error.Json.GetProperty("type").GetString();
Console.WriteLine($"{failedRun.CreatedAt} {errorType} {error.Message}");
}
```
```go Go
failedRuns := client.Beta.DeploymentRuns.ListAutoPaging(ctx, anthropic.BetaDeploymentRunListParams{
DeploymentID: anthropic.String(deployment.ID),
HasError: anthropic.Bool(true),
})
for failedRuns.Next() {
failedRun := failedRuns.Current()
fmt.Println(failedRun.CreatedAt.Format(time.RFC3339), failedRun.Error.Type, failedRun.Error.Message)
}
if err := failedRuns.Err(); err != nil {
panic(err)
}
```
```java Java
for (var run : client.beta().deploymentRuns().list(
DeploymentRunListParams.builder()
.deploymentId(deployment.id())
.hasError(true)
.build()).autoPager()) {
IO.println(run.createdAt() + " " + run.error().orElseThrow());
}
```
```php PHP
foreach ($client->beta->deploymentRuns->list(
deploymentID: $deployment->id,
hasError: true,
)->pagingEachItem() as $run) {
echo "{$run->createdAt->format(DATE_ATOM)} {$run->error->type} {$run->error->message}\n";
}
```
```ruby Ruby
client.beta.deployment_runs.list(
deployment_id: deployment.id,
has_error: true
).auto_paging_each do
puts "#{it.created_at} #{it.error.type} #{it.error.message}"
end
```
Una ejecución fallida incluye un `error` con un `type` que describe por qué se rechazó la creación de la sesión (por ejemplo, `environment_archived_error`, `agent_archived_error` o `session_rate_limited_error`). Consulta la [referencia de List Deployment Runs](https://platform.claude.com/docs/es/api/beta/deployment_runs/list) para ver todos los parámetros de filtro y el esquema de respuesta.
```json
{
"type": "deployment_run",
"id": "drun_01abc124",
"deployment_id": "depl_01xyz",
"trigger_context": { "type": "schedule", "scheduled_at": "2026-05-09T00:00:00Z" },
"session_id": null,
"error": {
"type": "environment_archived_error",
"message": "environment `env_01abc` is archived"
},
"agent": { "type": "agent", "id": "agent_01ghi789", "version": 3 },
"created_at": "2026-05-09T00:00:01Z"
}
```
Para recuperar una sola ejecución por ID, llama a [`GET /v1/deployment_runs/{deployment_run_id}`](https://platform.claude.com/docs/es/api/beta/deployment_runs/retrieve). Un [evento de webhook `deployment_run`](https://platform.claude.com/docs/es/managed-agents/webhooks#supported-event-types) incluye el ID de la ejecución como su `data.id`.
## Administrar el ciclo de vida de la implementación
Cada cambio en el ciclo de vida emite un [evento de webhook](https://platform.claude.com/docs/es/managed-agents/webhooks#supported-event-types), por lo que puedes reaccionar a una implementación pausada, reanudada o archivada sin hacer sondeos; consulta la pestaña Deployment events.
**Pausar** suprime las activaciones programadas de aquí en adelante; las sesiones en ejecución de una ejecución de implementación anterior continúan ejecutándose. Las ejecuciones manuales a través del endpoint `run` siguen permitidas mientras está en pausa. Pausar establece `paused_reason` en `{"type": "manual"}`; reanudar lo borra.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/pause?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments pause --deployment-id "$DEPLOYMENT_ID"
```
```python Python
client.beta.deployments.pause(deployment.id)
```
```typescript TypeScript
await client.beta.deployments.pause(deployment.id);
```
```csharp C#
await client.Beta.Deployments.Pause(deployment.ID);
```
```go Go
if _, err := client.Beta.Deployments.Pause(ctx, deployment.ID, anthropic.BetaDeploymentPauseParams{}); err != nil {
panic(err)
}
```
```java Java
client.beta().deployments().pause(deployment.id());
```
```php PHP
$client->beta->deployments->pause($deployment->id);
```
```ruby Ruby
client.beta.deployments.pause(deployment.id)
```
**Reanudar** retoma la programación a partir de la siguiente ocurrencia programada. Las activaciones omitidas no se recuperan.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/unpause?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments unpause --deployment-id "$DEPLOYMENT_ID"
```
```python Python
client.beta.deployments.unpause(deployment.id)
```
```typescript TypeScript
await client.beta.deployments.unpause(deployment.id);
```
```csharp C#
await client.Beta.Deployments.Unpause(deployment.ID);
```
```go Go
if _, err := client.Beta.Deployments.Unpause(ctx, deployment.ID, anthropic.BetaDeploymentUnpauseParams{}); err != nil {
panic(err)
}
```
```java Java
client.beta().deployments().unpause(deployment.id());
```
```php PHP
$client->beta->deployments->unpause($deployment->id);
```
```ruby Ruby
client.beta.deployments.unpause(deployment.id)
```
**Archivar**, a diferencia de **pausar**, es definitivo: la programación termina y la implementación no se puede modificar.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/archive?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments archive --deployment-id "$DEPLOYMENT_ID"
```
```python Python
client.beta.deployments.archive(deployment.id)
```
```typescript TypeScript
await client.beta.deployments.archive(deployment.id);
```
```csharp C#
await client.Beta.Deployments.Archive(deployment.ID);
```
```go Go
if _, err := client.Beta.Deployments.Archive(ctx, deployment.ID, anthropic.BetaDeploymentArchiveParams{}); err != nil {
panic(err)
}
```
```java Java
client.beta().deployments().archive(deployment.id());
```
```php PHP
$client->beta->deployments->archive($deployment->id);
```
```ruby Ruby
client.beta.deployments.archive(deployment.id)
```
### Comportamiento ante fallos
Las respuestas de límite de velocidad en la creación de sesiones se registran inmediatamente como una ejecución `session_rate_limited_error` sin reintento; la programación vuelve a intentarlo en la siguiente ocurrencia programada. Los límites de velocidad en las llamadas a la API subyacentes dentro de una sesión los gestiona la propia sesión.
Si el agente de una implementación se ha archivado, la implementación se archiva automáticamente en la misma operación. Si el agente se ha eliminado, la siguiente activación programada detecta el agente faltante y archiva automáticamente la implementación. En ambos casos no se registra ninguna ejecución de implementación. Si un subagente referenciado por el agente se ha archivado, la siguiente activación registra una ejecución fallida con `error.type: "agent_archived_error"` y la implementación se pausa automáticamente para que puedas actualizar el agente y reanudarla. Otros errores irrecuperables de creación de sesiones, como un entorno o una bóveda archivados, se comportan de la misma manera: la activación registra una ejecución fallida y la implementación se pausa automáticamente. El `paused_reason.error.type` de la implementación refleja el `error.type` de la ejecución fallida.
## Activar una ejecución manual
Para ejecutar una implementación fuera de su programación, llama al [endpoint `run`](https://platform.claude.com/docs/es/api/beta/deployments/run). Esto crea una sesión inmediatamente y escribe una ejecución de implementación con `trigger_context.type: "manual"`. Esto te permite probar una implementación antes de comprometerte con la programación.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/run?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments run --deployment-id "$DEPLOYMENT_ID"
```
```python Python
run = client.beta.deployments.run(deployment.id)
```
```typescript TypeScript
const run = await client.beta.deployments.run(deployment.id);
```
```csharp C#
var manualRun = await client.Beta.Deployments.Run(deployment.ID);
```
```go Go
manualRun, err := client.Beta.Deployments.Run(ctx, deployment.ID, anthropic.BetaDeploymentRunParams{})
if err != nil {
panic(err)
}
```
```java Java
var run = client.beta().deployments().run(deployment.id());
```
```php PHP
$run = $client->beta->deployments->run($deployment->id);
```
```ruby Ruby
run = client.beta.deployments.run(deployment.id)
```