---
title: Eine Session starten
url: https://platform.claude.com/docs/de/managed-agents/sessions
description: Erstelle eine Session, um deinen Agenten auszuführen und mit der Ausführung von Aufgaben zu beginnen.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Eine Session ist eine Agenteninstanz innerhalb einer Umgebung. Jede Session referenziert einen [Agenten](https://platform.claude.com/docs/de/managed-agents/agent-setup) und eine [Umgebung](https://platform.claude.com/docs/de/managed-agents/environments) (beide werden separat erstellt) und verwaltet den Gesprächsverlauf über mehrere Interaktionen hinweg. Sessions folgen einem zweistufigen Lebenszyklus: Zuerst [erstellst du die Session](https://platform.claude.com/docs/de/managed-agents/sessions#creating-a-session), dann [sendest du ein User-Event](https://platform.claude.com/docs/de/managed-agents/sessions#starting-the-session), um die Arbeit zu starten. Du kannst beide Schritte auch mit [`initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`)](https://platform.claude.com/docs/de/managed-agents/sessions#seed-the-session-with-initial-events) zu einem einzigen Aufruf zusammenfassen.

## Eine Session erstellen

Eine Session benötigt eine `agent`-ID und eine `environment`-ID. Agenten sind versionierte Ressourcen; wenn du die `agent` (csharp, go: `Agent`)-ID als String übergibst, wird die Session mit der neuesten Agentenversion erstellt.

<CodeGroup>
  ```bash cURL
  curl -fsSL 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"'"
    }'
  ```

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

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

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

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

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

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

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

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id
  )
  ```
</CodeGroup>

Um eine Session an eine bestimmte Agentenversion zu binden, übergib ein Objekt. So kannst du genau steuern, welche Version ausgeführt wird, und Rollouts neuer Versionen unabhängig voneinander staffeln.

<CodeGroup>
  ```bash cURL
  curl -fsSL 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": {"type": "agent", "id": "'"$AGENT_ID"'", "version": 1},
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create <<YAML
  agent:
    type: agent
    id: $AGENT_ID
    version: 1
  environment_id: $ENVIRONMENT_ID
  YAML
  ```

  ```python Python
  pinned_session = client.beta.sessions.create(
      agent={"type": "agent", "id": agent.id, "version": 1},
      environment_id=environment.id,
  )
  ```

  ```typescript TypeScript
  const pinnedSession = await client.beta.sessions.create({
    agent: { type: "agent", id: agent.id, version: 1 },
    environment_id: environment.id
  });
  ```

  ```csharp C#
  var pinnedSession = await client.Beta.Sessions.Create(new()
  {
      Agent = new BetaManagedAgentsAgentParams
      {
          Type = BetaManagedAgentsAgentParamsType.Agent,
          ID = agent.ID,
          Version = 1,
      },
      EnvironmentID = environment.ID,
  });
  ```

  ```go Go
  pinnedSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
  			Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
  			ID:      agent.ID,
  			Version: anthropic.Int(1),
  		},
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var pinnedSession = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(BetaManagedAgentsAgentParams.builder()
          .type(BetaManagedAgentsAgentParams.Type.AGENT)
          .id(agent.id())
          .version(1)
          .build())
      .environmentId(environment.id())
      .build());
  ```

  ```php PHP
  $pinnedSession = $client->beta->sessions->create(
      agent: ['type' => 'agent', 'id' => $agent->id, 'version' => 1],
      environmentID: $environment->id,
  );
  ```

  ```ruby Ruby
  pinned_session = client.beta.sessions.create(
    agent: {type: :agent, id: agent.id, version: 1},
    environment_id: environment.id
  )
  ```
</CodeGroup>

### Die Session mit initialen Events befüllen

Du kannst eine Session in einem einzigen Aufruf erstellen und ihre Arbeit starten. `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) ist ein optionales Array initialer [Events](https://platform.claude.com/docs/de/managed-agents/reference#event-types), die bei der Erstellung an die Session gesendet und der Reihe nach verarbeitet werden. Es unterstützt `user.message`- und [`user.define_outcome`](https://platform.claude.com/docs/de/managed-agents/define-outcomes)-Events und akzeptiert maximal 50 Events. Eine nicht leere Liste startet die Agentenschleife im selben Aufruf: Die Session wird direkt im Status `running` erstellt, ohne weitere Anfrage.

Das folgende Beispiel erstellt eine Session mit einer einzelnen `user.message` in `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`):

