---
title: Inizia con Claude Managed Agents
url: https://platform.claude.com/docs/it/managed-agents/quickstart
description: Crea il tuo primo agente autonomo.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Questa guida ti accompagna nella creazione di un agente, nella configurazione di un ambiente, nell'avvio di una sessione e nello streaming delle risposte dell'agente.

<Tip>
  **Preferisci una procedura guidata interattiva?** Esegui `/claude-api managed-agents-onboard` nell'ultima versione di [Claude Code](https://claude.com/product/claude-code) per una configurazione guidata e domande e risposte interattive.
</Tip>

## Concetti fondamentali

| Concetto        | Descrizione                                                                                                                                                  |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Agent**       | Il modello, il prompt di sistema, gli strumenti, i server MCP e le skill                                                                                     |
| **Environment** | Configurazione del luogo in cui vengono eseguite le sessioni: una sandbox cloud gestita da Anthropic oppure una sandbox self-hosted sulla tua infrastruttura |
| **Session**     | Un'istanza di agente in esecuzione all'interno di un ambiente, che svolge un compito specifico e genera output                                               |
| **Events**      | Messaggi scambiati tra la tua applicazione e l'agente (turni dell'utente, risultati degli strumenti, aggiornamenti di stato)                                 |

## Prerequisiti

