---
title: Operazioni sulle sessioni
url: https://platform.claude.com/docs/it/managed-agents/session-operations
description: Recupera, elenca, aggiorna, archivia ed elimina le sessioni di 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 volta che una sessione esiste, usa queste operazioni per leggerla, aggiornarla, archiviarla o eliminarla. Consulta [Avviare una sessione](https://platform.claude.com/docs/it/managed-agents/sessions) per creare una sessione e inviarle del lavoro.

## Stati della sessione

Le sessioni attraversano questi stati. Consulta [Avviare una sessione](https://platform.claude.com/docs/it/managed-agents/sessions) per il ciclo di vita della sessione.

| Stato          | Descrizione                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `idle`         | L'agente è in attesa di input, inclusi messaggi dell'utente o conferme degli strumenti. Le sessioni create senza `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) iniziano in `idle`. Una sessione può essere `idle` mentre un'[esecuzione di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#while-a-run-is-open) è ancora aperta, quindi `idle` da solo non significa che il lavoro sia terminato. Consulta [Sapere quando il lavoro è terminato](https://platform.claude.com/docs/it/managed-agents/workflow-runs#know-when-the-work-is-done). |
| `running`      | L'agente è attivamente in esecuzione.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `rescheduling` | Si è verificato un errore transitorio, nuovo tentativo automatico in corso.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `terminated`   | La sessione è terminata, a causa di un errore irreversibile oppure perché è stata archiviata. Una sessione che completa il proprio lavoro passa a `idle`, non a `terminated`.                                                                                                                                                                                                                                                                                                                                                                                                                          |

## Aggiornare la configurazione dell'agente

Puoi aggiornare `agent.tools` (csharp, go: `Agent.Tools`) e `agent.mcp_servers` (java, php: `agent.mcpServers`; csharp: `Agent.McpServers`; go: `Agent.MCPServers`) di una sessione, incluse le policy di autorizzazione e le impostazioni web per singolo strumento come i [filtri di dominio](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions#change-the-lists-mid-session), a sessione in corso senza creare una nuova versione dell'agente. Gli aggiornamenti sono locali alla sessione e non si propagano all'agente sottostante. I valori aggiornati di `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) e `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) si applicano al resto della sessione.

Solo `tools` (csharp, go: `Tools`) e `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) dell'agente possono cambiare dopo la creazione di una sessione. Per eseguire una sessione con valori di `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`) o `skills` (csharp, go: `Skills`) diversi da quelli dell'agente, usa gli [override della configurazione dell'agente](https://platform.claude.com/docs/it/managed-agents/sessions#override-agent-configuration-for-a-session) quando crei la sessione. Anche la configurazione del modello dell'agente, incluso il suo vincolo [`inference_geo`](https://platform.claude.com/docs/it/manage-claude/data-residency), non può cambiare a sessione in corso: imposta il vincolo quando salvi l'agente, oppure impostalo o rimuovilo per una singola sessione con un override di `model` (csharp, go: `Model`) quando la crei. Il campo `system` (csharp, go: `System`; ruby: `system_`) configurato per l'agente è fisso per tutta la durata della sessione. Sui modelli che lo supportano, puoi comunque aggiungere indicazioni a livello di sistema a sessione in corso inviando un [evento `system.message`](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#send-system-messages).

La semantica di un aggiornamento di `tools` (csharp, go: `Tools`) o `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) è di sostituzione completa: l'array fornito è il nuovo valore. Per preservare le voci esistenti, esegui `GET` sulla sessione, modifica l'array e rinvialo con `POST`.

La sessione deve essere `idle` per aggiornare l'agente. Per aggiornare l'agente mentre la sessione è in esecuzione, invia un [evento `user.interrupt`](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#interrupt-the-agent) da solo e attendi che la sessione diventi `idle`. Se un'[esecuzione di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#while-a-run-is-open) è aperta, che sia in corso o in pausa, l'aggiornamento restituisce un errore 400, anche quando la sessione è `idle`. Un'interruzione non termina un'esecuzione, quindi l'aggiornamento fallisce comunque dopo che hai interrotto la sessione. Invia un `user.message` che [chieda all'agente di fermare le sue esecuzioni](https://platform.claude.com/docs/it/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), oppure attendi che ogni esecuzione sia terminata.

<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>

## Aggiornare il budget della sessione

Una sessione [creata con un budget](https://platform.claude.com/docs/it/managed-agents/sessions#set-a-session-budget) accetta due tipi di aggiornamento del budget: la sostituzione del limite con un nuovo `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) e la sua rimozione passando `"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`). Entrambi riprendono automaticamente il lavoro che si era messo in pausa quando la sessione ha raggiunto il suo limite. Un limite sostitutivo può essere più alto o più basso di quello attuale, ma deve essere strettamente maggiore del costo di listino già consumato dalla sessione, e la rimozione è irreversibile: un `budget` (csharp, go: `Budget`) non nullo viene accettato solo su una sessione che ne ha attualmente uno, quindi non puoi aggiungere di nuovo un budget rimosso né aggiungerne uno a una sessione creata senza. Consulta [Budget delle sessioni](https://platform.claude.com/docs/it/managed-agents/budgets#resume-a-session-at-its-budget) per esempi di richieste, i comportamenti in caso di errore e cosa viene conteggiato nel costo di listino.

## Recuperare una sessione

<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>

## Elencare le sessioni

I risultati di `GET /v1/sessions` sono paginati. Usa il parametro di query `limit` per controllare la dimensione della pagina. Ogni risposta include un cursore `next_page`; passalo come parametro `page` nella richiesta successiva per recuperare la pagina seguente. `next_page` è `null` quando non ci sono altri risultati.

Per tornare indietro di una pagina, passa `prev_page` come parametro `page`. `prev_page` è `null` quando ti trovi sulla prima pagina.

Un cursore `page` è opaco e codifica l'`order` della richiesta che lo ha prodotto. Il parametro di query `order` imposta la direzione di ordinamento dei risultati, `asc` o `desc` per data di creazione; il valore predefinito è `desc` (i più recenti per primi). Riutilizzare un cursore con un `order` diverso restituisce un errore 400, così come modificare un filtro `created_at` in modo che escluda la posizione del cursore. Gli altri parametri di query, inclusi i filtri rimanenti e `limit`, possono cambiare tra una richiesta paginata e l'altra. Per i campi di paginazione condivisi tra gli endpoint di elenco, consulta [Paginazione](https://platform.claude.com/docs/it/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
  # Imposta `limit` basso così i risultati occupano più di una pagina.
  first_page = client.beta.sessions.list(limit=1, agent_id=agent.id)
  # `prev_page` è None sulla prima pagina; `next_page` è None sull'ultima.
  print(f"prev_page: {first_page.prev_page}")
  print(f"next_page: {first_page.next_page}")

  # Ripassa `next_page` come `page` per recuperare la pagina successiva.
  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}")

  # Ripassa `prev_page` come `page` per tornare alla pagina precedente.
  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}")
  # Per l'iterazione solo in avanti, l'oggetto pagina è anche direttamente iterabile.
  ```

  ```typescript TypeScript
  const firstPage = await client.beta.sessions.list({ limit: 1, agent_id: agent.id });
  // prev_page è null sulla prima pagina; next_page è valorizzato quando esistono altre sessioni.
  console.log(`prev_page: ${firstPage.prev_page}`);
  console.log(`next_page: ${firstPage.next_page}`);

  // Passa next_page come cursore `page` per recuperare la seconda pagina.
  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}`);
  }

  // Passa il cursore prev_page della seconda pagina per tornare alla prima pagina.
  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}`);
  }
  // Per l'iterazione solo in avanti, l'oggetto page è anche direttamente iterabile.
  ```

  ```csharp C#
  // Il SessionListPage restituito da `List` espone gli elementi ma non i
  // cursori di paginazione. Per leggere `prev_page` / `next_page`, deserializza la risposta
  // grezza in SessionListPageResponse.
  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"}");

  // Avanza: passa `next_page` della pagina 1 come cursore `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()}");
  }

  // Torna indietro: passa `prev_page` della pagina 2 come stesso cursore `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()}");
  }
  // Per l'iterazione solo in avanti, (await client.Beta.Sessions.List(...)).Paginate() restituisce un IAsyncEnumerable che segue automaticamente next_page.
  ```

  ```go Go
  // Pagina 1: prev_page è vuoto perché nulla precede la prima pagina.
  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)

  // Avanza: passa next_page come cursore Page per recuperare la pagina 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)
  }

  // Torna indietro: il prev_page della pagina 2 è il cursore della pagina precedente.
  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)
  }
  // Per l'iterazione solo in avanti, usa ListAutoPaging per seguire automaticamente next_page.
  ```

  ```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 è un Optional vuoto sulla prima pagina; next_page punta alla pagina 2.
  IO.println("prev_page: " + firstPage.response().prevPage());
  IO.println("next_page: " + firstPage.response().nextPage());

  // Avanza passando next_page come cursore di pagina.
  var nextCursor = firstPage.response().nextPage().orElseThrow();
  var secondPage = client.beta().sessions().list(params.toBuilder().page(nextCursor).build());

  // Torna indietro passando prev_page come lo stesso cursore di pagina.
  var prevCursor = secondPage.response().prevPage().orElseThrow();
  var previousPage = client.beta().sessions().list(params.toBuilder().page(prevCursor).build());
  // Di nuovo sulla prima pagina, quindi prev_page è di nuovo vuoto.
  IO.println("prev_page: " + previousPage.response().prevPage());
  // Per l'iterazione solo in avanti, page.autoPager() restituisce un Iterable che segue automaticamente next_page.
  ```

  ```php PHP
  // Pagina 1: prevPage è null perché nulla precede la prima pagina.
  $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: ripassa nextPage come cursore `page` per recuperare la pagina 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";
  }

  // Torna indietro: il prevPage della pagina 2 è il cursore della pagina precedente.
  $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";
  }
  // Per l'iterazione solo in avanti, $page->pagingEachItem() restituisce ogni sessione di tutte le pagine.
  ```

  ```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` è nil sulla prima pagina. Il cursore della pagina successiva è esposto come
  # `next_page_` (underscore finale) perché il semplice `next_page` è il metodo
  # helper che recupera per te l'oggetto della pagina successiva.
  puts "prev_page: #{first_page.prev_page.inspect}"
  puts "next_page: #{first_page.next_page_.inspect}"

  # Passa uno dei due cursori come `page` per scorrere l'elenco in entrambe le direzioni.
  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
  # Per l'iterazione solo in avanti, page.auto_paging_each segue automaticamente next_page.
  ```