<CodeGroup>
  ```bash cURL
  seeded_session=$(curl -fsSL 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"'",
      "initial_events": [
        {
          "type": "user.message",
          "content": [{"type": "text", "text": "List the files in the working directory."}]
        }
      ]
    }'
  )
  SEEDED_SESSION_ID=$(jq -r '.id' <<< "$seeded_session")

  # initial_events werden in der Create-Antwort nicht zurückgegeben; liste die Events
  # der Session auf, um die geseedete Nachricht zu sehen.
  seeded_events=$(curl -fsSL \
    "https://api.anthropic.com/v1/sessions/$SEEDED_SESSION_ID/events" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01")
  echo "Seeded event: $(jq -r \
    '.data[] | select(.type == "user.message") | .content[0].text' <<< "$seeded_events")"
  ```

  ```bash CLI
  SEEDED_SESSION_ID=$(ant beta:sessions create \
    --transform id --raw-output <<YAML
  agent: $AGENT_ID
  environment_id: $ENVIRONMENT_ID
  initial_events:
    - type: user.message
      content:
        - type: text
          text: List the files in the working directory.
  YAML
  )

  # initial_events werden in der Create-Antwort nicht zurückgegeben; liste die Events
  # der Session auf, um die geseedete Nachricht zu sehen.
  echo "Seeded event: $(ant beta:sessions:events list \
    --session-id "$SEEDED_SESSION_ID" \
    --format raw \
    --transform 'data.#(type=="user.message").content.0.text' --raw-output)"
  ```

  ```python Python
  seeded_session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      initial_events=[
          {
              "type": "user.message",
              "content": [
                  {"type": "text", "text": "List the files in the working directory."}
              ],
          },
      ],
  )
  # initial_events werden in der Create-Antwort nicht zurückgegeben; lies sie
  # aus der Event-Liste der Session zurück.
  for event in client.beta.sessions.events.list(seeded_session.id):
      if event.type == "user.message":
          for block in event.content:
              if block.type == "text":
                  print(f"Seeded event: {block.text}")
  ```

  ```typescript TypeScript
  const seededSession = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    initial_events: [
      {
        type: "user.message",
        content: [{ type: "text", text: "List the files in the working directory." }]
      }
    ]
  });

  // initial_events werden in der Create-Antwort nicht zurückgegeben; liste die
  // Events der Session auf, um die vorbefüllte Nachricht zurückzulesen.
  for await (const event of client.beta.sessions.events.list(seededSession.id)) {
    if (event.type === "user.message") {
      for (const block of event.content) {
        if (block.type === "text") {
          console.log(`Seeded event: ${block.text}`);
        }
      }
    }
  }
  ```

  ```csharp C#
  var seededSession = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      InitialEvents =
      [
          new BetaManagedAgentsUserMessageEventParams
          {
              Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
              Content =
              [
                  new BetaManagedAgentsTextBlock
                  {
                      Type = BetaManagedAgentsTextBlockType.Text,
                      Text = "List the files in the working directory.",
                  },
              ],
          },
      ],
  });
  // initial_events werden in der Create-Antwort nicht zurückgegeben; lies sie
  // aus der Event-Liste der Session zurück.
  var seededEvents = await client.Beta.Sessions.Events.List(seededSession.ID);
  await foreach (var sessionEvent in seededEvents.Paginate())
  {
      if (sessionEvent.TryPickUserMessage(out var userMessage))
      {
          foreach (var contentBlock in userMessage.Content)
          {
              if (contentBlock.TryPickBetaManagedAgentsTextBlock(out var textBlock))
              {
                  Console.WriteLine($"Seeded event: {textBlock.Text}");
              }
          }
      }
  }
  ```

  ```go Go
  seededSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	InitialEvents: []anthropic.BetaSessionNewParamsInitialEventUnion{{
  		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
  			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
  			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
  				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
  					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
  					Text: "List the files in the working directory.",
  				},
  			}},
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  // initial_events werden in der Create-Antwort nicht zurückgegeben, also liste die
  // Events der Session auf, um die gesetzte user.message zurückzulesen.
  seededEvents, err := client.Beta.Sessions.Events.List(ctx, seededSession.ID, anthropic.BetaSessionEventListParams{})
  if err != nil {
  	panic(err)
  }
  for _, event := range seededEvents.Data {
  	if event.Type != "user.message" {
  		continue
  	}
  	for _, contentBlock := range event.AsUserMessage().Content {
  		if contentBlock.Type == "text" {
  			fmt.Printf("Seeded event: %s\n", contentBlock.AsText().Text)
  		}
  	}
  }
  ```

  ```java Java
  var seededSession = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .addInitialEvent(BetaManagedAgentsUserMessageEventParams.builder()
          .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
          .addTextContent("List the files in the working directory.")
          .build())
      .build());
  // initial_events werden in der Create-Antwort nicht zurückgegeben; liste die
  // Events der Session auf, um die gesetzte user.message zurückzulesen.
  for (var event : client.beta().sessions().events().list(seededSession.id()).autoPager()) {
      if (event.isUserMessage()) {
          for (var contentBlock : event.asUserMessage().content()) {
              if (contentBlock.isText()) {
                  IO.println("Seeded event: " + contentBlock.asText().text());
              }
          }
      }
  }
  ```

  ```php PHP
  $seededSession = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      initialEvents: [
          [
              'type' => 'user.message',
              'content' => [['type' => 'text', 'text' => 'List the files in the working directory.']],
          ],
      ],
  );

  // initial_events werden in der Create-Antwort nicht zurückgegeben; lies sie
  // aus der Event-Liste der Session zurück.
  $seededEvents = $client->beta->sessions->events->list($seededSession->id);
  foreach ($seededEvents->getItems() as $event) {
      if ($event->type === 'user.message') {
          echo "Seeded event: {$event->content[0]->text}\n";
      }
  }
  ```

  ```ruby Ruby
  seeded_session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    initial_events: [
      {
        type: :"user.message",
        content: [{type: :text, text: "List the files in the working directory."}]
      }
    ]
  )

  # initial_events werden in der Create-Antwort nicht zurückgegeben; lies sie aus
  # der Event-Liste der Session zurück.
  client.beta.sessions.events.list(seeded_session.id).auto_paging_each do |event|
    next unless event.type == :"user.message"
    event.content.each do |block|
      puts "Seeded event: #{block.text}" if block.type == :text
    end
  end
  ```
