---
title: Komprimierung auf Anfrage
url: https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand
description: Lass Claude eine Unterhaltung zusammenfassen, wann immer deine Anwendung es entscheidet, und fahre dann mit der Zusammenfassung fort.
featureMetadata:
  status: beta
  betaHeader: compact-2026-09-04
  supportedModels:
    - 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-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-sonnet-4-6
    - claude-haiku-5-5
  supportedPlatforms:
    Claude API: beta
    Claude Platform on AWS: beta
    Google Cloud: beta
    Microsoft Foundry: beta
---

Mit „on-demand compaction“ (Komprimierung auf Anfrage) entscheidet deine Anwendung, wann eine Unterhaltung zusammengefasst wird: Du sendest eine Anfrage mit dem Parameter `compaction`, und Claude gibt anstelle einer Antwort eine Zusammenfassung zurück.

## So funktioniert die Komprimierung auf Anfrage

Eine Komprimierungsanfrage ist von den Turns deiner Unterhaltung getrennt. Du sendest die Unterhaltung in ihrem aktuellen Stand mit dem Parameter `compaction`, und die Antwort enthält einen einzelnen `compaction`-Block. Der Block enthält die Zusammenfassung als lesbaren Text sowie eine Signatur. Sende ihn in zukünftigen Anfragen genau so, wie er zurückgekommen ist.

Von da an tritt der Block an die Stelle der Nachrichten, die er zusammenfasst. Er steht an erster Stelle in `messages`, die zusammengefassten Nachrichten werden entfernt, und dein nächster Turn folgt auf ihn. Claude sieht die Zusammenfassung dort, wo diese Nachrichten standen.

