---
title: Erste Schritte mit Claude Managed Agents
url: https://platform.claude.com/docs/de/managed-agents/quickstart
description: Erstelle deinen ersten autonomen Agenten.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
  zdr:
    eligibility: not-eligible
    note: Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
---

Dieser Leitfaden führt dich durch das Erstellen eines Agenten, das Einrichten einer Umgebung, das Starten einer Session und das Streaming von Agentenantworten.

Lass Claude Code deinen Agenten für dich einrichten

```text
/claude-api managed-agents-onboard
```

## Kernkonzepte

| Konzept | Beschreibung |
| ----- | ----- |
| **Agent** | Das Modell, der System-Prompt, Tools, MCP-Server und Skills |
| **Umgebung** | Konfiguration dafür, wo Sessions ausgeführt werden: eine von Anthropic verwaltete Cloud-Sandbox oder eine selbst gehostete Sandbox auf deiner eigenen Infrastruktur |
| **Session** | Eine laufende Agent-Instanz innerhalb eines Environments, die eine bestimmte Aufgabe ausführt und Ausgaben erzeugt |
| **Events** | Nachrichten, die zwischen deiner Anwendung und dem Agenten ausgetauscht werden (Benutzer-Turns, Tool-Ergebnisse, Statusaktualisierungen) |

## Bevor du beginnst