</CodeGroup>

Kein anderer Event-Typ wird akzeptiert. Events, die auf einen Agenten-Turn antworten (`user.tool_confirmation`, `user.tool_result` und `user.custom_tool_result`), werden nicht akzeptiert, weil noch kein Agenten-Turn existiert, und `user.interrupt` wird nicht akzeptiert, weil es keinen Turn zum Anhalten gibt. Anders als `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) bei einem geplanten Deployment akzeptieren die `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) einer Session kein `system.message`.

Jedes Event in `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) wird validiert und gespeichert, bevor die Antwort auf die Erstellung zurückgegeben wird – in Listenreihenfolge und mit einer vom Server zugewiesenen ID, genau so, als hättest du es unmittelbar nach der Erstellung an den Endpunkt zum [Senden von Events](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#send-events) gesendet. Auch die inhaltlichen Regeln pro Event sind dieselben wie bei diesem Endpunkt. Eine leere Liste ist gleichbedeutend mit dem Weglassen des Feldes. Die Validierung erfolgt nach dem Alles-oder-nichts-Prinzip: Wenn ein Event die Validierung nicht besteht, wird die gesamte Anfrage abgelehnt und keine Session erstellt.

Die Erstellungsanfrage wird in den folgenden Fällen abgelehnt:

| Bedingung                                                                                                                                                         | Status |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| Mehr als ein `user.define_outcome`-Event                                                                                                                          | 400    |
| Ein `user.define_outcome`-Event ohne `rubric`                                                                                                                     | 400    |
| Mehr als 100 aus Dateien stammende [`document`-Content-Blöcke](https://platform.claude.com/docs/de/build-with-claude/files#document-blocks) in der gesamten Liste | 400    |
| Ein Request-Body über 32 MB                                                                                                                                       | 413    |

Ein `user.define_outcome`-Event in `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) wird unter denselben Bedingungen akzeptiert wie beim Senden an eine bestehende Session; siehe [Ergebnisse definieren](https://platform.claude.com/docs/de/managed-agents/define-outcomes).

### Agentenkonfiguration für eine Session überschreiben

Du kannst `agent` (csharp, go: `Agent`) in drei Formen übergeben: als Agenten-ID-String, als Objekt mit fixierter Version (`type: "agent"`) oder als Overrides-Objekt. Die Overrides-Form ändert Teile der Agentenkonfiguration für eine einzelne Session. Verwende sie, um in einer Session ein anderes Modell auszuprobieren oder ein zusätzliches Tool freizugeben, ohne den Agenten zu versionieren. Setze für die Overrides-Form `type` auf `agent_with_overrides` und übergib die `id` (csharp, go: `ID`) des Agenten sowie optional eine `version` (csharp, go: `Version`) (lass `version` (csharp, go: `Version`) weg, um die neueste Version des Agenten zu verwenden). Füge dann beliebige der Felder `model` (csharp, go: `Model`), `system` (csharp, go: `System`; ruby: `system_`), `tools` (csharp, go: `Tools`), `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) oder `skills` (csharp, go: `Skills`) mit den Werten hinzu, die die Session verwenden soll.

Jedes überschreibbare Feld folgt denselben drei Regeln:

* **Feld weglassen:** Die Session übernimmt den Wert aus der Agentenversion, die sie referenziert.

* **Feld auf `null` setzen oder bei Listenfeldern auf ein leeres Array:** Die Session läuft mit geleertem Feld. Diese Regel gilt vollständig für `system` (csharp, go: `System`; ruby: `system_`) und `skills` (csharp, go: `Skills`). Es gibt drei Ausnahmen:

  * `model` kann nie geleert werden. Eine Session benötigt immer ein Modell, daher gibt `model: null` einen 400-Fehler `agent_model_required` zurück.
  * Das Leeren von `tools` gibt einen 400-Fehler zurück, wenn die effektiven `skills` (csharp, go: `Skills`) der Session nicht leer sind, da Skills das `read`-Tool benötigen. Andernfalls leeren `tools: null` und `tools: []` das Feld.
  * Das Leeren von `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`) gibt einen 400-Fehler zurück, wenn die effektiven `tools` (csharp, go: `Tools`) der Session noch ein `mcp_toolset` enthalten, das einen der Server des Agenten referenziert. Überschreibe `tools` (csharp, go: `Tools`) in derselben Anfrage, um diese `mcp_toolset`-Einträge zu entfernen, und leere dann `mcp_servers` (java, php: `mcpServers`; csharp: `McpServers`; go: `MCPServers`).

* **Feld auf einen Wert setzen:** Der Wert ersetzt den Wert des Agenten vollständig. Overrides werden nie mit der Konfiguration des Agenten zusammengeführt, daher muss ein `tools` (csharp, go: `Tools`)-Override jedes Tool auflisten, das die Session haben soll. Ebenso ersetzt ein `model` (csharp, go: `Model`)-Override das `model` (csharp, go: `Model`)-Objekt des Agenten vollständig, sodass der eigene `effort` (csharp, go: `Effort`) des Agenten nicht übernommen wird. Um die Session mit einem bestimmten Effort-Level auszuführen, setze `effort` (csharp, go: `Effort`) innerhalb des `model` (csharp, go: `Model`)-Objekts des Overrides. Ein Level, das das Modell nicht unterstützt, gibt einen 400-Fehler zurück, und ein `model` (csharp, go: `Model`)-Override ohne `effort` (csharp, go: `Effort`) läuft mit dem Standard-Effort-Level dieses Modells.

Overrides gelten nur für die Session, die du erstellst. Sie ändern weder die Agentenressource noch erstellen sie eine neue Agentenversion, sodass andere Sessions, die denselben Agenten referenzieren, nicht betroffen sind.

In der Antwort spiegelt das `agent` (csharp, go: `Agent`)-Objekt die Konfiguration wider, mit der die Session nach Anwendung der Overrides läuft. Seine `id` (csharp, go: `ID`) und `version` (csharp, go: `Version`) identifizieren weiterhin den Agenten und die Version, auf die die Overrides angewendet werden. So kannst du eine Session auf ihren Basisagenten zurückverfolgen.

Das folgende Beispiel startet eine Session, die das Modell überschreibt und den System-Prompt leert:

<CodeGroup>
  ```bash cURL
  curl -fsSL 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": {
        "type": "agent_with_overrides",
        "id": "'"$AGENT_ID"'",
        "model": {"id": "claude-sonnet-5-5"},
        "system": null
      },
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  # Das `agent` in der Antwort ist der aufgelöste Snapshot: Jeder Override ersetzt dieses
  # Feld nur für diese Session, und die Agent-Ressource behält ihre id und version.
  ant beta:sessions create <<YAML
  agent:
    type: agent_with_overrides
    id: $AGENT_ID
    model:
      id: claude-sonnet-5-5
    system: null
  environment_id: $ENVIRONMENT_ID
  YAML
  ```

  ```python Python
  override_session = client.beta.sessions.create(
      agent={
          "type": "agent_with_overrides",
          "id": agent.id,
          "model": {"id": "claude-sonnet-5-5"},
          "system": None,  # clear the agent's system prompt for this session
      },
      environment_id=environment.id,
  )
  # Der Agent in der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  print(f"Model: {override_session.agent.model.id}")
  print(f"System: {override_session.agent.system}")
  ```

  ```typescript TypeScript
  const overrideSession = await client.beta.sessions.create({
    agent: {
      type: "agent_with_overrides",
      id: agent.id,
      model: { id: "claude-sonnet-5-5" },
      system: null // clear the agent's system prompt for this session
    },
    environment_id: environment.id
  });
  // Der Agent der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  console.log(`Model: ${overrideSession.agent.model.id}`);
  console.log(`System: ${overrideSession.agent.system}`);
  ```

  ```csharp C#
  var overrideSession = await client.Beta.Sessions.Create(new()
  {
      Agent = new BetaManagedAgentsAgentWithOverridesParams
      {
          Type = BetaManagedAgentsAgentWithOverridesParamsType.AgentWithOverrides,
          ID = agent.ID,
          Model = new BetaManagedAgentsModelConfigParams
          {
              ID = BetaManagedAgentsModel.ClaudeSonnet5_5,
          },
          System = null, // clear the agent's system prompt for this session
      },
      EnvironmentID = environment.ID,
  });
  // Der Agent in der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  Console.WriteLine($"Model: {overrideSession.Agent.Model.ID.Raw()}");
  Console.WriteLine($"System: {overrideSession.Agent.System ?? "null"}");
  ```

  ```go Go
  overrideSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfBetaManagedAgentsAgentWithOverridess: &anthropic.BetaManagedAgentsAgentWithOverridesParams{
  			Type: anthropic.BetaManagedAgentsAgentWithOverridesParamsTypeAgentWithOverrides,
  			ID:   agent.ID,
  			Model: anthropic.BetaManagedAgentsModelConfigParams{
  				ID: anthropic.BetaManagedAgentsModelClaudeSonnet5_5,
  			},
  			// Lösche den System-Prompt des Agents für diese Session.
  			System: param.Null[string](),
  		},
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  // Der Agent in der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  fmt.Printf("Model: %s\n", overrideSession.Agent.Model.ID)
  fmt.Printf("System: %q\n", overrideSession.Agent.System)
  ```

  ```java Java
  var overrideSession = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(BetaManagedAgentsAgentWithOverridesParams.builder()
          .type(BetaManagedAgentsAgentWithOverridesParams.Type.AGENT_WITH_OVERRIDES)
          .id(agent.id())
          .model(BetaManagedAgentsModelConfigParams.builder()
              .id(BetaManagedAgentsModel.CLAUDE_SONNET_5_5)
              .build())
          .system((String) null) // clear the agent's system prompt for this session
          .build())
      .environmentId(environment.id())
      .build());
  // Der Agent in der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  IO.println("Model: " + overrideSession.agent().model().id());
  IO.println("System: " + overrideSession.agent().system().orElse("null"));
  ```

  ```php PHP
  $overrides = BetaManagedAgentsAgentWithOverridesParams::with(
      id: $agent->id,
      type: 'agent_with_overrides',
      model: ['id' => 'claude-sonnet-5-5'],
  );
  // Leere den System-Prompt für diese Session. Der Array-Zugriff ist hier entscheidend:
  // create() entfernt Nulls aus rohen Arrays und ::with() behandelt null-Argumente als ausgelassen.
  $overrides['system'] = null;

  $overrideSession = $client->beta->sessions->create(
      agent: $overrides,
      environmentID: $environment->id,
  );
  // Der Agent in der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  echo "Model: {$overrideSession->agent->model->id}\n";
  echo 'System: ' . ($overrideSession->agent->system ?? 'null') . "\n";
  ```

  ```ruby Ruby
  # Der System-Prompt-Override heißt `system_` (mit Unterstrich am Ende), weil das einfache
  # `system` Rubys Kernel#system ist. Auf nil setzen löscht den Prompt.
  override_session = client.beta.sessions.create(
    agent: Anthropic::Beta::BetaManagedAgentsAgentWithOverridesParams.new(
      type: :agent_with_overrides,
      id: agent.id,
      model: {id: "claude-sonnet-5-5"},
      system_: nil
    ),
    environment_id: environment.id
  )
  # Der Agent in der Antwort ist der aufgelöste Snapshot mit angewendeten Overrides.
  puts "Model: #{override_session.agent.model.id}"
  puts "System: #{override_session.agent.system_.inspect}"
  ```
</CodeGroup>

#### Die Inferenz-Geo für eine Session fixieren

Da ein `model` (csharp, go: `Model`)-Override das `model` (csharp, go: `Model`)-Objekt des Agenten vollständig ersetzt, setzt oder entfernt es auch die Fixierung der [Inferenz-Geo](https://platform.claude.com/docs/de/manage-claude/data-residency) des Modells für die Session: Ein Override, das `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) enthält, fixiert die Region, die die Modellanfragen der Session bedient, und eines, das es weglässt, entfernt die Fixierung des Agenten, sodass die Session der `default_inference_geo` des Workspace folgt. Der überschriebene Wert wird bei der Erstellung der Session gegen die `allowed_inference_geos` des Workspace validiert.

