---
title: Komprimierung, die die letzten Turns beibehält
url: https://platform.claude.com/docs/de/build-with-claude/compaction-keep-recent-turns
description: Fasse die älteren Turns einer Unterhaltung mit On-Demand-Komprimierung zusammen und sende die letzten Turns wortwörtlich nach der Zusammenfassung.
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
---

„Keep-tail compaction“ (Komprimierung mit beibehaltenem Ende) behält die letzten paar „turns“ (Gesprächsrunden) einer Unterhaltung nach der Zusammenfassung wortwörtlich bei. Sie ändert zwei Dinge in der [Komprimierungsschleife](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#compact-in-a-loop): welche Nachrichten in die Komprimierungsanfrage eingehen und was du nach dem Block sendest. Alles in [Ab der Zusammenfassung fortfahren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#continue-from-the-summary) gilt unverändert.

## Auswählen, welche Turns beibehalten werden

Kein Parameter legt fest, welche Turns beibehalten werden. Du wählst einen Schnittpunkt in deinem Verlauf: Die Nachrichten davor gehen in die Komprimierungsanfrage ein, und die Nachrichten ab diesem Punkt werden beibehalten.

Beibehaltene Turns gehen in voller Länge an Claude zurück. Je mehr du also beibehältst, desto weniger Platz schafft die Komprimierung.

Setze den Schnitt dort, wo kein „tool call“ (Tool-Aufruf) offen bleibt, sodass jeder Tool-Aufruf und sein Ergebnis auf derselben Seite liegen. Wenn die Nachrichten, die du sendest, mit einem `assistant`-Turn enden, dessen Tool-Aufruf noch kein Ergebnis hat, lehnt die API die Komprimierungsanfrage ab.

## Die älteren Turns komprimieren und den Rest nach dem Block senden

Um die letzten Turns wortwörtlich beizubehalten, lass diese Turns aus der Komprimierungsanfrage heraus. Die API fasst jede Nachricht zusammen, die ihr gesendet wird. Sende also nur die älteren Turns und setze dann den Block vor die Turns, die du beibehalten hast.

Sende die beibehaltenen Turns genau so, wie sie in deinem Verlauf stehen, einschließlich der Thinking-Blöcke. Beide Anfragen enthalten den Beta-Header, wie in [Eine Zusammenfassung anfordern](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#request-a-summary).

Im folgenden Beispiel enthält der Verlauf zwei Turns, und der Schnitt behält den zweiten bei. Die Komprimierungsanfrage enthält den ersten Turn:

```json
{
  "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."
    }
  ],
  "compaction": { "type": "summarize" }
}
```

Die nächste Anfrage sendet zuerst den zurückgegebenen Block, dann den beibehaltenen Turn genau so, wie er war, und dann die neue `user`-Nachricht. [Ab der Zusammenfassung fortfahren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#continue-from-the-summary) zeigt eine Anfrage, die mit einem Block beginnt.

Das folgende Programm ist die Schleife aus [In einer Schleife komprimieren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#compact-in-a-loop), so geändert, dass die letzten zwei Turns beibehalten werden. Die hervorgehobenen Zeilen zeigen, wo es sich von der Schleife unterscheidet.

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

  client = anthropic.Anthropic()

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

  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 KEEP_TURNS < turn < len(QUESTIONS):
          # Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort,
          # daher beginnen die behaltenen Turns mit einer User-Nachricht.
          split = -2 * KEEP_TURNS
          older, recent = history[:split], history[split:]
          summary = client.beta.messages.create(
              model="claude-opus-5-5",
              max_tokens=4096,
              system=SYSTEM,
              betas=["compact-2026-09-04"],
              messages=older,
              compaction={"type": "summarize"},
          )
          if summary.stop_reason == "compaction":
              history = [{"role": "assistant", "content": summary.content}, *recent]
              print(f"Kept {len(recent) // 2} turns after the block")
  ```

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

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

  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 > keepTurns && turn < questions.length) {
      // Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort, daher beginnen die behaltenen Turns mit einer User-Nachricht.
      const older = history.slice(0, -2 * keepTurns);
      const recent = history.slice(-2 * keepTurns);
      const summary = await client.beta.messages.create({
        model: "claude-opus-5-5",
        max_tokens: 4096,
        system: systemPrompt,
        betas: ["compact-2026-09-04"],
        messages: older,
        compaction: { type: "summarize" }
      });
      if (summary.stop_reason === "compaction") {
        history = [{ role: "assistant", content: summary.content }, ...recent];
        console.log(`Kept ${recent.length / 2} turns after the block`);
      }
    }
  }
  ```

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

  AnthropicClient client = new();

  // Setze dies nahe an dein echtes Input-Budget. Hier ist es 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.";
  const int KeepTurns = 2;

  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 auch diese Antwort mit, also zähle sie mit.
      var conversationTokens = response.Usage.InputTokens + response.Usage.OutputTokens;
      if (conversationTokens > CompactAtTokens && turn > KeepTurns && turn < questions.Length)
      {
          // Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort, daher beginnen die behaltenen Turns mit einer User-Nachricht.
          var older = history[..^(2 * KeepTurns)];
          var recent = history[^(2 * KeepTurns)..];
          var summary = await client.Beta.Messages.Create(new MessageCreateParams
          {
              Model = Model.ClaudeOpus5_5,
              MaxTokens = 4096,
              System = SystemPrompt,
              Betas = [AnthropicBeta.Compact2026_09_04],
              Messages = older,
              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(),
                  },
                  .. recent,
              ];
              Console.WriteLine($"Kept {recent.Count / 2} turns after the block");
          }
      }
  }
  ```

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

  // Setze dies nahe an dein echtes Input-Budget. Hier ist es niedrig, damit schon 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."}}
  const keepTurns = 2

  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 > keepTurns && turn < len(questions) {
  		// Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort, daher beginnen die behaltenen Turns mit einer User-Nachricht.
  		split := len(history) - 2*keepTurns
  		older, recent := history[:split], history[split:]
  		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:  older,
  			Compaction: anthropic.BetaCompactionConfigUnionParam{
  				OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
  			},
  		})
  		if err != nil {
  			log.Fatal(err)
  		}
  		if summary.StopReason == anthropic.BetaStopReasonCompaction {
  			history = slices.Replace(history, 0, split, summary.ToParam())
  			fmt.Printf("Kept %d turns after the block\n", len(recent)/2)
  		}
  	}
  }
  ```

  ```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 schon 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.";
  static final int KEEP_TURNS = 2;

  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 > KEEP_TURNS && turn < questions.size()) {
              // Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort, daher beginnen die behaltenen Turns mit einer User-Nachricht.
              var older = history.subList(0, history.size() - 2 * KEEP_TURNS);
              var summaryParams = MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_5_5)
                  .maxTokens(4096)
                  .system(SYSTEM)
                  .addBeta(AnthropicBeta.COMPACT_2026_09_04)
                  .messages(older)
                  .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)) {
                  older.clear();
                  history.addFirst(summary.toParam());
                  IO.println("Kept " + (history.size() - 1) / 2 + " turns after the block");
              }
          }
      }
  }
  ```

  ```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 dies nahe an dein tatsächliches Input-Budget. Hier ist es 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.";
  const KEEP_TURNS = 2;

  $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 > KEEP_TURNS && $turn < count($questions)) {
          // Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort, daher beginnen die behaltenen Turns mit einer User-Nachricht.
          $older = array_slice($history, 0, -2 * KEEP_TURNS);
          $recent = array_slice($history, -2 * KEEP_TURNS);
          $summary = $client->beta->messages->create(
              model: Model::CLAUDE_OPUS_5_5,
              maxTokens: 4096,
              system: SYSTEM,
              betas: [AnthropicBeta::COMPACT_2026_09_04],
              messages: $older,
              compaction: new BetaCompactionConfig(), // type defaults to 'summarize'
          );
          if ($summary->stopReason === BetaStopReason::COMPACTION->value) {
              $history = [BetaMessageParam::with(role: Role::ASSISTANT, content: $summary->content), ...$recent];
              printf("Kept %d turns after the block\n", intdiv(count($recent), 2));
          }
      }
  }
  ```

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

  # 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."
  KEEP_TURNS = 2

  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 > KEEP_TURNS && turn < questions.length
      # Ein Turn besteht aus einer User-Nachricht und einer Assistant-Antwort, daher beginnen die behaltenen Turns mit einer User-Nachricht.
      older, recent = history[...-2 * KEEP_TURNS], history.last(2 * KEEP_TURNS)
      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: older,
        compaction: { type: "summarize" }
      )
      if summary.stop_reason == :compaction
        history = [{ role: "assistant", content: summary.content }, *recent]
        puts "Kept #{recent.length / 2} turns after the block"
      end
    end
  end
  ```
</CodeGroup>

* **Den Schnitt wählen:** Das Programm behält die letzten zwei Turns bei, wobei ein Turn aus einer `user`-Nachricht und der Antwort darauf besteht. Es teilt den Verlauf vier Nachrichten vor dem Ende, sodass die beibehaltenen Turns mit einer `user`-Nachricht beginnen.
* **Entscheiden, wann komprimiert wird:** Die Größenprüfung verlangt außerdem, dass die Unterhaltung mehr Turns hat, als das Programm beibehält, sodass der ältere Teil nie leer ist.
* **Die Komprimierungsanfrage:** Wo die Schleife den gesamten Verlauf sendet, sendet diese Version nur die älteren Nachrichten.
* **Der Austausch:** Wo die Schleife den gesamten Verlauf durch die zurückgegebene Nachricht ersetzt, besteht der neue Verlauf dieser Version aus der zurückgegebenen Nachricht, gefolgt von den beibehaltenen Turns.

Die `stop_reason`-Prüfung und jede Anfrage nach dem Austausch sind gegenüber der Schleife unverändert.

## Thinking in den beibehaltenen Turns gültig halten

Wenn du Thinking-Blöcke bei einem Modell mit [„preserved thinking“ (beibehaltenem Nachdenken)](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking) zurücksendest, bleibt das Thinking in den beibehaltenen Turns nur gültig, solange die [Bedingungen für beibehaltenes Thinking](https://platform.claude.com/docs/de/build-with-claude/compaction-thinking-blocks#conditions-for-kept-thinking-to-stay-valid) erfüllt sind, und eine davon schränkt ein, wo der Schnitt liegen kann.

Der Schnitt des Programms, zwischen einer Antwort und der nächsten `user`-Nachricht, erfüllt diese Bedingung. Das gilt auch für einen Schnitt am Ende einer Anfrage, die du bereits gestellt hast: Komprimiere genau die `messages` dieser Anfrage und behalte alles bei, was dein Verlauf seitdem hinzugewonnen hat.