<Frame>
  ![„On-demand compaction“ (Komprimierung auf Anfrage): Eine Anfrage, die vier Nachrichten und den Parameter compaction enthält, gibt einen compaction-Block und keine Antwort zurück; bei der nächsten Anfrage steht der Block anstelle dieser vier Nachrichten an erster Stelle in messages, gefolgt vom nächsten user-Turn](https://platform.claude.com/docs/de/images/compaction-on-demand-swap.svg)
</Frame>

## Eine Zusammenfassung anfordern

Sende den Beta-Header `compact-2026-09-04` bei der Anfrage, die die Zusammenfassung anfordert, und bei jeder späteren Anfrage, die den signierten Block enthält. Um zu prüfen, ob ein Modell die Komprimierung auf Anfrage unterstützt, rufe die [Models API](https://platform.claude.com/docs/de/api/beta/models/list) mit dem Beta-Header auf und lies `capabilities.compaction` für jedes Modell aus. Du kannst `compaction` nicht mit `context_management` in einer Anfrage kombinieren.

Sende die Unterhaltung in ihrem aktuellen Stand mit `"compaction": {"type": "summarize"}`. Die API fasst jede Nachricht in der Anfrage einmal zusammen, generiert danach keine Antwort und gibt nur den Block mit `stop_reason` `"compaction"` zurück. Sende denselben `system`-Prompt und dieselben `tools`, die du für den Rest der Unterhaltung verwendest. Der Zusammenfasser liest sie, und wenn du Turns nach dem Block auf einem Modell mit [„preserved thinking“ (beibehaltenem Nachdenken)](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking) behältst, bleibt das Nachdenken in diesen Turns nur gültig, wenn `system` und `tools` übereinstimmen. Die Unterhaltung in diesem Beispiel hat weder einen `system`-Prompt noch Tools, daher sendet die Anfrage keines von beiden:

<CodeGroup>
  ```bash cURL
  # max_tokens begrenzt den gesamten Aufruf inkl. Nachdenken, also plane mehrere tausend Token ein.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: compact-2026-09-04" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [
        {"role": "user", "content": "I am building a recipe app. Help me name the main entities in the data model."},
        {"role": "assistant", "content": "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."},
        {"role": "user", "content": "Good. Now suggest field names for Recipe."}
      ],
      "compaction": {"type": "summarize"}
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta compact-2026-09-04 <<'YAML'
  model: claude-opus-5-5
  # max_tokens begrenzt den gesamten Aufruf inkl. Nachdenken, also plane mehrere tausend Token ein.
  max_tokens: 4096
  messages:
    - role: user
      content: I am building a recipe app. Help me name the main entities in the data model.
    - role: assistant
      content: Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.
    - role: user
      content: Good. Now suggest field names for Recipe.
  compaction:
    type: summarize
  YAML
  ```

  ```python Python
  from anthropic.types.beta import BetaMessageParam

  client = anthropic.Anthropic()

  history: list[BetaMessageParam] = [
      {
          "role": "user",
          "content": "I am building a recipe app. Help me name the main entities in the data model.",
      },
      {
          "role": "assistant",
          "content": "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.",
      },
      {"role": "user", "content": "Good. Now suggest field names for Recipe."},
  ]

  response = client.beta.messages.create(
      model="claude-opus-5-5",
      # max_tokens begrenzt den gesamten Aufruf inkl. Nachdenken, also plane mehrere tausend Token ein.
      max_tokens=4096,
      betas=["compact-2026-09-04"],
      messages=history,
      compaction={"type": "summarize"},
  )
  print(f"Stop reason: {response.stop_reason}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const history: Anthropic.Beta.Messages.BetaMessageParam[] = [
    {
      role: "user",
      content: "I am building a recipe app. Help me name the main entities in the data model."
    },
    {
      role: "assistant",
      content:
        "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
    },
    { role: "user", content: "Good. Now suggest field names for Recipe." }
  ];

  const response = await client.beta.messages.create({
    model: "claude-opus-5-5",
    // max_tokens begrenzt den gesamten Aufruf inkl. Thinking, also plane mehrere tausend Token ein.
    max_tokens: 4096,
    betas: ["compact-2026-09-04"],
    messages: history,
    compaction: { type: "summarize" }
  });
  console.log(`Stop reason: ${response.stop_reason}`);
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  List<BetaMessageParam> history =
  [
      new()
      {
          Role = Role.User,
          Content = "I am building a recipe app. Help me name the main entities in the data model.",
      },
      new()
      {
          Role = Role.Assistant,
          Content = "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.",
      },
      new() { Role = Role.User, Content = "Good. Now suggest field names for Recipe." },
  ];

  var response = await client.Beta.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      // max_tokens begrenzt den gesamten Aufruf inklusive Nachdenken, also plane mehrere tausend Token ein.
      MaxTokens = 4096,
      Betas = [AnthropicBeta.Compact2026_09_04],
      Messages = history,
      Compaction = new BetaCompactionConfig(), // type defaults to "summarize"
  });

  Console.WriteLine($"Stop reason: {response.StopReason?.Raw()}");
  ```

  ```go Go
  client := anthropic.NewClient()

  history := []anthropic.BetaMessageParam{
  	anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("I am building a recipe app. Help me name the main entities in the data model.")),
  	{
  		Role:    anthropic.BetaMessageParamRoleAssistant,
  		Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.")},
  	},
  	anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Good. Now suggest field names for Recipe.")),
  }

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model: anthropic.ModelClaudeOpus5_5,
  	// max_tokens begrenzt den gesamten Aufruf inkl. Nachdenken, also plane mehrere tausend Token ein.
  	MaxTokens: 4096,
  	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaCompact2026_09_04},
  	Messages:  history,
  	Compaction: anthropic.BetaCompactionConfigUnionParam{
  		OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println("Stop reason:", response.StopReason)
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaCompactionConfig;
  import com.anthropic.models.beta.messages.MessageCreateParams;

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

      var params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          // max_tokens begrenzt den gesamten Aufruf inkl. Thinking, also plane mehrere tausend Token ein.
          .maxTokens(4096)
          .addBeta(AnthropicBeta.COMPACT_2026_09_04)
          .addUserMessage("I am building a recipe app. Help me name the main entities in the data model.")
          .addAssistantMessage("Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.")
          .addUserMessage("Good. Now suggest field names for Recipe.")
          .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize"
          .build();

      var response = client.beta().messages().create(params);
      response.stopReason().ifPresent(reason -> IO.println("Stop reason: " + reason));
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaCompactionConfig;
  use Anthropic\Beta\Messages\BetaMessageParam;
  use Anthropic\Beta\Messages\BetaMessageParam\Role;

  $client = new Client();

  $history = [
      BetaMessageParam::with(
          role: Role::USER,
          content: 'I am building a recipe app. Help me name the main entities in the data model.',
      ),
      BetaMessageParam::with(
          role: Role::ASSISTANT,
          content: 'Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.',
      ),
      BetaMessageParam::with(role: Role::USER, content: 'Good. Now suggest field names for Recipe.'),
  ];

  $response = $client->beta->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      // max_tokens begrenzt den gesamten Aufruf inkl. Thinking, also plane mehrere tausend Token ein.
      maxTokens: 4096,
      betas: [AnthropicBeta::COMPACT_2026_09_04],
      messages: $history,
      compaction: BetaCompactionConfig::with(), // type defaults to 'summarize'
  );

  echo "Stop reason: {$response->stopReason}", PHP_EOL;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  history = [
    {
      role: "user",
      content: "I am building a recipe app. Help me name the main entities in the data model."
    },
    {
      role: "assistant",
      content: "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
    },
    { role: "user", content: "Good. Now suggest field names for Recipe." }
  ]

  response = client.beta.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    # max_tokens begrenzt den gesamten Aufruf inkl. Nachdenken, also plane mehrere tausend Token ein.
    max_tokens: 4096,
    betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
    messages: history,
    compaction: { type: "summarize" }
  )
  puts "Stop reason: #{response.stop_reason}"
  ```
</CodeGroup>

```json Response
{
  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "compaction",
      "content": "Summary of the conversation: the user is designing the data model for a recipe app. The entities agreed so far are Recipe, Ingredient, Step, and RecipeIngredient, which holds the quantity and unit. The user then asked for field names for Recipe.",
      "signature": "EuYBCkQY..."
    }
  ],
  "stop_reason": "compaction",
  "usage": {
    "input_tokens": 0,
    "output_tokens": 0,
    "iterations": [{ "type": "compaction", "input_tokens": 144, "output_tokens": 276 }]
  }
}
```

Der Zusammenfassungsaufruf verwendet das Modell, `system`, `tools`, die Thinking-Einstellungen und `max_tokens` der Anfrage. Der Zusammenfasser liest die Tool-Definitionen, führt aber nie ein Tool aus, und die Antwort enthält kein Thinking. `max_tokens` begrenzt den gesamten Aufruf, einschließlich des Nachdenkens, das das Modell vor dem Schreiben der Zusammenfassung ausführt, also plane mehrere tausend Token ein. [Komprimierungsnutzung zählen](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#understanding-usage) zeigt, wie der Aufruf abgerechnet wird.

Wenn der letzte `assistant`-Turn mit einem Tool-Aufruf endet, für den noch kein Ergebnis vorliegt, lehnt die API die Anfrage ab. Sende zuerst die Tool-Ergebnisse dieses Turns. Lass außerdem `stop_sequences`, das Structured-Output-Feld `output_config.format` und eine `tool_choice` vom Typ `any` oder `tool` weg. Sie hätten bei einem Zusammenfassungsaufruf keine Wirkung, und die API lehnt sie ab. Die Unterhaltung muss weiterhin in das „context window“ (Kontextfenster) des Modells passen, also komprimiere, bevor du es überschreitest, nicht danach.

Wenn du die Antwort per Streaming empfängst, kommt der Block vollständig an. Du erhältst ein `content_block_start`-Event mit dem vollständigen Block, dann `content_block_stop`, ohne `content_block_delta`-Events. `ping`-Events können davor oder dazwischen eintreffen.

## Ab der Zusammenfassung fortfahren

Ersetze in deinem Verlauf die gesendeten Nachrichten durch die zurückgegebene Assistant-Nachricht. Behalte den `compaction`-Block genau so bei, wie die API ihn zurückgegeben hat, einschließlich seiner `signature`. Alle Turns, die nach dem Senden der Komprimierungsanfrage stattgefunden haben, folgen unverändert auf den Block – darauf baut [Komprimierung im Hintergrund](https://platform.claude.com/docs/de/build-with-claude/compaction-background) auf. Sende den Block bei jeder späteren Anfrage an erster Stelle, zusammen mit dem Beta-Header:

```json
{
  "model": "claude-opus-5-5",
  "max_tokens": 2048,
  "messages": [
    {
      "role": "assistant",
      "content": [
        {
          "type": "compaction",
          "content": "Summary of the conversation: the user is designing the data model for a recipe app. The entities agreed so far are Recipe, Ingredient, Step, and RecipeIngredient, which holds the quantity and unit. The user then asked for field names for Recipe.",
          "signature": "EuYBCkQY..."
        }
      ]
    },
    {
      "role": "assistant",
      "content": "For Recipe, use title, description, servings, prep_minutes, and cook_minutes. Add created_at and updated_at timestamps."
    },
    { "role": "user", "content": "Now do the same for Ingredient." }
  ]
}
```

Dieses Beispiel setzt das Anfragebeispiel fort, das mit einem `user`-Turn endete; das Diagramm zeigt den einfacheren Fall, in dem während des Schreibens der Zusammenfassung kein Turn stattfindet. Hier ist die zweite `assistant`-Nachricht die Antwort auf den letzten zusammengefassten `user`-Turn. Sie kam an, während die Zusammenfassung geschrieben wurde, und gehörte daher nicht zu den zusammengefassten Nachrichten. Zwei aufeinanderfolgende `assistant`-Nachrichten sind hier in Ordnung, weil der Block weiterhin an erster Stelle steht.

Die API setzt die Zusammenfassung dort ein, wo der Block steht, und gibt jede spätere Nachricht unverändert an Claude weiter. Befolge diese Regeln:

* Setze den Block an die erste Stelle in `messages`, entweder als eigene `assistant`-Nachricht oder als ersten Content-Block der ersten Nachricht, unabhängig davon, ob es sich um eine `user`- oder `assistant`-Nachricht handelt.
* Entferne die zusammengefassten Nachrichten. Wenn noch welche vor dem Block stehen, gibt die Anfrage einen 400-Fehler zurück (`compaction_block_misplaced`).
* Sende genau einen `compaction`-Block pro Anfrage, und zwar bei jeder späteren Anfrage.

<Warning>
  Zwei Fehler beim Austausch lösen keine Fehlermeldung aus. Wenn zusammengefasste Nachrichten nach dem Block verbleiben, sendet die API sie erneut an Claude. Wenn eine spätere Anfrage den Block weglässt, erhält Claude keine Zusammenfassung.
</Warning>

Die Schwellenwert-Komprimierung funktioniert umgekehrt: Ihr Block folgt auf die Nachrichten, die er zusammenfasst, und die API entfernt diese für dich. Siehe [Komprimierungsblöcke zurückgeben](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold#passing-compaction-blocks-back).

Verwende in Python `client.beta.messages`, wie es die Beispiele auf dieser Seite tun. Wenn du `client.messages` aufrufst und Blöcke selbst serialisierst, verwende `to_dict()` oder `model_dump(exclude_none=True)`: Ein einfaches `model_dump()` fügt dem Block `citations: null` und `text: null` hinzu, und die API lehnt ihn ab.

Wenn du Turns nach dem Block behältst und deren Thinking-Blöcke zurücksendest, findest du die Bedingungen, unter denen dieses Nachdenken gültig bleibt, unter [Komprimierung und beibehaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/compaction-thinking-blocks).

### Erneut komprimieren

Um eine Unterhaltung zu komprimieren, die bereits mit einem Block beginnt, sende erneut `compaction`. Der neue Block fasst die alte Zusammenfassung und alles danach zusammen. Sende von da an nur noch den neuesten Block.

## In einer Schleife komprimieren

Nach jedem Turn addiert die Schleife die Eingabe- und Ausgabe-Token der letzten Antwort, weil die nächste Anfrage auch die Antwort mitsendet. Wenn diese Summe ein Limit überschreitet und noch ein weiterer Turn folgt, sendet sie eine Komprimierungsanfrage mit demselben Modell und demselben `system`-Prompt, prüft `stop_reason`, ersetzt ihren Verlauf durch die zurückgegebene Nachricht und gibt aus, vor welchem Turn sie komprimiert hat. Das Limit von 2.500 Token im Beispiel ist absichtlich niedrig, damit auch eine kurze Unterhaltung komprimiert wird. Setze deines nahe an dein tatsächliches Eingabebudget.

<CodeGroup exclude="shell">
  ```python Python
  from anthropic.types.beta import BetaMessageParam

  client = anthropic.Anthropic()

  # Setze dies nahe an dein tatsächliches Input-Budget. Hier ist es niedrig, damit schon ein kurzes Gespräch kompaktiert wird.
  COMPACT_AT_TOKENS = 2500
  SYSTEM = "You help design a recipe app's data model. Keep answers short."

  QUESTIONS = [
      "What are the main entities in the data model?",
      "Which fields should Recipe have?",
      "Which fields should Ingredient have?",
      "Which fields should RecipeIngredient have?",
      "Which fields should Step have?",
      "Which indexes should these tables have?",
      "Which fields should be required?",
      "Which fields should have default values?",
  ]

  history: list[BetaMessageParam] = []
  for turn, question in enumerate(QUESTIONS, start=1):
      history.append({"role": "user", "content": question})
      response = client.beta.messages.create(
          model="claude-opus-5-5",
          max_tokens=8192,
          system=SYSTEM,
          betas=["compact-2026-09-04"],
          messages=history,
      )
      history.append({"role": "assistant", "content": response.content})

      # Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
      conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
      if conversation_tokens > COMPACT_AT_TOKENS and turn < len(QUESTIONS):
          summary = client.beta.messages.create(
              model="claude-opus-5-5",
              max_tokens=4096,
              system=SYSTEM,
              betas=["compact-2026-09-04"],
              messages=history,
              compaction={"type": "summarize"},
          )
          if summary.stop_reason == "compaction":
              history = [{"role": "assistant", "content": summary.content}]
              print(f"Compacted before turn {turn + 1}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  // Setze dies nahe an dein echtes Input-Budget. Hier ist es niedrig, damit ein kurzes Gespräch kompaktiert wird.
  const compactAtTokens = 2500;
  const systemPrompt = "You help design a recipe app's data model. Keep answers short.";

  const questions = [
    "What are the main entities in the data model?",
    "Which fields should Recipe have?",
    "Which fields should Ingredient have?",
    "Which fields should RecipeIngredient have?",
    "Which fields should Step have?",
    "Which indexes should these tables have?",
    "Which fields should be required?",
    "Which fields should have default values?"
  ];

  let history: Anthropic.Beta.Messages.BetaMessageParam[] = [];
  for (const [index, question] of questions.entries()) {
    const turn = index + 1;
    history.push({ role: "user", content: question });
    const response = await client.beta.messages.create({
      model: "claude-opus-5-5",
      max_tokens: 8192,
      system: systemPrompt,
      betas: ["compact-2026-09-04"],
      messages: history
    });
    history.push({ role: "assistant", content: response.content });

    // Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
    const conversationTokens = response.usage.input_tokens + response.usage.output_tokens;
    if (conversationTokens > compactAtTokens && turn < questions.length) {
      const summary = await client.beta.messages.create({
        model: "claude-opus-5-5",
        max_tokens: 4096,
        system: systemPrompt,
        betas: ["compact-2026-09-04"],
        messages: history,
        compaction: { type: "summarize" }
      });
      if (summary.stop_reason === "compaction") {
        history = [{ role: "assistant", content: summary.content }];
        console.log(`Compacted before turn ${turn + 1}`);
      }
    }
  }
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  // Setze diesen Wert nahe an dein tatsächliches Input-Budget. Hier ist er niedrig, damit schon ein kurzes Gespräch kompaktiert wird.
  const int CompactAtTokens = 2500;
  const string SystemPrompt = "You help design a recipe app's data model. Keep answers short.";

  string[] questions =
  [
      "What are the main entities in the data model?",
      "Which fields should Recipe have?",
      "Which fields should Ingredient have?",
      "Which fields should RecipeIngredient have?",
      "Which fields should Step have?",
      "Which indexes should these tables have?",
      "Which fields should be required?",
      "Which fields should have default values?",
  ];

  List<BetaMessageParam> history = [];
  foreach (var (index, question) in questions.Index())
  {
      var turn = index + 1;
      history.Add(new() { Role = Role.User, Content = question });
      var response = await client.Beta.Messages.Create(new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 8192,
          System = SystemPrompt,
          Betas = [AnthropicBeta.Compact2026_09_04],
          Messages = history,
      });
      history.Add(new()
      {
          Role = Role.Assistant,
          Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
      });

      // Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
      var conversationTokens = response.Usage.InputTokens + response.Usage.OutputTokens;
      if (conversationTokens > CompactAtTokens && turn < questions.Length)
      {
          var summary = await client.Beta.Messages.Create(new MessageCreateParams
          {
              Model = Model.ClaudeOpus5_5,
              MaxTokens = 4096,
              System = SystemPrompt,
              Betas = [AnthropicBeta.Compact2026_09_04],
              Messages = history,
              Compaction = new BetaCompactionConfig(), // type defaults to "summarize"
          });
          if (summary.StopReason == BetaStopReason.Compaction)
          {
              history =
              [
                  new()
                  {
                      Role = Role.Assistant,
                      Content = summary.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
                  },
              ];
              Console.WriteLine($"Compacted before turn {turn + 1}");
          }
      }
  }
  ```

  ```go Go
  ctx := context.Background()
  client := anthropic.NewClient()

  // Setze dies nahe an dein echtes Input-Budget. Hier ist es niedrig, damit ein kurzes Gespräch kompaktiert wird.
  const compactAtTokens = 2500
  system := []anthropic.BetaTextBlockParam{{Text: "You help design a recipe app's data model. Keep answers short."}}

  questions := []string{
  	"What are the main entities in the data model?",
  	"Which fields should Recipe have?",
  	"Which fields should Ingredient have?",
  	"Which fields should RecipeIngredient have?",
  	"Which fields should Step have?",
  	"Which indexes should these tables have?",
  	"Which fields should be required?",
  	"Which fields should have default values?",
  }

  var history []anthropic.BetaMessageParam
  for i, question := range questions {
  	turn := i + 1
  	history = append(history, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(question)))
  	response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 8192,
  		System:    system,
  		Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaCompact2026_09_04},
  		Messages:  history,
  	})
  	if err != nil {
  		log.Fatal(err)
  	}
  	history = append(history, response.ToParam())

  	// Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
  	conversationTokens := response.Usage.InputTokens + response.Usage.OutputTokens
  	if conversationTokens > compactAtTokens && turn < len(questions) {
  		summary, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
  			Model:     anthropic.ModelClaudeOpus5_5,
  			MaxTokens: 4096,
  			System:    system,
  			Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaCompact2026_09_04},
  			Messages:  history,
  			Compaction: anthropic.BetaCompactionConfigUnionParam{
  				OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
  			},
  		})
  		if err != nil {
  			log.Fatal(err)
  		}
  		if summary.StopReason == anthropic.BetaStopReasonCompaction {
  			history = []anthropic.BetaMessageParam{summary.ToParam()}
  			fmt.Printf("Compacted before turn %d\n", turn+1)
  		}
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaCompactionConfig;
  import com.anthropic.models.beta.messages.BetaMessageParam;
  import com.anthropic.models.beta.messages.BetaStopReason;
  import com.anthropic.models.beta.messages.MessageCreateParams;

  // Setze dies nahe an dein echtes Input-Budget. Hier ist es niedrig, damit ein kurzes Gespräch kompaktiert wird.
  static final long COMPACT_AT_TOKENS = 2500;
  static final String SYSTEM = "You help design a recipe app's data model. Keep answers short.";

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

      var questions = List.of(
          "What are the main entities in the data model?",
          "Which fields should Recipe have?",
          "Which fields should Ingredient have?",
          "Which fields should RecipeIngredient have?",
          "Which fields should Step have?",
          "Which indexes should these tables have?",
          "Which fields should be required?",
          "Which fields should have default values?"
      );

      var history = new ArrayList<BetaMessageParam>();
      for (int turn = 1; turn <= questions.size(); turn++) {
          history.add(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.USER)
              .content(questions.get(turn - 1))
              .build());
          var params = MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(8192)
              .system(SYSTEM)
              .addBeta(AnthropicBeta.COMPACT_2026_09_04)
              .messages(history)
              .build();
          var response = client.beta().messages().create(params);
          history.add(response.toParam());

          // Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
          long conversationTokens = response.usage().inputTokens() + response.usage().outputTokens();
          if (conversationTokens > COMPACT_AT_TOKENS && turn < questions.size()) {
              var summaryParams = MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_5_5)
                  .maxTokens(4096)
                  .system(SYSTEM)
                  .addBeta(AnthropicBeta.COMPACT_2026_09_04)
                  .messages(history)
                  .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize"
                  .build();
              var summary = client.beta().messages().create(summaryParams);
              if (summary.stopReason().map(BetaStopReason.COMPACTION::equals).orElse(false)) {
                  history.clear();
                  history.add(summary.toParam());
                  IO.println("Compacted before turn " + (turn + 1));
              }
          }
      }
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaCompactionConfig;
  use Anthropic\Beta\Messages\BetaMessageParam;
  use Anthropic\Beta\Messages\BetaMessageParam\Role;
  use Anthropic\Beta\Messages\BetaStopReason;

  $client = new Client();

  // Setze diesen Wert nahe an dein echtes Input-Budget. Hier ist er niedrig, damit schon ein kurzes Gespräch kompaktiert wird.
  const COMPACT_AT_TOKENS = 2500;
  const SYSTEM = "You help design a recipe app's data model. Keep answers short.";

  $questions = [
      'What are the main entities in the data model?',
      'Which fields should Recipe have?',
      'Which fields should Ingredient have?',
      'Which fields should RecipeIngredient have?',
      'Which fields should Step have?',
      'Which indexes should these tables have?',
      'Which fields should be required?',
      'Which fields should have default values?',
  ];

  $history = [];
  foreach ($questions as $index => $question) {
      $turn = $index + 1;
      $history[] = BetaMessageParam::with(role: Role::USER, content: $question);
      $response = $client->beta->messages->create(
          model: Model::CLAUDE_OPUS_5_5,
          maxTokens: 8192,
          system: SYSTEM,
          betas: [AnthropicBeta::COMPACT_2026_09_04],
          messages: $history,
      );
      $history[] = BetaMessageParam::with(role: Role::ASSISTANT, content: $response->content);

      // Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
      $conversationTokens = $response->usage->inputTokens + $response->usage->outputTokens;
      if ($conversationTokens > COMPACT_AT_TOKENS && $turn < count($questions)) {
          $summary = $client->beta->messages->create(
              model: Model::CLAUDE_OPUS_5_5,
              maxTokens: 4096,
              system: SYSTEM,
              betas: [AnthropicBeta::COMPACT_2026_09_04],
              messages: $history,
              compaction: new BetaCompactionConfig(), // type defaults to 'summarize'
          );
          if ($summary->stopReason === BetaStopReason::COMPACTION->value) {
              $history = [BetaMessageParam::with(role: Role::ASSISTANT, content: $summary->content)];
              printf("Compacted before turn %d\n", $turn + 1);
          }
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Setze diesen Wert nahe an dein echtes Input-Budget. Hier ist er niedrig, damit schon ein kurzes Gespräch kompaktiert wird.
  COMPACT_AT_TOKENS = 2500
  SYSTEM = "You help design a recipe app's data model. Keep answers short."

  questions = [
    "What are the main entities in the data model?",
    "Which fields should Recipe have?",
    "Which fields should Ingredient have?",
    "Which fields should RecipeIngredient have?",
    "Which fields should Step have?",
    "Which indexes should these tables have?",
    "Which fields should be required?",
    "Which fields should have default values?"
  ]

  history = []
  questions.each.with_index(1) do |question, turn|
    history << { role: "user", content: question }
    response = client.beta.messages.create(
      model: Anthropic::Model::CLAUDE_OPUS_5_5,
      max_tokens: 8192,
      system_: SYSTEM,
      betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
      messages: history
    )
    history << { role: "assistant", content: response.content }

    # Die nächste Anfrage sendet diese Antwort mit, also zähle sie mit.
    conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
    if conversation_tokens > COMPACT_AT_TOKENS && turn < questions.length
      summary = client.beta.messages.create(
        model: Anthropic::Model::CLAUDE_OPUS_5_5,
        max_tokens: 4096,
        system_: SYSTEM,
        betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
        messages: history,
        compaction: { type: "summarize" }
      )
      if summary.stop_reason == :compaction
        history = [{ role: "assistant", content: summary.content }]
        puts "Compacted before turn #{turn + 1}"
      end
    end
  end
  ```
</CodeGroup>

Die Prüfung von `stop_reason` erfolgt, bevor der Code nach dem Block sucht; [Fehlende Zusammenfassung oder Fehler behandeln](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#when-no-summary-comes-back) erklärt, warum. Der Verlauf wird ersetzt, nicht ergänzt: Die zurückgegebene Nachricht ersetzt jede Nachricht, die die Anfrage enthielt, gemäß den Regeln unter [Ab der Zusammenfassung fortfahren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#continue-from-the-summary). Wenn keine Zusammenfassung zurückkommt, behält die Schleife ihren Verlauf und fragt nach dem nächsten Turn erneut an.

Der [„tool runner“ (Tool-Runner)](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-runner) des SDK in Python, TypeScript, C#, Go, Java, PHP und Ruby kann die Komprimierungsanfrage für dich senden. Wenn du dich zum Komprimieren entscheidest, rufe `compact_before_next_turn()` (typescript, java, php: `compactBeforeNextTurn()`; csharp, go: `CompactBeforeNextTurn()`) auf dem Runner auf. Sobald der aktuelle Turn und seine Tool-Aufrufe abgeschlossen sind, sendet der Runner die Komprimierungsanfrage und ersetzt seinen Verlauf durch die zurückgegebene Nachricht. Erstelle den Runner mit der Beta `compact-2026-09-04`, da der Runner sie nicht selbst hinzufügt.

Der Runner erstellt die Komprimierungsanfrage aus seinen eigenen Parametern und lässt `context_management` weg. Er lässt außerdem `stop_sequences`, eine `tool_choice` vom Typ `any` oder `tool` und ein Structured-Output-Feld `output_config.format` weg, die die API bei einer Komprimierungsanfrage ablehnt. [Eine Zusammenfassung anfordern](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#request-a-summary) erklärt, warum. Der Runner sendet sie bei seinen späteren Anfragen wieder mit. SDK-Versionen vor Python 1.8.0, TypeScript 0.128.0, C# 12.50.0, Go 1.75.0 und Java 2.65.0 senden sie auch bei der Komprimierungsanfrage. Bei diesen Versionen erhält ein Runner, der einen dieser Parameter setzt, einen 400-Fehler. Der Runner sendet ein [„task budget“ (Task-Budget)](https://platform.claude.com/docs/de/build-with-claude/task-budgets) unverändert. Wenn `output_config.task_budget` einen `remaining`-Wert setzt, gibt die Komprimierungsanfrage einen 400-Fehler zurück, also lass `remaining` ungesetzt, wie unter [Einschränkungen und Wechselwirkungen mit anderen Funktionen](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#how-it-fits-with-the-rest-of-the-api) beschrieben. Der Runner verweigert die Komprimierung, solange sein `context_management` eine Komprimierungsbearbeitung enthält, also verwende auf einem Runner nur eine Art der Komprimierung.

### Wann komprimiert werden sollte

Du kannst nach jedem abgeschlossenen Turn eine Komprimierungsanfrage senden, also entscheidet dein Code, wann.

Um abzuschätzen, wie groß die nächste Anfrage sein wird, addiere `input_tokens` und `output_tokens` aus der `usage` der letzten Antwort, wie es die Schleife tut. Mit [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#tracking-cache-performance) zählt `input_tokens` nur die Token nach dem letzten Cache-Breakpoint, addiere also zusätzlich `cache_read_input_tokens` und `cache_creation_input_tokens`. Du kannst dieselben Nachrichten auch an den Endpunkt für [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting) senden.

Vergleiche diese Zahl mit einem von dir gewählten Limit unterhalb des [Kontextfensters](https://platform.claude.com/docs/de/build-with-claude/context-windows) des Modells.

## Eigenen Zusammenfassungs-Prompt schreiben

Ohne `instructions` verwendet die API ihren eigenen Zusammenfassungs-Prompt. Ein nicht leerer `instructions`-String (bis zu 16.384 Zeichen) ersetzt diesen Prompt vollständig. Zum Beispiel:

```json
{
  "compaction": {
    "type": "summarize",
    "instructions": "Summarize this recipe app design conversation. Preserve every entity and field name agreed so far, and the user's latest open request. Do not call tools; respond with the summary text only."
  }
}
```

Der Zusammenfasser liest die gesamte Unterhaltung, einschließlich früheren Nachdenkens, mit oder ohne `instructions`. Gib in deinen `instructions` an, was die Zusammenfassung beibehalten muss, und weise das Modell an, keine Tools aufzurufen. Der Zusammenfassungsaufruf unterliegt denselben Schutzmaßnahmen wie jede andere Anfrage.

## Fehlende Zusammenfassung oder Fehler behandeln

Eine Zusammenfassung wird nur erzeugt, wenn der Zusammenfassungsaufruf normal mit Text und ohne Tool-Aufruf endet. Andernfalls ist die Antwort trotzdem ein 200 mit leerem `content`, prüfe also `stop_reason`, bevor du nach dem Block suchst. Der Aufruf wird trotzdem abgerechnet und in `usage.iterations` ausgewiesen, mit einer Nutzung von null, wenn kein Aufruf erfolgen konnte. Der `stop_reason` ist derjenige, mit dem der Zusammenfassungsaufruf geendet hat. In jedem Fall kannst du ohne Zusammenfassung fortfahren und später komprimieren.

| `stop_reason`                     | Ursache                                                                       | Was zu tun ist                                                                    |
| --------------------------------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| `"max_tokens"`                    | Die Zusammenfassung wurde abgeschnitten.                                      | Sende erneut mit einem größeren `max_tokens`.                                     |
| `"model_context_window_exceeded"` | Es war kein Platz für den Zusammenfassungs-Prompt.                            | Sende erneut mit kürzeren `instructions` oder weniger Nachrichten.                |
| `"tool_use"`                      | Das Modell hat ein Tool aufgerufen, anstatt die Zusammenfassung zu schreiben. | Sende erneut mit `instructions`, die das Modell anweisen, keine Tools aufzurufen. |
| `"refusal"`                       | Die Anfrage wurde abgelehnt.                                                  | Fahre ohne Zusammenfassung fort.                                                  |
| `"end_turn"`                      | Der Aufruf hat keinen Text zurückgegeben.                                     | Fahre ohne Zusammenfassung fort.                                                  |

Der Zusammenfassungsaufruf unterliegt denselben Schutzmaßnahmen wie deine anderen Anfragen. Nach einem `"refusal"` gibt [`stop_details`](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons#refusal) die zugrunde liegende Richtlinienkategorie an.

### Fehler

Eine Komprimierungsanfrage oder eine Anfrage, die einen Block enthält, kann auch vollständig fehlschlagen. Die meisten 400-Fehler haben eine Meldung, die angibt, was entfernt oder erneut gesendet werden muss. Einige enthalten zusätzlich einen `error.details.error_code`, der mit `compaction_` beginnt. Parameterfehler, etwa ein Feld, das nicht mit `compaction` kombiniert werden kann, enthalten nur die Meldung.

| Fehler                                                                                                                                                                                           | Ursache                                                                                                             | Was zu tun ist                                                                                                                                                                                            |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 529 `overloaded_error`, `error.details.error_code` `compaction_unavailable`                                                                                                                      | Ein vorübergehendes Serverproblem beim Erzeugen eines Blocks oder beim Lesen eines von dir zurückgesendeten Blocks. | Wiederhole die Anfrage.                                                                                                                                                                                   |
| 400 `compaction_block_misplaced`                                                                                                                                                                 | Zusammengefasste Nachrichten stehen noch vor dem Block.                                                             | Entferne sie, damit der Block an erster Stelle in `messages` steht.                                                                                                                                       |
| 400 `compaction_signature_invalid` oder `compaction_content_mismatch`                                                                                                                            | Die `signature` oder der `content` des Blocks wurde geändert, nachdem die API ihn zurückgegeben hat.                | Sende den Block genau so, wie er zurückgegeben wurde, einschließlich seiner `signature`.                                                                                                                  |
| 400                                                                                                                                                                                              | Die Anfrage enthält mehr als einen `compaction`-Block.                                                              | Sende genau einen, den neuesten.                                                                                                                                                                          |
| 400                                                                                                                                                                                              | Der letzte `assistant`-Turn endet mit einem Tool-Aufruf, für den noch kein Ergebnis vorliegt.                       | Sende die Tool-Ergebnisse dieses Turns und komprimiere dann.                                                                                                                                              |
| 400 `compaction_nothing_to_summarize`                                                                                                                                                            | `messages` enthält keinen `user`- oder `assistant`-Inhalt, zum Beispiel eine leere Liste.                           | Sende mindestens eine `user`- oder `assistant`-Nachricht.                                                                                                                                                 |
| 400 bei der Komprimierungsanfrage, mit einer Meldung, dass der Parameter `compaction` `requires anthropic-beta: compact-2026-09-04`                                                              | Bei der Komprimierungsanfrage fehlte der Beta-Header.                                                               | Füge den Beta-Header hinzu; siehe [Eine Zusammenfassung anfordern](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#request-a-summary).                                         |
| 400 bei einer späteren Anfrage, die den Block enthält: ein Validierungsfehler, der besagt, dass `compaction` keiner der erwarteten Content-Block-Typen ist. Die Meldung erwähnt den Header nicht | Bei dieser Anfrage fehlte der Beta-Header.                                                                          | Füge den Beta-Header zu jeder Anfrage hinzu, die den Block enthält; siehe [Eine Zusammenfassung anfordern](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#request-a-summary). |
| 400-Validierungsfehler, etwa `messages.0.content.0.compaction.citations: Extra inputs are not permitted`                                                                                         | Ein Block wurde mit Feldern zurückgesendet, die die API nicht zurückgegeben hat, etwa `citations: null`.            | Sende den Block genau so, wie er zurückgegeben wurde; siehe [Ab der Zusammenfassung fortfahren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#continue-from-the-summary).    |

## Komprimierungsnutzung zählen

Der Zusammenfassungsaufruf wird wie jede andere Anfrage abgerechnet und unterliegt denselben Ratenlimits, und `usage.iterations` weist ihn als `compaction`-Eintrag aus. Die `input_tokens` und `output_tokens` auf oberster Ebene sind null, weil keine Antwort generiert wurde. Um zu zählen, was eine Unterhaltung verbraucht hat, summiere über `usage.iterations`, nicht über die Felder auf oberster Ebene. Das Zurücksenden eines Blocks bei späteren Anfragen verursacht keine zusätzlichen Komprimierungskosten.

Du hast jetzt eine funktionierende Schleife, die eine Unterhaltung komprimiert und eine fehlende Zusammenfassung behandelt. Zwei Seiten verändern, wie sie abläuft, und du kannst sie kombinieren: [Komprimierung, die die letzten Turns beibehält](https://platform.claude.com/docs/de/build-with-claude/compaction-keep-recent-turns) behält die letzten Turns wortwörtlich bei, und [Komprimierung im Hintergrund](https://platform.claude.com/docs/de/build-with-claude/compaction-background) lässt die Unterhaltung weiterlaufen, während die Zusammenfassung geschrieben wird. [Komprimierung und beibehaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/compaction-thinking-blocks) ist relevant, wenn du Thinking-Blöcke zurücksendest und eines von beiden tust.

## Einschränkungen und Wechselwirkungen mit anderen Funktionen

* **Schwellenwert-Komprimierung und Kontextbearbeitung.** Du kannst `compaction` und `context_management` nicht in derselben Anfrage senden. Die Schwellenwert-Komprimierung (`compact_20260112`) kann nicht bei einer Anfrage ausgeführt werden, die einen signierten Block enthält.
* **Prompt-Caching.** `cache_control` auf dem Block setzt einen Breakpoint nach der Zusammenfassung.
* **System-Nachrichten und Tool-Änderungen mitten in der Unterhaltung.** `role: "system"`-Nachrichten innerhalb des zusammengefassten Bereichs werden ebenfalls zusammengefasst, sodass ihre Textanweisungen nicht mehr gelten, sobald der Block sie ersetzt. Ein von ihnen gesetztes [Effort-Level pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) wird ebenfalls nicht übernommen: Bis eine spätere Nachricht ein Level setzt, laufen Turns mit dem `output_config.effort` der obersten Ebene der Anfrage oder mit dem Standardwert des Modells, wenn du keines setzt. Wenn eine Anweisung oder ein Effort-Level weiterhin wichtig ist, gib sie erneut in einer `role: "system"`-Nachricht an. Sende diese Nachricht direkt nach deinem nächsten neuen `user`-Turn und behalte sie von da an in deinem Verlauf. Für [Tool-Änderungen](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#mid-conversation-tool-changes) und dafür, wo diese Nachricht hingehört, wenn du Turns nach dem Block behältst, siehe [System-Prompt oder Tools ändern](https://platform.claude.com/docs/de/build-with-claude/compaction-thinking-blocks#change-the-system-prompt-or-tools).
* **Task-Budgets.** Sende den `remaining`-Wert eines [Task-Budgets](https://platform.claude.com/docs/de/build-with-claude/task-budgets) (`output_config.task_budget.remaining`) nicht zusammen mit `compaction` oder bei Anfragen, die den Block enthalten. Andernfalls wird ein 400-Fehler zurückgegeben.
* **Token-Zählung.** Der Endpunkt für [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting) ignoriert den Parameter `compaction`.
* **Inhalte, die die Zusammenfassung nicht übernehmen kann.** Bilder, Dokumente, `container_upload`-Blöcke und abgerufene URLs innerhalb der zusammengefassten Nachrichten sind verloren, sobald der Block sie ersetzt. Formuliere alles, was ein späterer Turn noch benötigt, erneut oder lade es erneut hoch.