---
title: Operaciones de sesión
url: https://platform.claude.com/docs/es/managed-agents/session-operations
description: Recupera, lista, actualiza, archiva y elimina sesiones de Claude Managed Agents.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Una vez que existe una sesión, usa estas operaciones para leerla, actualizarla, archivarla o eliminarla. Consulta [Iniciar una sesión](https://platform.claude.com/docs/es/managed-agents/sessions) para crear una sesión y enviarle trabajo.

## Estados de la sesión

Las sesiones avanzan a través de estos estados. Consulta [Iniciar una sesión](https://platform.claude.com/docs/es/managed-agents/sessions) para conocer el ciclo de vida de la sesión.

| Estado         | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `idle`         | El agente está esperando una entrada, incluidos mensajes del usuario o confirmaciones de herramientas. Las sesiones creadas sin `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) comienzan en `idle`. Una sesión puede estar en `idle` mientras una [ejecución de flujo de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#while-a-run-is-open) sigue abierta, por lo que `idle` por sí solo no significa que el trabajo haya terminado. Consulta [Saber cuándo termina el trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#know-when-the-work-is-done). |
| `running`      | El agente se está ejecutando activamente.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `rescheduling` | Ocurrió un error transitorio; se reintenta automáticamente.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `terminated`   | La sesión ha finalizado, ya sea por un error irrecuperable o porque fue archivada. Una sesión que termina su trabajo pasa a `idle`, no a `terminated`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

## Actualizar la configuración del agente

Puedes actualizar `agent.tools` (csharp, go: `Agent.Tools`) y `agent.mcp_servers` (java, php: `agent.mcpServers`; csharp: `Agent.McpServers`; go: `Agent.MCPServers`) de una sesión, incluidas las políticas de permisos y la configuración web por herramienta, como los [filtros de dominio](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions#change-the-lists-mid-session), a mitad de la sesión sin crear una nueva versión del agente. Las actualizaciones son locales a la sesión y no se propagan de vuelta al agente subyacente. Los valores actualizados de `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) y `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) se aplican durante el resto de la sesión.

Solo `tools` (csharp, go: `Tools`) y `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) del agente pueden cambiar después de crear una sesión. Para ejecutar una sesión con valores de `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`) o `skills` (csharp, go: `Skills`) distintos de los del agente, usa [anulaciones de la configuración del agente](https://platform.claude.com/docs/es/managed-agents/sessions#override-agent-configuration-for-a-session) al crear la sesión. La configuración del modelo del agente, incluida su fijación de [`inference_geo`](https://platform.claude.com/docs/es/manage-claude/data-residency), tampoco puede cambiar a mitad de la sesión: establece la fijación al guardar el agente, o establécela o elimínala para una sola sesión con una anulación de `model` (csharp, go: `Model`) al crearla. El campo `system` (csharp, go: `System`; ruby: `system_`) configurado del agente es fijo durante toda la vida de la sesión. En los modelos que lo admiten, aún puedes agregar orientación a nivel de sistema a mitad de la sesión enviando un [evento `system.message`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#send-system-messages).

La semántica de una actualización de `tools` (csharp, go: `Tools`) o `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) es de reemplazo completo: el arreglo proporcionado es el nuevo valor. Para conservar las entradas existentes, haz un `GET` de la sesión, modifica el arreglo y envíalo de vuelta con `POST`.

La sesión debe estar en `idle` para actualizar el agente. Para actualizar el agente mientras la sesión se está ejecutando, envía un [evento `user.interrupt`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#interrupt-the-agent) por sí solo y espera a que la sesión pase a `idle`. Si hay una [ejecución de flujo de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#while-a-run-is-open) abierta, ya sea en ejecución o en pausa, la actualización devuelve un error 400, incluso cuando la sesión está en `idle`. Una interrupción no finaliza una ejecución, por lo que la actualización sigue fallando después de interrumpir la sesión. Envía un `user.message` que [le pida al agente detener sus ejecuciones](https://platform.claude.com/docs/es/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), o espera hasta que todas las ejecuciones hayan finalizado.

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID" \
    -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 '{
      "agent": {
        "tools": [
          {"type": "agent_toolset_20260401"},
          {"type": "mcp_toolset", "mcp_server_name": "linear"}
        ],
        "mcp_servers": [
          {"type": "url", "name": "linear", "url": "https://mcp.linear.app/sse"}
        ]
      }
    }'
  ```

  ```bash CLI
  ant beta:sessions update --session-id "$SESSION_ID" <<'YAML'
  agent:
    tools:
      - type: agent_toolset_20260401
      - type: mcp_toolset
        mcp_server_name: linear
    mcp_servers:
      - type: url
        name: linear
        url: https://mcp.linear.app/sse
  YAML
  ```

  ```python Python
  client.beta.sessions.update(
      session.id,
      agent={
          "tools": [
              {"type": "agent_toolset_20260401"},
              {"type": "mcp_toolset", "mcp_server_name": "linear"},
          ],
          "mcp_servers": [
              {"type": "url", "name": "linear", "url": "https://mcp.linear.app/sse"}
          ],
      },
  )
  ```

  ```typescript TypeScript
  await client.beta.sessions.update(session.id, {
    agent: {
      tools: [
        { type: "agent_toolset_20260401" },
        { type: "mcp_toolset", mcp_server_name: "linear" }
      ],
      mcp_servers: [{ type: "url", name: "linear", url: "https://mcp.linear.app/sse" }]
    }
  });
  ```

  ```csharp C#
  await client.Beta.Sessions.Update(session.ID, new()
  {
      Agent = new()
      {
          Tools =
          [
              new BetaManagedAgentsAgentToolset20260401Params
              {
                  Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
              },
              new BetaManagedAgentsMcpToolsetParams
              {
                  Type = BetaManagedAgentsMcpToolsetParamsType.McpToolset,
                  McpServerName = "linear",
              },
          ],
          McpServers =
          [
              new()
              {
                  Type = BetaManagedAgentsUrlMcpServerParamsType.Url,
                  Name = "linear",
                  Url = "https://mcp.linear.app/sse",
              },
          ],
      },
  });
  ```

  ```go Go
  _, err = client.Beta.Sessions.Update(ctx, session.ID, anthropic.BetaSessionUpdateParams{
  	Agent: anthropic.BetaManagedAgentsSessionAgentUpdateParam{
  		Tools: []anthropic.BetaManagedAgentsSessionAgentUpdateToolUnionParam{
  			{
  				OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
  					Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  				},
  			},
  			{
  				OfMCPToolset: &anthropic.BetaManagedAgentsMCPToolsetParams{
  					Type:          anthropic.BetaManagedAgentsMCPToolsetParamsTypeMCPToolset,
  					MCPServerName: "linear",
  				},
  			},
  		},
  		MCPServers: []anthropic.BetaManagedAgentsURLMCPServerParams{
  			{
  				Type: anthropic.BetaManagedAgentsURLMCPServerParamsTypeURL,
  				Name: "linear",
  				URL:  "https://mcp.linear.app/sse",
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().update(
      session.id(),
      SessionUpdateParams.builder()
          .agent(BetaManagedAgentsSessionAgentUpdate.builder()
              .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
                  .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
                  .build())
              .addTool(BetaManagedAgentsMcpToolsetParams.builder()
                  .type(BetaManagedAgentsMcpToolsetParams.Type.MCP_TOOLSET)
                  .mcpServerName("linear")
                  .build())
              .addMcpServer(BetaManagedAgentsUrlMcpServerParams.builder()
                  .type(BetaManagedAgentsUrlMcpServerParams.Type.URL)
                  .name("linear")
                  .url("https://mcp.linear.app/sse")
                  .build())
              .build())
          .build()
  );
  ```

  ```php PHP
  $client->beta->sessions->update(
      $session->id,
      agent: BetaManagedAgentsSessionAgentUpdate::with(
          tools: [
              BetaManagedAgentsAgentToolset20260401Params::with(type: 'agent_toolset_20260401'),
              BetaManagedAgentsMCPToolsetParams::with(mcpServerName: 'linear', type: 'mcp_toolset'),
          ],
          mcpServers: [
              BetaManagedAgentsURLMCPServerParams::with(
                  name: 'linear',
                  type: 'url',
                  url: 'https://mcp.linear.app/sse',
              ),
          ],
      ),
  );
  ```

  ```ruby Ruby
  client.beta.sessions.update(
    session.id,
    agent: {
      tools: [
        {type: :agent_toolset_20260401},
        {type: :mcp_toolset, mcp_server_name: "linear"}
      ],
      mcp_servers: [
        {type: :url, name: "linear", url: "https://mcp.linear.app/sse"}
      ]
    }
  )
  ```
</CodeGroup>

## Actualizar el presupuesto de la sesión

Una sesión [creada con un presupuesto](https://platform.claude.com/docs/es/managed-agents/sessions#set-a-session-budget) acepta dos tipos de actualización del presupuesto: reemplazar el límite con un nuevo `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`), y eliminarlo pasando `"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`). Ambas reanudan automáticamente el trabajo que se pausó cuando la sesión alcanzó su límite. Un límite de reemplazo puede ser mayor o menor que el actual, pero debe ser estrictamente mayor que el costo de lista consumido por la sesión, y la eliminación es irreversible: un `budget` (csharp, go: `Budget`) no nulo solo se acepta en una sesión que actualmente tiene uno, por lo que no puedes volver a agregar un presupuesto eliminado ni agregar uno a una sesión creada sin él. Consulta [Presupuestos de sesión](https://platform.claude.com/docs/es/managed-agents/budgets#resume-a-session-at-its-budget) para ver ejemplos de solicitudes, los comportamientos de error y qué cuenta para el costo de lista.

## Recuperar una sesión

<CodeGroup>
  ```bash cURL
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_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:sessions retrieve --session-id "$SESSION_ID"
  ```

  ```python Python
  retrieved = client.beta.sessions.retrieve(session.id)
  print(f"Status: {retrieved.status}")
  ```

  ```typescript TypeScript
  const retrieved = await client.beta.sessions.retrieve(session.id);
  console.log(`Status: ${retrieved.status}`);
  ```

  ```csharp C#
  var retrieved = await client.Beta.Sessions.Retrieve(session.ID);
  Console.WriteLine($"Status: {retrieved.Status.Raw()}");
  ```

  ```go Go
  retrieved, err := client.Beta.Sessions.Get(ctx, session.ID, anthropic.BetaSessionGetParams{})
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Status: %s\n", retrieved.Status)
  ```

  ```java Java
  var retrieved = client.beta().sessions().retrieve(session.id());
  IO.println("Status: " + retrieved.status());
  ```

  ```php PHP
  $retrieved = $client->beta->sessions->retrieve($session->id);
  echo "Status: {$retrieved->status}\n";
  ```

  ```ruby Ruby
  retrieved = client.beta.sessions.retrieve(session.id)
  puts "Status: #{retrieved.status}"
  ```
</CodeGroup>

## Listar sesiones

Los resultados de `GET /v1/sessions` están paginados. Usa el parámetro de consulta `limit` para controlar el tamaño de la página. Cada respuesta incluye un cursor `next_page`; pásalo como el parámetro `page` en la siguiente solicitud para obtener la página siguiente. `next_page` es `null` cuando no hay más resultados.

Para retroceder una página, pasa `prev_page` como el parámetro `page`. `prev_page` es `null` cuando estás en la primera página.

Un cursor `page` es opaco y codifica el `order` de la solicitud que lo produjo. El parámetro de consulta `order` establece la dirección de ordenamiento de los resultados, `asc` o `desc` por fecha de creación; el valor predeterminado es `desc` (los más recientes primero). Reutilizar un cursor con un `order` diferente devuelve un error 400, al igual que cambiar un filtro `created_at` de modo que excluya la posición del cursor. Otros parámetros de consulta, incluidos los filtros restantes y `limit`, pueden cambiar entre solicitudes paginadas. Para conocer los campos de paginación compartidos entre los endpoints de listado, consulta [Paginación](https://platform.claude.com/docs/es/api/overview#pagination).

<CodeGroup>
  ```bash cURL
  curl -sS --fail-with-body \
    "https://api.anthropic.com/v1/sessions?agent_id=$AGENT_ID&limit=1" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  # Pass next_page back as the page query parameter to fetch the next page,
  # or prev_page to go back.
  ```

  ```bash CLI
  # --format raw returns one page envelope with its prev_page and next_page
  # cursors; the default output auto-paginates and emits only the sessions.
  ant beta:sessions list \
    --agent-id "$AGENT_ID" \
    --limit 1 \
    --format raw
  # Pass next_page back as --page to fetch the next page, or prev_page to go back.
  ```

  ```python Python
  # Establece `limit` bajo para que los resultados abarquen más de una página.
  first_page = client.beta.sessions.list(limit=1, agent_id=agent.id)
  # `prev_page` es None en la primera página; `next_page` es None en la última.
  print(f"prev_page: {first_page.prev_page}")
  print(f"next_page: {first_page.next_page}")

  # Pasa `next_page` de vuelta como `page` para obtener la página siguiente.
  second_page = client.beta.sessions.list(
      limit=1, agent_id=agent.id, page=first_page.next_page
  )
  for listed_session in second_page.data:
      print(f"{listed_session.id}: {listed_session.status}")

  # Pasa `prev_page` de vuelta como `page` para volver a la página anterior.
  previous_page = client.beta.sessions.list(
      limit=1, agent_id=agent.id, page=second_page.prev_page
  )
  for listed_session in previous_page.data:
      print(f"{listed_session.id}: {listed_session.status}")
  # Para iteración solo hacia adelante, el objeto de página también es directamente iterable.
  ```

  ```typescript TypeScript
  const firstPage = await client.beta.sessions.list({ limit: 1, agent_id: agent.id });
  // prev_page es null en la primera página; next_page se establece cuando existen más sesiones.
  console.log(`prev_page: ${firstPage.prev_page}`);
  console.log(`next_page: ${firstPage.next_page}`);

  // Pasa next_page como el cursor `page` para obtener la segunda página.
  const secondPage = await client.beta.sessions.list({
    limit: 1,
    agent_id: agent.id,
    page: firstPage.next_page
  });
  for (const listedSession of secondPage.data) {
    console.log(`Page 2 has ${listedSession.id}: ${listedSession.status}`);
  }

  // Pasa el cursor prev_page de la segunda página para volver a la primera página.
  const previousPage = await client.beta.sessions.list({
    limit: 1,
    agent_id: agent.id,
    page: secondPage.prev_page
  });
  for (const listedSession of previousPage.data) {
    console.log(`Back on page 1: ${listedSession.id} is ${listedSession.status}`);
  }
  // Para iteración solo hacia adelante, el objeto de página también es directamente iterable.
  ```

  ```csharp C#
  // El SessionListPage que devuelve `List` expone los elementos pero no los
  // cursores de paginación. Para leer `prev_page` / `next_page`, deserializa la respuesta
  // cruda en SessionListPageResponse en su lugar.
  using var page1Response = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID }
  );
  var page1 = await page1Response.Deserialize<SessionListPageResponse>();
  Console.WriteLine($"prev_page: {page1.PrevPage ?? "null"}");
  Console.WriteLine($"next_page: {page1.NextPage ?? "null"}");

  // Avanzar: pasa el `next_page` de la página 1 como el cursor `page`.
  using var page2Response = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID, Page = page1.NextPage }
  );
  var page2 = await page2Response.Deserialize<SessionListPageResponse>();
  foreach (var listedSession in page2.Data ?? [])
  {
      Console.WriteLine($"Page 2: {listedSession.ID}: {listedSession.Status.Raw()}");
  }

  // Retroceder: pasa el `prev_page` de la página 2 como el mismo cursor `page`.
  using var previousPageResponse = await client.Beta.Sessions.WithRawResponse.List(
      new SessionListParams { Limit = 1, AgentID = agent.ID, Page = page2.PrevPage }
  );
  var previousPage = await previousPageResponse.Deserialize<SessionListPageResponse>();
  foreach (var listedSession in previousPage.Data ?? [])
  {
      Console.WriteLine($"Back to page 1: {listedSession.ID}: {listedSession.Status.Raw()}");
  }
  // Para iteración solo hacia adelante, (await client.Beta.Sessions.List(...)).Paginate() devuelve un IAsyncEnumerable que sigue next_page automáticamente.
  ```

  ```go Go
  // Página 1: prev_page está vacío porque nada precede a la primera página.
  firstPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Page 1 prev_page: %q\n", firstPage.PrevPage)
  fmt.Printf("Page 1 next_page: %q\n", firstPage.NextPage)

  // Avanzar: pasa next_page como el cursor Page para obtener la página 2.
  secondPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  	Page:    anthropic.String(firstPage.NextPage),
  })
  if err != nil {
  	panic(err)
  }
  for _, listedSession := range secondPage.Data {
  	fmt.Printf("Page 2: %s: %s\n", listedSession.ID, listedSession.Status)
  }

  // Retroceder: el prev_page de la página 2 es el cursor de la página anterior.
  previousPage, err := client.Beta.Sessions.List(ctx, anthropic.BetaSessionListParams{
  	AgentID: anthropic.String(agent.ID),
  	Limit:   anthropic.Int(1),
  	Page:    anthropic.String(secondPage.PrevPage),
  })
  if err != nil {
  	panic(err)
  }
  for _, listedSession := range previousPage.Data {
  	fmt.Printf("Back to page 1: %s: %s\n", listedSession.ID, listedSession.Status)
  }
  // Para iteración solo hacia adelante, usa ListAutoPaging para seguir next_page automáticamente.
  ```

  ```java Java
  var params = SessionListParams.builder()
      .agentId(agent.id())
      .limit(1)
      .build();
  var firstPage = client.beta().sessions().list(params);
  for (var listedSession : firstPage.data()) {
      IO.println(listedSession.id() + ": " + listedSession.status());
  }
  // prev_page es un Optional vacío en la primera página; next_page apunta a la página 2.
  IO.println("prev_page: " + firstPage.response().prevPage());
  IO.println("next_page: " + firstPage.response().nextPage());

  // Avanza pasando next_page como el cursor de página.
  var nextCursor = firstPage.response().nextPage().orElseThrow();
  var secondPage = client.beta().sessions().list(params.toBuilder().page(nextCursor).build());

  // Retrocede pasando prev_page como el mismo cursor de página.
  var prevCursor = secondPage.response().prevPage().orElseThrow();
  var previousPage = client.beta().sessions().list(params.toBuilder().page(prevCursor).build());
  // De vuelta en la primera página, así que prev_page está vacío de nuevo.
  IO.println("prev_page: " + previousPage.response().prevPage());
  // Para iteración solo hacia adelante, page.autoPager() devuelve un Iterable que sigue next_page automáticamente.
  ```

  ```php PHP
  // Página 1: prevPage es null porque nada precede a la primera página.
  $firstPage = $client->beta->sessions->list(agentID: $agent->id, limit: 1);
  echo 'Page 1 prev_page: ' . ($firstPage->prevPage ?? 'null') . "\n";
  echo 'Page 1 next_page: ' . ($firstPage->nextPage ?? 'null') . "\n";

  // Avanza: pasa nextPage de vuelta como el cursor `page` para obtener la página 2.
  $secondPage = $client->beta->sessions->list(
      agentID: $agent->id,
      limit: 1,
      page: $firstPage->nextPage,
  );
  foreach ($secondPage->getItems() as $listedSession) {
      echo "Page 2: {$listedSession->id}: {$listedSession->status}\n";
  }

  // Retrocede: el prevPage de la página 2 es el cursor de la página anterior.
  $previousPage = $client->beta->sessions->list(
      agentID: $agent->id,
      limit: 1,
      page: $secondPage->prevPage,
  );
  foreach ($previousPage->getItems() as $listedSession) {
      echo "Back to page 1: {$listedSession->id}: {$listedSession->status}\n";
  }
  // Para iteración solo hacia adelante, $page->pagingEachItem() produce cada sesión a través de las páginas.
  ```

  ```ruby Ruby
  first_page = client.beta.sessions.list(agent_id: agent.id, limit: 1)
  first_page.data.each do |listed_session|
    puts "#{listed_session.id}: #{listed_session.status}"
  end

  # `prev_page` es nil en la primera página. El cursor de la página siguiente se expone como
  # `next_page_` (guion bajo final) porque `next_page` a secas es el método
  # auxiliar que obtiene el objeto de la página siguiente por ti.
  puts "prev_page: #{first_page.prev_page.inspect}"
  puts "next_page: #{first_page.next_page_.inspect}"

  # Pasa cualquiera de los cursores como `page` para recorrer la lista en ambas direcciones.
  second_page = client.beta.sessions.list(
    agent_id: agent.id,
    limit: 1,
    page: first_page.next_page_
  )
  back_to_first = client.beta.sessions.list(
    agent_id: agent.id,
    limit: 1,
    page: second_page.prev_page
  )
  back_to_first.data.each do |listed_session|
    puts "#{listed_session.id}: #{listed_session.status}"
  end
  # Para iteración solo hacia adelante, page.auto_paging_each sigue automáticamente next_page.
  ```
</CodeGroup>

## Archivar una sesión

Archiva una sesión para impedir que se envíen nuevos eventos mientras se conserva su historial. Una sesión en `running` no se puede archivar; para archivarla, envía un [evento `user.interrupt`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#interrupt-the-agent) por sí solo y espera a que la sesión pase a `idle`. Si hay una [ejecución de flujo de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#while-a-run-is-open) abierta, archivar podría devolver un error 400, incluso cuando la sesión está en `idle`, o podría tener éxito y finalizar la ejecución. Antes de archivar, envía un `user.message` que [le pida al agente detener sus ejecuciones](https://platform.claude.com/docs/es/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), o espera hasta que cada ejecución haya finalizado. Luego archiva la sesión una vez que esté en `idle`.

<CodeGroup>
  ```bash cURL
  curl -fsSL -X POST "https://api.anthropic.com/v1/sessions/$SESSION_ID/archive" \
    -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:sessions archive \
    --session-id "$SESSION_ID"
  ```

  ```python Python
  client.beta.sessions.archive(session.id)
  ```

  ```typescript TypeScript
  await client.beta.sessions.archive(session.id);
  ```

  ```csharp C#
  await client.Beta.Sessions.Archive(session.ID);
  ```

  ```go Go
  _, err = client.Beta.Sessions.Archive(ctx, session.ID, anthropic.BetaSessionArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().archive(session.id());
  ```

  ```php PHP
  $client->beta->sessions->archive($session->id);
  ```

  ```ruby Ruby
  client.beta.sessions.archive(session.id)
  ```
</CodeGroup>

## Eliminar una sesión

Elimina una sesión para borrar permanentemente su registro, sus eventos y el sandbox asociado. Una sesión en `running` no se puede eliminar; para eliminarla, envía un [evento `user.interrupt`](https://platform.claude.com/docs/es/managed-agents/events-and-streaming#interrupt-the-agent) por sí solo y espera a que la sesión pase a `idle`. Si hay una [ejecución de flujo de trabajo](https://platform.claude.com/docs/es/managed-agents/workflow-runs#while-a-run-is-open) abierta, eliminar podría devolver un error 400, incluso cuando la sesión está en `idle`, o podría tener éxito. Después de una eliminación exitosa, ningún evento `workflow_run` informa el final de las ejecuciones de la sesión. Antes de eliminar, envía un `user.message` que [le pida al agente detener sus ejecuciones](https://platform.claude.com/docs/es/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), o espera hasta que cada ejecución haya finalizado. Luego elimina la sesión una vez que esté en `idle`.

Los almacenes de memoria, las bóvedas, las skills, los entornos y los agentes son recursos independientes y no se ven afectados por la eliminación de la sesión. Los archivos que subiste a través de la Files API tampoco se ven afectados, pero los archivos que la propia sesión produjo están limitados a ella y se eliminan permanentemente junto con su sistema de archivos. Descarga todo lo que necesites conservar antes de eliminar la sesión. Un archivo de salida escrito al final del último turno puede tardar unos segundos después de que la sesión pase a idle en aparecer en la [lista de archivos de la sesión](https://platform.claude.com/docs/es/managed-agents/files#listing-and-downloading-session-files), así que primero verifica que los archivos que esperas aparezcan en la lista.

<CodeGroup>
  ```bash cURL
  curl -fsSL -X DELETE "https://api.anthropic.com/v1/sessions/$SESSION_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:sessions delete \
    --session-id "$SESSION_ID"
  ```

  ```python Python
  client.beta.sessions.delete(session.id)
  ```

  ```typescript TypeScript
  await client.beta.sessions.delete(session.id);
  ```

  ```csharp C#
  await client.Beta.Sessions.Delete(session.ID);
  ```

  ```go Go
  _, err = client.Beta.Sessions.Delete(ctx, session.ID, anthropic.BetaSessionDeleteParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().delete(session.id());
  ```

  ```php PHP
  $client->beta->sessions->delete($session->id);
  ```

  ```ruby Ruby
  client.beta.sessions.delete(session.id)
  ```
</CodeGroup>