<Steps continues>
  <Step title="Erstelle ein Claude Console-Konto">
    [Registriere dich](https://platform.claude.com/) für ein Claude Console-Konto oder melde dich bei deinem bestehenden Konto an.
  </Step>

  <Step title="Wähle aus, wie du dich authentifizierst">
    Für die lokale Entwicklung wird die Anmeldung über die CLI empfohlen.

    Follow the steps for one of the following options.
  </Step>
</Steps>

**CLI**

<Steps continued>
  <Step title="Installiere die CLI" stepNumber={3}>
    <Tabs noDeepLinks>
      <Tab title="Homebrew (macOS)">
        ```bash
        brew install anthropics/tap/ant
        ```
      </Tab>

      <Tab title="curl (Linux/WSL)">
        Für Linux-Umgebungen lädst du das Release-Binary direkt herunter.

        ```bash
        VERSION=2.12.1
        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
        ```

        Alle Releases findest du auf der [GitHub-Releases-Seite](https://github.com/anthropics/anthropic-cli/releases).
      </Tab>

      <Tab title="go install">
        Du kannst die CLI auch aus dem Quellcode mit `go install` installieren, was Go 1.26.10 oder höher erfordert.

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

        `go install` legt die Binärdatei in `$(go env GOPATH)/bin` ab. Füge dieses Verzeichnis zu deinem `PATH` hinzu, falls es dort noch nicht enthalten ist:

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

  <Step title="Melde dich an" stepNumber={4}>
    ```bash
    ant auth login
    ```

    Sobald die Anmeldung abgeschlossen ist, übernehmen die SDKs und die CLI deine Anmeldedaten automatisch.
  </Step>
</Steps>

**API-Key**

<Steps continued>
  <Step title="Erstelle einen API-Key" stepNumber={3}>
    Erstelle einen [API-Key](https://platform.claude.com/settings/keys) in der Claude Console.
  </Step>

  <Step title="Setze die Umgebungsvariable" stepNumber={4}>
    Die SDKs und die CLI lesen deinen Key aus `ANTHROPIC_API_KEY`:

    ```bash
    export ANTHROPIC_API_KEY="your-api-key-here"
    ```
  </Step>
</Steps>

**API-Key**

Um die CLI-Beispiele auszuführen, installiere die CLI:

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

  <Tab title="curl (Linux/WSL)">
    Für Linux-Umgebungen lädst du das Release-Binary direkt herunter.

    ```bash
    VERSION=2.12.1
    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
    ```

    Alle Releases findest du auf der [GitHub-Releases-Seite](https://github.com/anthropics/anthropic-cli/releases).
  </Tab>

  <Tab title="go install">
    Du kannst die CLI auch aus dem Quellcode mit `go install` installieren, was Go 1.26.10 oder höher erfordert.

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

    `go install` legt die Binärdatei in `$(go env GOPATH)/bin` ab. Füge dieses Verzeichnis zu deinem `PATH` hinzu, falls es dort noch nicht enthalten ist:

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

## Das SDK installieren

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

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

  <Tab title="Java">
    <Tabs>
      <Tab title="Gradle">
        ```kotlin
        implementation("com.anthropic:anthropic-java:3.12.0")
        ```
      </Tab>

      <Tab title="Maven">
        ```xml
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java</artifactId>
            <version>3.12.0</version>
        </dependency>
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go/v2
    ```
  </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>

## Deine erste Session erstellen

<Steps>
  <Step title="Einen Agenten erstellen">
    Erstelle einen Agenten, der das Modell, den „system prompt“ (System-Prompt) und die verfügbaren Tools definiert.

    <CodeGroup defaultLanguage="CLI">
      **CLI-Anmeldung**

      <CodeGroupItem>
        ```bash cURL
        curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
          -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
          -H "anthropic-version: 2026-10-21" \
          -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",
                "configs": [
                  {"name": "web_search", "enabled": false},
                  {"name": "web_fetch", "enabled": false}
                ]
              }
            ]
          }'
        ```

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </CodeGroupItem>

      **API-Key**

      <CodeGroupItem>
        ```bash cURL
        curl -sS --fail-with-body https://api.anthropic.com/v1/agents \
          -H "x-api-key: $ANTHROPIC_API_KEY" \
          -H "anthropic-version: 2026-10-21" \
          -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",
                "configs": [
                  {"name": "web_search", "enabled": false},
                  {"name": "web_fetch", "enabled": false}
                ]
              }
            ]
          }'
        ```

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </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
              configs:
                - name: web_search
                  enabled: false
                - name: web_fetch
                  enabled: false
          ---

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

        [`ant apply`](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/apply) gibt die ID des Agenten aus und speichert sie in `claude-lock.json`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </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",
                    "configs": [
                        {"name": "web_search", "enabled": False},
                        {"name": "web_fetch", "enabled": False},
                    ],
                },
            ],
        )

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </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",
              configs: [
                { name: "web_search", enabled: false },
                { name: "web_fetch", enabled: false }
              ]
            }
          ]
        });

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </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
                {
                    Configs =
                    [
                        new BetaManagedAgentsWebSearchToolConfigParams { Enabled = false },
                        new BetaManagedAgentsWebFetchToolConfigParams { Enabled = false },
                    ],
                },
            ],
        });

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </CodeGroupItem>

      <CodeGroupItem>
        ```go Go
        package main

        import (
        	"context"
        	"fmt"

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

        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{
        				Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
        					{OfWebSearch: &anthropic.BetaManagedAgentsWebSearchToolConfigParams{
        						Enabled: anthropic.Bool(false),
        					}},
        					{OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
        						Enabled: anthropic.Bool(false),
        					}},
        				},
        			},
        		}},
        	})
        	if err != nil {
        		panic(err)
        	}

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </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.agents.BetaManagedAgentsWebFetchToolConfigParams;
        import com.anthropic.models.beta.agents.BetaManagedAgentsWebSearchToolConfigParams;
        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.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()
                    .addConfig(BetaManagedAgentsWebSearchToolConfigParams.builder()
                        .enabled(false)
                        .build())
                    .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
                        .enabled(false)
                        .build())
                    .build())
                .build());

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </CodeGroupItem>

      <CodeGroupItem>
        ```php PHP
        use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
        use Anthropic\Beta\Agents\BetaManagedAgentsModel;
        use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
        use Anthropic\Beta\Agents\BetaManagedAgentsWebSearchToolConfigParams;
        use Anthropic\Client;

        $client = new Client();

        $agent = $client->beta->agents->create(
            name: 'Coding Assistant',
            model: BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
            system: 'You are a helpful coding assistant. Write clean, well-documented code.',
            tools: [
                BetaManagedAgentsAgentToolset20260401Params::with(
                    configs: [
                        BetaManagedAgentsWebSearchToolConfigParams::with(enabled: false),
                        BetaManagedAgentsWebFetchToolConfigParams::with(enabled: false),
                    ],
                ),
            ],
        );

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </CodeGroupItem>

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

        client = Anthropic::Client.new

        agent = client.beta.agents.create(
          name: "Coding Assistant",
          model: Anthropic::Beta::BetaManagedAgentsModel::CLAUDE_OPUS_5_5,
          system_: "You are a helpful coding assistant. Write clean, well-documented code.",
          tools: [
            {
              type: "agent_toolset_20260401",
              configs: [
                {name: "web_search", enabled: false},
                {name: "web_fetch", enabled: false}
              ]
            }
          ]
        )

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

        Speichere die zurückgegebene `agent.id`. Du wirst sie in jeder Session referenzieren, die du erstellst.
      </CodeGroupItem>
    </CodeGroup>

    Der Tool-Typ `agent_toolset_20260401` aktiviert die vorgefertigten Agenten-Tools (Bash, Dateioperationen, Websuche und mehr). Dieses Beispiel deaktiviert Websuche und Web-Fetch, da die Aufgabe in diesem Leitfaden, das Schreiben eines kurzen Python-Skripts, ohne das Web auskommt. Gib einem Agenten [nur die Tools, die er benötigt](https://platform.claude.com/docs/de/managed-agents/secure-deployment#give-the-agent-the-smallest-tool-set). Unter [Tools](https://platform.claude.com/docs/de/managed-agents/tools) findest du die vollständige Liste und die Konfigurationsoptionen pro Tool.
  </Step>

  <Step title="Eine Umgebung erstellen">
    Eine Umgebung definiert die Sandbox, in der dein Agent läuft. Diese hier verwendet `limited` [Netzwerkzugriff](https://platform.claude.com/docs/de/managed-agents/environments#networking) mit erlaubten Paketmanagern, sodass Code, der in der Sandbox läuft, öffentliche [Paket-Registries und Code-Hosts](https://platform.claude.com/docs/de/managed-agents/environments#package-manager-hosts) erreichen kann. Bei `limited` Networking gilt die [`allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`)-Liste](https://platform.claude.com/docs/de/managed-agents/environments#networking) auch für Websuche und Web-Fetch, obwohl sie außerhalb der Sandbox laufen. Wenn keine Hosts aufgelistet sind, wie in dieser Umgebung, liefern diese Tools keine Seiten oder Suchergebnisse. Wenn dein eigener Agent diese Tools verwendet, füge die benötigten Hosts zu dieser Liste hinzu.

    <CodeGroup defaultLanguage="CLI">
      **CLI-Anmeldung**

      <CodeGroupItem>
        ```bash cURL
        curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
          -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
          -H "anthropic-version: 2026-10-21" \
          -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}
            }
          }'
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </CodeGroupItem>

      **API-Key**

      <CodeGroupItem>
        ```bash cURL
        curl -sS --fail-with-body https://api.anthropic.com/v1/environments \
          -H "x-api-key: $ANTHROPIC_API_KEY" \
          -H "anthropic-version: 2026-10-21" \
          -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}
            }
          }'
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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/de/cli-sdks-libraries/cli/apply) speichert auch die ID der Umgebung in `claude-lock.json`. Um den Agenten und die Umgebung mit einem einzigen Befehl zu erstellen, übergib beide Dateien: `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}")
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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}`);
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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}");
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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)
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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());
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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";
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </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}"
        ```

        Speichere auch die zurückgegebene `environment.id`.
      </CodeGroupItem>
    </CodeGroup>

    <Tip>
      Dieser Schnellstart verwendet eine Cloud-Umgebung. Um zu entscheiden, ob du Tools stattdessen mit einer 

      [selbst gehosteten Sandbox](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes)

       auf deiner eigenen Infrastruktur ausführen möchtest, siehe 

      [Eine Agentenumgebung auswählen](https://platform.claude.com/docs/de/managed-agents/choosing-an-environment)

      .
    </Tip>
  </Step>

  <Step title="Eine Session starten">
    Erstelle eine Session, die deinen Agenten und deine Umgebung referenziert.

    <CodeGroup>
      **CLI-Anmeldung**

      ```bash cURL
      curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
        -H "Authorization: Bearer $(ant auth print-credentials --access-token)" \
        -H "anthropic-version: 2026-10-21" \
        -H "anthropic-beta: managed-agents-2026-04-01" \
        -H "content-type: application/json" \
        -d '{
          "agent": "'"$AGENT_ID"'",
          "environment_id": "'"$ENVIRONMENT_ID"'",
          "title": "Quickstart session"
        }'
      ```

      **API-Key**

      ```bash cURL
      curl -sS --fail-with-body https://api.anthropic.com/v1/sessions \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2026-10-21" \
        -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="Eine Nachricht senden und die Antwort streamen">
    Öffne einen Stream, sende ein User-Event und verarbeite dann die Events, sobald sie eintreffen:

    <CodeGroup exclude="shell">
      <CodeGroupItem language="cURL">
        Dieser Workflow benötigt mehr Logik als ein einzelner Shell-Befehl. Verwende das [Anthropic SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
      </CodeGroupItem>

      <CodeGroupItem language="CLI">
        Dieser Workflow benötigt mehr Logik als ein einzelner Shell-Befehl. Verwende das [Anthropic SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
      </CodeGroupItem>

      ```python Python
      with client.beta.sessions.events.stream(session.id) as stream:
          # Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
          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",
                          },
                      ],
                  },
              ],
          )

          # Verarbeite Streaming-Events
          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);

      // Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
      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"
              }
            ]
          }
        ]
      });

      // Verarbeite Streaming-Events
      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);

      // Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
      await client.Beta.Sessions.Events.Send(session.ID, new()
      {
          Events =
          [
              new BetaManagedAgentsUserMessageEventParams
              {
                  Content =
                  [
                      new BetaManagedAgentsTextBlock
                      {
                          Text = "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                      },
                  ],
              },
          ],
      });

      // Verarbeite Streaming-Events
      await foreach (var streamEvent in stream)
      {
          if (streamEvent.Value is BetaManagedAgentsAgentMessageEvent message)
          {
              foreach (var block in message.Content)
              {
                  if (block.Value is BetaManagedAgentsTextBlock textBlock)
                  {
                      Console.Write(textBlock.Text);
                  }
              }
          }
          else if (streamEvent.Value is BetaManagedAgentsAgentToolUseEvent toolUse)
          {
              Console.WriteLine($"\n[Using tool: {toolUse.Name}]");
          }
          else if (streamEvent.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()

      	// Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
      	_, err = client.Beta.Sessions.Events.Send(ctx, session.ID, anthropic.BetaSessionEventSendParams{
      		Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
      			OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
      				Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
      					OfText: &anthropic.BetaManagedAgentsTextBlockParam{
      						Text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
      					},
      				}},
      			},
      		}},
      	})
      	if err != nil {
      		panic(err)
      	}

      	// Verarbeite Streaming-Events
      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())) {
          // Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
          client.beta().sessions().events().send(session.id(), EventSendParams.builder()
              .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                  .addTextContent("Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt")
                  .build())
              .build());

          // Verarbeite Streaming-Events
          loop:
          for (var event : stream) {
              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);

      // Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
      $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'],
                  ],
              ],
          ],
      );

      // Verarbeite Streaming-Ereignisse
      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)

      # Sende die Benutzernachricht, nachdem der Stream geöffnet wurde
      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"}]
        }]
      )

      # Verarbeite Streaming-Events
      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
          # ignoriere andere Event-Typen
        end
      end
      ```
    </CodeGroup>

    Der Agent schreibt ein Python-Skript, führt es in der Sandbox aus und überprüft, ob die Ausgabedatei erstellt wurde. Deine Ausgabe sieht ungefähr so aus:

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

## Was passiert

Wenn du ein User-Event sendest, führt Claude Managed Agents Folgendes aus:

1. **Stellt eine Sandbox bereit:** Deine Umgebungskonfiguration bestimmt, wie sie aufgebaut wird.
2. **Führt die Agentenschleife aus:** Claude bestimmt anhand deiner Nachricht, welche Tools verwendet werden.
3. **Führt Tools aus:** Dateischreibvorgänge, Bash-Befehle und andere Tool-Aufrufe laufen innerhalb der Sandbox.
4. **Streamt Events:** Du erhältst Echtzeit-Updates, während der Agent arbeitet.
5. **Wechselt in den Leerlauf:** Der Agent sendet ein `session.status_idle`-Event, wenn er nichts mehr zu tun hat.

## Eine vollständige App erstellen

Jeder dieser Schnellstarts kombiniert Claude Managed Agents mit einem beliebten Chat-Framework zu einer vollständigen, lauffähigen Anwendung. In jedem davon rendert das Framework die Chat-Oberfläche, während eine verwaltete Session die Agentenschleife serverseitig ausführt: Die Session hält das Transkript, führt Tools in einer Sandbox aus und streamt Events, die das Frontend rendert.

<CardGroup cols={3}>
  <Card title="Chat SDK" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/chat-sdk">
    Ein Recherche-Analyst in einem Browser-Chat, der mit dem Chat SDK von Vercel erstellt wurde. Jede Unterhaltung ist eine persistente Session, die ihre Antwort streamt, während ein Live-Feed die Tool-Aufrufe anzeigt. Durch Austauschen des Chat-SDK-Adapters wird derselbe Handler nach Slack, Teams, Discord oder WhatsApp verlagert.
  </Card>

  <Card title="assistant-ui" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/assistant-ui">
    Ein Tabellenkalkulations-Analyst in einem Chat, der aus assistant-ui-Primitiven aufgebaut ist. Sessions bilden die Thread-Liste, ein Reducer wandelt das Event-Log der Session in Nachrichten und Tool-Karten um, und jeder Bash-Befehl rendert vor seiner Ausführung eine Inline-Abfrage zum Erlauben/Ablehnen.
  </Card>

  <Card title="CopilotKit (AG-UI)" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/copilot-kit-ag-ui">
    Ein persönlicher Finanzassistent in einem CopilotKit-Chat. Der AG-UI-Adapter für Claude Managed Agents ordnet jeden Chat-Thread einer verwalteten Session zu und streamt Antworten Token für Token, und benutzerdefinierte Tools rendern interaktive Diagramme inline in der Unterhaltung.
  </Card>
</CardGroup>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Definiere deinen Agenten" icon="brain" href="https://platform.claude.com/docs/de/managed-agents/agent-setup">
    Erstelle wiederverwendbare, versionierte Agentenkonfigurationen
  </Card>

  <Card title="Umgebungen konfigurieren" icon="settings" href="https://platform.claude.com/docs/de/managed-agents/environments">
    Passe Networking- und Sandbox-Einstellungen an
  </Card>

  <Card title="Agenten-Tools" icon="tool" href="https://platform.claude.com/docs/de/managed-agents/tools">
    Aktiviere bestimmte Tools für deinen Agenten
  </Card>

  <Card title="Session-Event-Stream" icon="lightning" href="https://platform.claude.com/docs/de/managed-agents/events-and-streaming">
    Verarbeite Events und steuere den Agenten, während er läuft
  </Card>

  <Card title="Geplante Deployments" icon="arrows-clockwise" href="https://platform.claude.com/docs/de/managed-agents/scheduled-deployments">
    Führe deinen Agenten nach einem wiederkehrenden Cron-Zeitplan aus
  </Card>

  <Card title="Schnellstart Wissens-Wiki" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/managed-agents/knowledge-wiki">
    Destilliere einen Dokumentenkorpus einmalig zu einem Wissens-Wiki und beantworte daraus wiederholte Fragen zu einem Bruchteil der Kosten
  </Card>
</CardGroup>