</CodeGroup>

## Archiviare una sessione

Archivia una sessione per impedire l'invio di nuovi eventi preservandone la cronologia. Una sessione `running` non può essere archiviata; per archiviarla, invia un [evento `user.interrupt`](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#interrupt-the-agent) da solo e attendi che la sessione diventi `idle`. Se un'[esecuzione di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#while-a-run-is-open) è aperta, l'archiviazione potrebbe restituire un errore 400, anche quando la sessione è `idle`, oppure potrebbe riuscire e terminare l'esecuzione. Prima di archiviare, invia un `user.message` che [chieda all'agente di fermare le sue esecuzioni](https://platform.claude.com/docs/it/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), oppure attendi che ogni esecuzione sia terminata. Quindi archivia la sessione una volta che è `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>

## Eliminare una sessione

Elimina una sessione per rimuoverne definitivamente il record, gli eventi e la sandbox associata. Una sessione `running` non può essere eliminata; per eliminarla, invia un [evento `user.interrupt`](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#interrupt-the-agent) da solo e attendi che la sessione diventi `idle`. Se un'[esecuzione di workflow](https://platform.claude.com/docs/it/managed-agents/workflow-runs#while-a-run-is-open) è aperta, l'eliminazione potrebbe restituire un errore 400, anche quando la sessione è `idle`, oppure potrebbe riuscire. Dopo un'eliminazione riuscita, nessun evento `workflow_run` segnala la fine delle esecuzioni della sessione. Prima di eliminare, invia un `user.message` che [chieda all'agente di fermare le sue esecuzioni](https://platform.claude.com/docs/it/managed-agents/workflow-runs#interrupt-a-session-with-runs-open), oppure attendi che ogni esecuzione sia terminata. Quindi elimina la sessione una volta che è `idle`.

Memory store, vault, skill, ambienti e agenti sono risorse indipendenti e non sono interessati dall'eliminazione della sessione. Anche i file che hai caricato tramite la Files API non sono interessati, ma i file prodotti dalla sessione stessa sono limitati ad essa e vengono eliminati definitivamente insieme al suo filesystem. Scarica tutto ciò che devi conservare prima di eliminare la sessione. Un file di output scritto alla fine dell'ultimo turno può richiedere alcuni secondi dopo che la sessione è diventata idle per comparire nell'[elenco dei file della sessione](https://platform.claude.com/docs/it/managed-agents/files#listing-and-downloading-session-files), quindi verifica prima che i file che ti aspetti siano elencati.

<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>