Das folgende Beispiel startet eine Session von einem Agenten, dessen Modell keine Geo-Fixierung hat, fixiert die Modellanfragen der Session auf US-Inferenz, indem es `inference_geo` (java, php: `inferenceGeo`; csharp, go: `InferenceGeo`) in den `model` (csharp, go: `Model`)-Override aufnimmt, und gibt den Wert aus, der in `agent.model` (csharp, go: `Agent.Model`) der Antwort zurückgegeben wird:

<CodeGroup>
  ```bash cURL
  # Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Pinnen hinzu.
  session=$(curl -fsSL 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": {
        "type": "agent_with_overrides",
        "id": "'"$AGENT_ID"'",
        "model": {"id": "claude-opus-5-5", "inference_geo": "us"}
      },
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  )
  echo "Inference geo: $(jq -r '.agent.model.inference_geo' <<< "$session")"
  ```

  ```bash CLI
  # Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
  session=$(ant beta:sessions create <<YAML
  agent:
    type: agent_with_overrides
    id: $AGENT_ID
    model:
      id: claude-opus-5-5
      inference_geo: us
  environment_id: $ENVIRONMENT_ID
  YAML
  )
  echo "Inference geo: $(jq -r '.agent.model.inference_geo' <<< "$session")"
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent={
          "type": "agent_with_overrides",
          "id": agent.id,
          # Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
          "model": {"id": "claude-opus-5-5", "inference_geo": "us"},
      },
      environment_id=environment.id,
  )
  print(f"Inference geo: {session.agent.model.inference_geo}")
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: {
      type: "agent_with_overrides",
      id: agent.id,
      // Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
      model: { id: "claude-opus-5-5", inference_geo: "us" }
    },
    environment_id: environment.id
  });
  console.log(`Inference geo: ${session.agent.model.inference_geo}`);
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = new BetaManagedAgentsAgentWithOverridesParams
      {
          Type = BetaManagedAgentsAgentWithOverridesParamsType.AgentWithOverrides,
          ID = agent.ID,
          // Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
          Model = new BetaManagedAgentsModelConfigParams
          {
              ID = BetaManagedAgentsModel.ClaudeOpus5_5,
              InferenceGeo = "us",
          },
      },
      EnvironmentID = environment.ID,
  });
  Console.WriteLine($"Inference geo: {session.Agent.Model.InferenceGeo}");
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfBetaManagedAgentsAgentWithOverridess: &anthropic.BetaManagedAgentsAgentWithOverridesParams{
  			Type: anthropic.BetaManagedAgentsAgentWithOverridesParamsTypeAgentWithOverrides,
  			ID:   agent.ID,
  			// Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
  			Model: anthropic.BetaManagedAgentsModelConfigParams{
  				ID:           anthropic.BetaManagedAgentsModelClaudeOpus5_5,
  				InferenceGeo: anthropic.String("us"),
  			},
  		},
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  fmt.Printf("Inference geo: %s\n", session.Agent.Model.InferenceGeo)
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(BetaManagedAgentsAgentWithOverridesParams.builder()
          .type(BetaManagedAgentsAgentWithOverridesParams.Type.AGENT_WITH_OVERRIDES)
          .id(agent.id())
          // Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
          .model(BetaManagedAgentsModelConfigParams.builder()
              .id(BetaManagedAgentsModel.CLAUDE_OPUS_5_5)
              .inferenceGeo("us")
              .build())
          .build())
      .environmentId(environment.id())
      .build());
  IO.println("Inference geo: " + session.agent().model().inferenceGeo().orElseThrow());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: BetaManagedAgentsAgentWithOverridesParams::with(
          id: $agent->id,
          type: 'agent_with_overrides',
          // Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
          model: BetaManagedAgentsModelConfigParams::with(
              id: 'claude-opus-5-5',
              inferenceGeo: 'us',
          ),
      ),
      environmentID: $environment->id,
  );
  echo "Inference geo: {$session->agent->model->inferenceGeo}\n";
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: {
      type: :agent_with_overrides,
      id: agent.id,
      # Ersetzt das `model` des Agents vollständig: gib `id` erneut an, füge `inference_geo` zum Fixieren hinzu.
      model: {id: "claude-opus-5-5", inference_geo: "us"}
    },
    environment_id: environment.id
  )
  puts "Inference geo: #{session.agent.model.inference_geo}"
  ```