* Un [account Claude Console](https://platform.claude.com)
* Una [chiave API](https://platform.claude.com/settings/keys)

## Installa la CLI

<Tabs>
  <Tab title="Homebrew (macOS)">
    ```bash
    brew install anthropics/tap/ant
    ```
  </Tab>

  <Tab title="curl (Linux/WSL)">
    Per gli ambienti Linux, scarica direttamente il binario della release.

    ```bash
    VERSION=1.42.0
    OS=$(uname -s | tr '[:upper:]' '[:lower:]')
    case $(uname -m) in
      x86_64) ARCH=amd64 ;;
      aarch64) ARCH=arm64 ;;
    esac
    curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
      | sudo tar -xz -C /usr/local/bin ant
    ```

    Puoi trovare tutte le release nella [pagina delle release su GitHub](https://github.com/anthropics/anthropic-cli/releases).
  </Tab>

  <Tab title="Go">
    Puoi anche installare la CLI dal codice sorgente usando `go install`. Richiede Go 1.25 o versioni successive.

    ```bash
    go install github.com/anthropics/anthropic-cli/cmd/ant@latest
    ```

    Il binario viene collocato in `$(go env GOPATH)/bin`. Aggiungilo al tuo `PATH` se non è già presente:

    ```bash
    export PATH="$PATH:$(go env GOPATH)/bin"
    ```
  </Tab>
</Tabs>

Verifica l'installazione:

```bash
ant --version
```

## Installa l'SDK

<Tabs>
  <Tab title="Python">
    ```bash
    pip install anthropic
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash
    npm install @anthropic-ai/sdk
    ```
  </Tab>

  <Tab title="Java">
    ```groovy Gradle
    implementation("com.anthropic:anthropic-java:2.73.0")
    ```
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go
    ```
  </Tab>

  <Tab title="C#">
    ```bash
    dotnet add package Anthropic
    ```
  </Tab>

  <Tab title="Ruby">
    ```bash
    bundle add anthropic
    ```
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
    ```
  </Tab>
</Tabs>

Imposta la tua chiave API come variabile d'ambiente:

```bash
export ANTHROPIC_API_KEY="your-api-key-here"
```

## Crea la tua prima sessione

<Steps>
  <Step title="Crea un agente">
    Crea un agente che definisce il modello, il "system prompt" (prompt di sistema) e gli strumenti disponibili.

    <CodeGroup defaultLanguage="CLI">
      <CodeGroupItem>
        ```bash cURL
        curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
          -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": "Coding Assistant",
            "model": "claude-opus-5-5",
            "system": "You are a helpful coding assistant. Write clean, well-documented code.",
            "tools": [
              {"type": "agent_toolset_20260401"}
            ]
          }'
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```bash CLI
        ant apply coding-assistant.md
        ```

        <File filename="coding-assistant.md">
          ```markdown
          ---
          name: Coding Assistant
          model: claude-opus-5-5
          tools:
            - type: agent_toolset_20260401
          ---

          You are a helpful coding assistant. Write clean, well-documented code.
          ```
        </File>

        [`ant apply`](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/apply) stampa l'ID dell'agente e lo registra in `claude-lock.json`. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```python Python
        from anthropic import Anthropic

        client = Anthropic()

        agent = client.beta.agents.create(
            name="Coding Assistant",
            model="claude-opus-5-5",
            system="You are a helpful coding assistant. Write clean, well-documented code.",
            tools=[
                {"type": "agent_toolset_20260401"},
            ],
        )

        print(f"Agent ID: {agent.id}, version: {agent.version}")
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```typescript TypeScript
        import Anthropic from "@anthropic-ai/sdk";

        const client = new Anthropic();

        const agent = await client.beta.agents.create({
          name: "Coding Assistant",
          model: "claude-opus-5-5",
          system: "You are a helpful coding assistant. Write clean, well-documented code.",
          tools: [
            { type: "agent_toolset_20260401" },
          ],
        });

        console.log(`Agent ID: ${agent.id}, version: ${agent.version}`);
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```csharp C#
        using Anthropic;
        using Anthropic.Models.Beta.Agents;
        using Anthropic.Models.Beta.Environments;
        using Anthropic.Models.Beta.Sessions;
        using Anthropic.Models.Beta.Sessions.Events;

        var client = new AnthropicClient();

        var agent = await client.Beta.Agents.Create(new()
        {
            Name = "Coding Assistant",
            Model = BetaManagedAgentsModel.ClaudeOpus5_5,
            System = "You are a helpful coding assistant. Write clean, well-documented code.",
            Tools =
            [
                new BetaManagedAgentsAgentToolset20260401Params
                {
                    Type = "agent_toolset_20260401",
                },
            ],
        });

        Console.WriteLine($"Agent ID: {agent.ID}, version: {agent.Version}");
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```go Go
        package main

        import (
        	"context"
        	"fmt"

        	"github.com/anthropics/anthropic-sdk-go"
        )

        func main() {
        	client := anthropic.NewClient()
        	ctx := context.Background()

        	agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
        		Name: "Coding Assistant",
        		Model: anthropic.BetaManagedAgentsModelConfigParams{
        			ID: anthropic.BetaManagedAgentsModelClaudeOpus5_5,
        		},
        		System: anthropic.String("You are a helpful coding assistant. Write clean, well-documented code."),
        		Tools: []anthropic.BetaAgentNewParamsToolUnion{{
        			OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
        				Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
        			},
        		}},
        	})
        	if err != nil {
        		panic(err)
        	}

        	fmt.Printf("Agent ID: %s, version: %d\n", agent.ID, agent.Version)
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```java Java
        import com.anthropic.client.okhttp.AnthropicOkHttpClient;
        import com.anthropic.models.beta.agents.AgentCreateParams;
        import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
        import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
        import com.anthropic.models.beta.environments.BetaCloudConfigParams;
        import com.anthropic.models.beta.environments.BetaLimitedNetworkParams;
        import com.anthropic.models.beta.environments.EnvironmentCreateParams;
        import com.anthropic.models.beta.sessions.SessionCreateParams;
        import com.anthropic.models.beta.sessions.events.BetaManagedAgentsStreamSessionEvents;
        import com.anthropic.models.beta.sessions.events.BetaManagedAgentsUserMessageEventParams;
        import com.anthropic.models.beta.sessions.events.EventSendParams;

        void main() {
            var client = AnthropicOkHttpClient.fromEnv();

            var agent = client.beta().agents().create(AgentCreateParams.builder()
                .name("Coding Assistant")
                .model(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
                .system("You are a helpful coding assistant. Write clean, well-documented code.")
                .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
                    .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
                    .build())
                .build());

            IO.println("Agent ID: " + agent.id() + ", version: " + agent.version());
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```php PHP
        use Anthropic\Client;

        $client = new Client();

        $agent = $client->beta->agents->create(
            name: 'Coding Assistant',
            model: 'claude-opus-5-5',
            system: 'You are a helpful coding assistant. Write clean, well-documented code.',
            tools: [
                ['type' => 'agent_toolset_20260401'],
            ],
        );

        echo "Agent ID: {$agent->id}, version: {$agent->version}\n";
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>

      <CodeGroupItem>
        ```ruby Ruby
        require "anthropic"

        client = Anthropic::Client.new

        agent = client.beta.agents.create(
          name: "Coding Assistant",
          model: "claude-opus-5-5",
          system_: "You are a helpful coding assistant. Write clean, well-documented code.",
          tools: [{type: "agent_toolset_20260401"}]
        )

        puts "Agent ID: #{agent.id}, version: #{agent.version}"
        ```

        Salva l'`agent.id` restituito. Lo userai come riferimento in ogni sessione che crei.
      </CodeGroupItem>
    </CodeGroup>

    Il tipo di strumento `agent_toolset_20260401` abilita l'intero set di strumenti predefiniti per agenti (bash, operazioni sui file, ricerca web e altro). Consulta [Strumenti](https://platform.claude.com/docs/it/managed-agents/tools) per l'elenco completo e le opzioni di configurazione di ciascuno strumento.
  </Step>

  <Step title="Crea un ambiente">
    Un ambiente definisce la "sandbox" (ambiente isolato) in cui viene eseguito il tuo agente. Questo usa il [networking](https://platform.claude.com/docs/it/managed-agents/environments#networking) `limited` con i gestori di pacchetti consentiti, così il codice eseguito nella sandbox può raggiungere i [registri di pacchetti e gli host di codice](https://platform.claude.com/docs/it/managed-agents/environments#package-manager-hosts) pubblici. La ricerca web e il recupero web vengono eseguiti al di fuori della sandbox, e questa guida rapida non ne ha bisogno. Con il networking `limited`, anche a essi si applica l'[elenco `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)](https://platform.claude.com/docs/it/managed-agents/environments#networking). In questo ambiente non restituiscono pagine né risultati di ricerca, perché non elenca alcun host. Per il tuo agente, elenca gli host di cui ha bisogno in `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

    <CodeGroup defaultLanguage="CLI">
      <CodeGroupItem>
        ```bash cURL
        curl -sS --fail-with-body 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": "quickstart-env",
            "config": {
              "type": "cloud",
              "networking": {"type": "limited", "allow_package_managers": true}
            }
          }'
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```bash CLI
        ant apply environment.yaml
        ```

        <File filename="environment.yaml">
          ```yaml
          # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
          name: quickstart-env
          config:
            type: cloud
            networking:
              type: limited
              allow_package_managers: true
          ```
        </File>

        [`ant apply`](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/apply) registra anche l'ID dell'ambiente in `claude-lock.json`. Per creare l'agente e l'ambiente con un solo comando, passa entrambi i file: `ant apply coding-assistant.md environment.yaml`.
      </CodeGroupItem>

      <CodeGroupItem>
        ```python Python
        environment = client.beta.environments.create(
            name="quickstart-env",
            config={
                "type": "cloud",
                "networking": {"type": "limited", "allow_package_managers": True},
            },
        )

        print(f"Environment ID: {environment.id}")
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```typescript TypeScript
        const environment = await client.beta.environments.create({
          name: "quickstart-env",
          config: {
            type: "cloud",
            networking: { type: "limited", allow_package_managers: true },
          },
        });

        console.log(`Environment ID: ${environment.id}`);
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```csharp C#
        var environment = await client.Beta.Environments.Create(new()
        {
            Name = "quickstart-env",
            Config = new BetaCloudConfigParams
            {
                Networking = new BetaLimitedNetworkParams { AllowPackageManagers = true },
            },
        });

        Console.WriteLine($"Environment ID: {environment.ID}");
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```go Go
        environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
        	Name: "quickstart-env",
        	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
        		OfCloud: &anthropic.BetaCloudConfigParams{
        			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
        				OfLimited: &anthropic.BetaLimitedNetworkParams{
        					AllowPackageManagers: anthropic.Bool(true),
        				},
        			},
        		},
        	},
        })
        if err != nil {
        	panic(err)
        }

        fmt.Printf("Environment ID: %s\n", environment.ID)
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```java Java
        var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
            .name("quickstart-env")
            .config(BetaCloudConfigParams.builder()
                .networking(BetaLimitedNetworkParams.builder()
                    .allowPackageManagers(true)
                    .build())
                .build())
            .build());

        IO.println("Environment ID: " + environment.id());
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```php PHP
        $environment = $client->beta->environments->create(
            name: 'quickstart-env',
            config: [
                'type' => 'cloud',
                'networking' => ['type' => 'limited', 'allow_package_managers' => true],
            ],
        );

        echo "Environment ID: {$environment->id}\n";
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>

      <CodeGroupItem>
        ```ruby Ruby
        environment = client.beta.environments.create(
          name: "quickstart-env",
          config: {type: "cloud", networking: {type: "limited", allow_package_managers: true}}
        )

        puts "Environment ID: #{environment.id}"
        ```

        Salva anche l'`environment.id` restituito.
      </CodeGroupItem>
    </CodeGroup>

    <Tip>
      Questa guida rapida usa un ambiente cloud. Per decidere se eseguire invece gli strumenti sulla tua infrastruttura con una 

      [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes)

      , consulta 

      [Scegliere un ambiente per l'agente](https://platform.claude.com/docs/it/managed-agents/choosing-an-environment)

      .
    </Tip>
  </Step>

  <Step title="Avvia una sessione">
    Crea una sessione che fa riferimento al tuo agente e al tuo ambiente.

    <CodeGroup>
      ```bash cURL
      curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
        -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": "'"$AGENT_ID"'",
          "environment_id": "'"$ENVIRONMENT_ID"'",
          "title": "Quickstart session"
        }'
      ```

      ```bash CLI
      ant beta:sessions create \
        --agent "$AGENT_ID" \
        --environment-id "$ENVIRONMENT_ID" \
        --title "Quickstart session"
      ```

      ```python Python
      session = client.beta.sessions.create(
          agent=agent.id,
          environment_id=environment.id,
          title="Quickstart session",
      )

      print(f"Session ID: {session.id}")
      ```

      ```typescript TypeScript
      const session = await client.beta.sessions.create({
        agent: agent.id,
        environment_id: environment.id,
        title: "Quickstart session",
      });

      console.log(`Session ID: ${session.id}`);
      ```

      ```csharp C#
      var session = await client.Beta.Sessions.Create(new()
      {
          Agent = agent.ID,
          EnvironmentID = environment.ID,
          Title = "Quickstart session",
      });

      Console.WriteLine($"Session ID: {session.ID}");
      ```

      ```go Go
      session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
      	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
      	EnvironmentID: environment.ID,
      	Title:         anthropic.String("Quickstart session"),
      })
      if err != nil {
      	panic(err)
      }

      fmt.Printf("Session ID: %s\n", session.ID)
      ```

      ```java Java
      var session = client.beta().sessions().create(SessionCreateParams.builder()
          .agent(agent.id())
          .environmentId(environment.id())
          .title("Quickstart session")
          .build());

      IO.println("Session ID: " + session.id());
      ```

      ```php PHP
      $session = $client->beta->sessions->create(
          agent: $agent->id,
          environmentID: $environment->id,
          title: 'Quickstart session',
      );

      echo "Session ID: {$session->id}\n";
      ```

      ```ruby Ruby
      session = client.beta.sessions.create(
        agent: agent.id,
        environment_id: environment.id,
        title: "Quickstart session"
      )

      puts "Session ID: #{session.id}"
      ```
    </CodeGroup>
  </Step>

  <Step title="Invia un messaggio e trasmetti la risposta in streaming">
    Apri uno stream, invia un evento utente, quindi elabora gli eventi man mano che arrivano:

    <CodeGroup exclude="shell">
      <CodeGroupItem language="cURL">
        Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
      </CodeGroupItem>

      <CodeGroupItem language="CLI">
        Questo flusso di lavoro richiede più logica di un singolo comando shell. Usa il [Claude SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per eseguirlo.
      </CodeGroupItem>

      ```python Python
      with client.beta.sessions.events.stream(session.id) as stream:
          # Invia il messaggio dell'utente dopo l'apertura dello stream
          client.beta.sessions.events.send(
              session.id,
              events=[
                  {
                      "type": "user.message",
                      "content": [
                          {
                              "type": "text",
                              "text": "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                          },
                      ],
                  },
              ],
          )

          # Elabora gli eventi di streaming
          for event in stream:
              match event.type:
                  case "agent.message":
                      for block in event.content:
                          if block.type == "text":
                              print(block.text, end="")
                  case "agent.tool_use":
                      print(f"\n[Using tool: {event.name}]")
                  case "session.status_idle":
                      print("\n\nAgent finished.")
                      break
      ```

      ```typescript TypeScript
      const stream = await client.beta.sessions.events.stream(session.id);

      // Invia il messaggio dell'utente dopo l'apertura dello stream
      await client.beta.sessions.events.send(session.id, {
        events: [
          {
            type: "user.message",
            content: [
              {
                type: "text",
                text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
              },
            ],
          },
        ],
      });

      // Elabora gli eventi di streaming
      loop: for await (const event of stream) {
        switch (event.type) {
          case "agent.message":
            for (const block of event.content) {
              if (block.type === "text") {
                process.stdout.write(block.text);
              }
            }
            break;
          case "agent.tool_use":
            console.log(`\n[Using tool: ${event.name}]`);
            break;
          case "session.status_idle":
            console.log("\n\nAgent finished.");
            break loop;
        }
      }
      ```

      ```csharp C#
      var stream = client.Beta.Sessions.Events.StreamStreaming(session.ID);

      // Invia il messaggio dell'utente dopo l'apertura dello stream
      await client.Beta.Sessions.Events.Send(session.ID, new()
      {
          Events =
          [
              new BetaManagedAgentsUserMessageEventParams
              {
                  Type = "user.message",
                  Content =
                  [
                      new BetaManagedAgentsTextBlock
                      {
                          Type = "text",
                          Text = "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                      },
                  ],
              },
          ],
      });

      // Elabora gli eventi in streaming
      await foreach (var ev in stream)
      {
          if (ev.Value is BetaManagedAgentsAgentMessageEvent message)
          {
              foreach (var block in message.Content)
              {
                  if (block.Value is BetaManagedAgentsTextBlock textBlock)
                  {
                      Console.Write(textBlock.Text);
                  }
              }
          }
          else if (ev.Value is BetaManagedAgentsAgentToolUseEvent toolUse)
          {
              Console.WriteLine($"\n[Using tool: {toolUse.Name}]");
          }
          else if (ev.Value is BetaManagedAgentsSessionStatusIdleEvent)
          {
              Console.WriteLine("\n\nAgent finished.");
              break;
          }
      }
      ```

      ```go Go
      	stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, anthropic.BetaSessionEventStreamParams{})
      	defer stream.Close()

      	// Invia il messaggio dell'utente dopo l'apertura dello stream
      	_, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
      		Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
      			OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
      				Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
      				Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
      					OfText: &anthropic.BetaManagedAgentsTextBlockParam{
      						Type: anthropic.BetaManagedAgentsTextBlockTypeText,
      						Text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
      					},
      				}},
      			},
      		}},
      	})
      	if err != nil {
      		panic(err)
      	}

      	// Elabora gli eventi in streaming
      loop:
      	for stream.Next() {
      		switch event := stream.Current().AsAny().(type) {
      		case anthropic.BetaManagedAgentsAgentMessageEvent:
      			for _, block := range event.Content {
      				if block.Type == "text" {
      					fmt.Print(block.Text)
      				}
      			}
      		case anthropic.BetaManagedAgentsAgentToolUseEvent:
      			fmt.Printf("\n[Using tool: %s]\n", event.Name)
      		case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
      			fmt.Print("\n\nAgent finished.\n")
      			break loop
      		}
      	}
      	if err := stream.Err(); err != nil {
      		panic(err)
      	}
      ```

      ```java Java
      try (var stream = client.beta().sessions().events().streamStreaming(session.id())) {
          // Invia il messaggio dell'utente dopo l'apertura dello stream
          client.beta().sessions().events().send(session.id(), EventSendParams.builder()
              .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                  .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
                  .addTextContent("Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt")
                  .build())
              .build());

          // Elabora gli eventi di streaming
          loop:
          for (var event : (Iterable<BetaManagedAgentsStreamSessionEvents>) stream.stream()::iterator) {
              switch (event.type().value()) {
                  case AGENT_MESSAGE -> event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
                  case AGENT_TOOL_USE -> IO.println("\n[Using tool: " + event.asAgentToolUse().name() + "]");
                  case SESSION_STATUS_IDLE -> {
                      IO.println("\n\nAgent finished.");
                      break loop;
                  }
              }
          }
      }
      ```

      ```php PHP
      $stream = $client->beta->sessions->events->streamStream($session->id);

      // Invia il messaggio dell'utente dopo l'apertura dello stream
      $client->beta->sessions->events->send(
          $session->id,
          events: [
              [
                  'type' => 'user.message',
                  'content' => [
                      ['type' => 'text', 'text' => 'Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt'],
                  ],
              ],
          ],
      );

      // Elabora gli eventi di streaming
      foreach ($stream as $event) {
          match (true) {
              $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent => array_walk(
                  $event->content,
                  static fn ($block) => $block instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock ? print($block->text) : null,
              ),
              $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentToolUseEvent => print("\n[Using tool: {$event->name}]\n"),
              $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent => print("\n\nAgent finished.\n"),
              default => null,
          };
          if ($event->type === 'session.status_idle') {
              break;
          }
      }
      ```

      ```ruby Ruby
      stream = client.beta.sessions.events.stream_events(session.id)

      # Invia il messaggio dell'utente dopo l'apertura dello stream
      client.beta.sessions.events.send_(
        session.id,
        events: [{
          type: "user.message",
          content: [{type: "text", text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt"}]
        }]
      )

      # Elabora gli eventi di streaming
      stream.each do |event|
        case event
        when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
          event.content.each { print it.text if it.is_a?(Anthropic::Beta::Sessions::BetaManagedAgentsTextBlock) }
        when Anthropic::Beta::Sessions::BetaManagedAgentsAgentToolUseEvent
          puts "\n[Using tool: #{event.name}]"
        when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
          puts "\n\nAgent finished."
          break
        else
          # ignora gli altri tipi di evento
        end
      end
      ```
    </CodeGroup>

    L'agente scrive uno script Python, lo esegue nella sandbox e verifica che il file di output sia stato creato. Il tuo output sarà simile a questo:

    ```text wrap
    I'll create a Python script that generates the first 20 Fibonacci numbers and saves them to a file.
    [Using tool: write]
    [Using tool: bash]
    The script ran successfully. Let me verify the output file.
    [Using tool: bash]
    fibonacci.txt contains the first 20 Fibonacci numbers (0 through 4181).

    Agent finished.
    ```
  </Step>
</Steps>

## Cosa succede

Quando invii un evento utente, Claude Managed Agents:

1. **Effettua il provisioning di una sandbox:** la configurazione del tuo ambiente determina come viene costruita.
2. **Esegue il ciclo dell'agente:** Claude determina quali strumenti usare in base al tuo messaggio.
3. **Esegue gli strumenti:** scritture di file, comandi bash e altre chiamate a strumenti vengono eseguite all'interno della sandbox.
4. **Trasmette eventi in streaming:** ricevi aggiornamenti in tempo reale mentre l'agente lavora.
5. **Diventa inattivo:** l'agente emette un evento `session.status_idle` quando non ha più nulla da fare.

## Costruisci un'app completa

Ciascuno di questi quickstart abbina Claude Managed Agents a un popolare framework di chat per realizzare un'applicazione completa ed eseguibile. In ognuno, il framework renderizza l'interfaccia di chat mentre una sessione gestita esegue il ciclo dell'agente lato server: la sessione conserva la trascrizione, esegue gli strumenti in una sandbox e trasmette in streaming gli eventi che il front end renderizza.

<CardGroup cols={3}>
  <Card title="Chat SDK" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/chat-sdk">
    Un analista di ricerca in una chat nel browser costruita con il Chat SDK di Vercel. Ogni conversazione è una sessione persistente che trasmette in streaming la propria risposta mentre un feed in tempo reale mostra le chiamate agli strumenti. Sostituendo l'adapter del Chat SDK, lo stesso handler si sposta su Slack, Teams, Discord o WhatsApp.
  </Card>

  <Card title="assistant-ui" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/assistant-ui">
    Un analista di fogli di calcolo in una chat costruita con le primitive di assistant-ui. Le sessioni costituiscono l'elenco dei thread, un reducer trasforma il log degli eventi della sessione in messaggi e schede degli strumenti, e ogni comando bash mostra un controllo Allow/Deny inline prima di essere eseguito.
  </Card>

  <Card title="CopilotKit (AG-UI)" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/copilot-kit-ag-ui">
    Un assistente per le finanze personali in una chat CopilotKit. L'adapter AG-UI per Claude Managed Agents mappa ogni thread di chat su una sessione gestita e trasmette le risposte in streaming token per token, e gli strumenti personalizzati renderizzano grafici interattivi inline nella conversazione.
  </Card>
</CardGroup>

## Prossimi passi

<CardGroup cols={2}>
  <Card title="Definisci il tuo agente" icon="brain" href="https://platform.claude.com/docs/it/managed-agents/agent-setup">
    Crea configurazioni di agenti riutilizzabili e versionate
  </Card>

  <Card title="Configura gli ambienti" icon="settings" href="https://platform.claude.com/docs/it/managed-agents/environments">
    Personalizza le impostazioni di rete e della sandbox
  </Card>

  <Card title="Strumenti dell'agente" icon="tool" href="https://platform.claude.com/docs/it/managed-agents/tools">
    Abilita strumenti specifici per il tuo agente
  </Card>

  <Card title="Stream di eventi della sessione" icon="lightning" href="https://platform.claude.com/docs/it/managed-agents/events-and-streaming">
    Gestisci gli eventi e guida l'agente durante l'esecuzione
  </Card>

  <Card title="Deployment pianificati" icon="arrows-clockwise" href="https://platform.claude.com/docs/it/managed-agents/scheduled-deployments">
    Esegui il tuo agente secondo una pianificazione cron ricorrente
  </Card>

  <Card title="Quickstart knowledge wiki" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/knowledge-wiki">
    Distilla una volta un corpus di documenti in una knowledge wiki, quindi rispondi a domande ripetute a partire da essa a una frazione del costo
  </Card>
</CardGroup>