</CodeGroup>

<Tip>
  Der Agent definiert, wie sich Claude innerhalb der Session verhält, einschließlich Modell, System-Prompt, Tools und MCP-Servern. Details findest du unter [Deinen Agenten definieren](https://platform.claude.com/docs/de/managed-agents/agent-setup).
</Tip>

### Ein Session-Budget festlegen

Um zu begrenzen, was eine Session ausgeben kann, übergib beim Erstellen das optionale `budget` (csharp, go: `Budget`)-Objekt. Ein Budget ist eine harte Obergrenze für die Listenkosten der Session: Die Plattform bepreist alles, was die Session verbraucht, zu öffentlichen Listenpreisen, und die Session stellt keine neuen Modellanfragen mehr, sobald diese laufende Summe `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) erreicht. Setze `type` (csharp, go: `Type`) auf `limit` und gib `max_list_cost` (java, php: `maxListCost`; csharp, go: `MaxListCost`) einen `amount` (csharp, go: `Amount`) und eine `currency` (csharp, go: `Currency`). `amount` (csharp, go: `Amount`) ist eine ganze Zahl von US-Cent, geschrieben als String, etwa `"125"` für 1,25 $. Die API nimmt einen String statt einer Zahl entgegen, damit niemals eine Gleitkomma-Rundung angewendet wird. `USD` ist derzeit die einzige unterstützte Währung. Wenn die Session die Obergrenze erreicht, pausiert sie und wird mit dem Stop-Grund `budget_reached` inaktiv. Die Obergrenze wird zwischen Modellanfragen durchgesetzt, sodass die Anfrage, die sie überschreitet, zuerst abgeschlossen wird und die endgültigen Listenkosten der Session [geringfügig über der Obergrenze](https://platform.claude.com/docs/de/managed-agents/budgets#when-a-session-reaches-its-budget) liegen können. Ein Budget kann nur bei der Erstellung angehängt werden: Du kannst es später [ändern oder entfernen](https://platform.claude.com/docs/de/managed-agents/session-operations#updating-the-session-budget), aber du kannst keines zu einer Session hinzufügen, die ohne Budget erstellt wurde.

Das folgende Beispiel erstellt eine Session mit einem Budget von 1,25 $:

<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"'",
      "budget": {
        "type": "limit",
        "max_list_cost": {"amount": "125", "currency": "USD"}
      }
    }'
  ```

  ```bash CLI
  # Lass den Betrag in Anführungszeichen, damit er als String und nicht als Zahl gesendet wird.
  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" \
    --budget '{type: limit, max_list_cost: {amount: "125", currency: USD}}'
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      budget={
          "type": "limit",
          "max_list_cost": {"amount": "125", "currency": "USD"},
      },
  )
  print(session.id, session.budget.max_list_cost.amount)  # sesn_01... 125
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    budget: {
      type: "limit",
      max_list_cost: { amount: "125", currency: "USD" }
    }
  });
  console.log(session.id, session.budget?.max_list_cost.amount); // sesn_01... 125
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Budget = new()
      {
          Type = BetaManagedAgentsBudgetLimitType.Limit,
          MaxListCost = new() { Amount = "125", Currency = BetaCurrency.Usd },
      },
  });
  Console.WriteLine($"{session.ID} {session.Budget?.MaxListCost.Amount}");  // sesn_01... 125
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	Budget: anthropic.BetaManagedAgentsBudgetLimitParam{
  		Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit,
  		MaxListCost: anthropic.BetaMonetaryAmountParam{
  			Amount:   "125",
  			Currency: anthropic.BetaCurrencyUsd,
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(session.ID, session.Budget.MaxListCost.Amount) // sesn_01... 125
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .budget(BetaManagedAgentsBudgetLimit.builder()
          .type(BetaManagedAgentsBudgetLimit.Type.LIMIT)
          .maxListCost(BetaMonetaryAmount.builder()
              .amount("125")
              .currency(BetaCurrency.USD)
              .build())
          .build())
      .build());
  IO.println(session.id() + " " + session.budget().orElseThrow().maxListCost().amount());  // sesn_01... 125
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      budget: [
          'type' => 'limit',
          'max_list_cost' => ['amount' => '125', 'currency' => 'USD'],
      ],
  );
  echo "{$session->id} {$session->budget->maxListCost->amount}\n"; // sesn_01... 125
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    budget: {
      type: "limit",
      max_list_cost: {amount: "125", currency: "USD"}
    }
  )
  puts "#{session.id} #{session.budget.max_list_cost.amount}" # sesn_01... 125
  ```
</CodeGroup>

Unter [Session-Budgets](https://platform.claude.com/docs/de/managed-agents/budgets) erfährst du, wie die Durchsetzung funktioniert, was zu den Listenkosten zählt und wie sich Budgets in Multiagenten-Sessions verhalten.

## MCP-Authentifizierung über Vaults

Wenn dein Agent MCP-Tools verwendet, die eine Authentifizierung erfordern, übergib bei der Session-Erstellung `vault_ids` (java: `vaultIds`; php: `vaultIDs`; csharp: `VaultIds`; go: `VaultIDs`), um einen Vault mit gespeicherten OAuth-Anmeldedaten zu referenzieren. Anthropic übernimmt die Token-Aktualisierung für dich. Unter [Mit Vaults authentifizieren](https://platform.claude.com/docs/de/managed-agents/vaults) erfährst du, wie du Vaults erstellst und Anmeldedaten registrierst.

<CodeGroup>
  ```bash cURL
  curl -fsSL 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"'",
      "vault_ids": ["'"$VAULT_ID"'"]
    }'
  ```

  ```bash CLI
  ant beta:sessions create <<YAML
  agent: $AGENT_ID
  environment_id: $ENVIRONMENT_ID
  vault_ids:
    - $VAULT_ID
  YAML
  ```

  ```python Python
  vault_session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      vault_ids=[vault.id],
  )
  ```

  ```typescript TypeScript
  const vaultSession = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    vault_ids: [vault.id]
  });
  ```

  ```csharp C#
  var vaultSession = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      VaultIds = [vault.ID],
  });
  ```

  ```go Go
  vaultSession, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	VaultIDs:      []string{vault.ID},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var vaultSession = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .addVaultId(vault.id())
      .build());
  ```

  ```php PHP
  $vaultSession = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      vaultIDs: [$vault->id],
  );
  ```

  ```ruby Ruby
  vault_session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    vault_ids: [vault.id]
  )
  ```
</CodeGroup>

## Die Session starten

Das Erstellen einer Session ohne `initial_events` (java, php: `initialEvents`; csharp, go: `InitialEvents`) registriert die Session, startet aber keine Arbeit; die Sandbox der Umgebung beginnt mit der Bereitstellung, sobald die Session erstellt ist, sodass der erste Tool-Aufruf nicht darauf warten muss. Um eine Aufgabe zu delegieren, sende Events an die Session mithilfe eines [User-Events](https://platform.claude.com/docs/de/managed-agents/reference#event-types). Um das erste Event stattdessen in der Erstellungsanfrage mitzugeben, siehe [Die Session mit initialen Events befüllen](https://platform.claude.com/docs/de/managed-agents/sessions#seed-the-session-with-initial-events). Die Session fungiert als Zustandsautomat, der den Fortschritt verfolgt, während Events die eigentliche Ausführung steuern.

<CodeGroup>
  ```bash cURL
  curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
    -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 '{
      "events": [
        {
          "type": "user.message",
          "content": [{"type": "text", "text": "List the files in the working directory."}]
        }
      ]
    }'
  ```

  ```bash CLI
  ant beta:sessions:events send \
    --session-id "$SESSION_ID" <<'YAML'
  events:
    - type: user.message
      content:
        - type: text
          text: List the files in the working directory.
  YAML
  ```

  ```python Python
  client.beta.sessions.events.send(
      session.id,
      events=[
          {
              "type": "user.message",
              "content": [
                  {"type": "text", "text": "List the files in the working directory."}
              ],
          },
      ],
  )
  ```

  ```typescript TypeScript
  await client.beta.sessions.events.send(session.id, {
    events: [
      {
        type: "user.message",
        content: [{ type: "text", text: "List the files in the working directory." }]
      }
    ]
  });
  ```

  ```csharp C#
  await client.Beta.Sessions.Events.Send(session.ID, new()
  {
      Events =
      [
          new BetaManagedAgentsUserMessageEventParams
          {
              Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
              Content =
              [
                  new BetaManagedAgentsTextBlock
                  {
                      Type = BetaManagedAgentsTextBlockType.Text,
                      Text = "List the files in the working directory.",
                  },
              ],
          },
      ],
  });
  ```

  ```go Go
  if _, 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: "List the files in the working directory.",
  				},
  			}},
  		},
  	}},
  }); err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().sessions().events().send(
      session.id(),
      EventSendParams.builder()
          .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
              .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
              .addTextContent("List the files in the working directory.")
              .build())
          .build());
  ```

  ```php PHP
  $client->beta->sessions->events->send(
      $session->id,
      events: [
          [
              'type' => 'user.message',
              'content' => [['type' => 'text', 'text' => 'List the files in the working directory.']],
          ],
      ],
  );
  ```

  ```ruby Ruby
  client.beta.sessions.events.send_(
    session.id,
    events: [
      {
        type: :"user.message",
        content: [{type: :text, text: "List the files in the working directory."}]
      }
    ]
  )
  ```
</CodeGroup>

Unter [Session-Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) erfährst du, wie du die Antworten des Agenten streamst und Tool-Bestätigungen verarbeitest.

Unter [Session-Status](https://platform.claude.com/docs/de/managed-agents/session-operations#session-statuses) findest du die Status, die eine Session durchläuft.

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Session-Operationen" icon="settings" href="https://platform.claude.com/docs/de/managed-agents/session-operations">
    Claude Managed Agents-Sessions abrufen, auflisten, aktualisieren, archivieren und löschen.
  </Card>

  <Card title="Session-Event-Stream" icon="lightning" href="https://platform.claude.com/docs/de/managed-agents/events-and-streaming">
    Events senden, Antworten streamen und deine Session während der Ausführung unterbrechen oder umlenken.
  </Card>

  <Card title="Geplante Deployments" icon="arrows-clockwise" href="https://platform.claude.com/docs/de/managed-agents/scheduled-deployments">
    Deployments mit der Claude API erstellen und verwalten: einen Agenten nach einem wiederkehrenden Cron-Zeitplan ausführen und seinen Ausführungsverlauf einsehen.
  </Card>
</CardGroup>