---
title: Komprimierung im Hintergrund
url: https://platform.claude.com/docs/de/build-with-claude/compaction-background
description: Fordere bei Bedarf eine Compaction-Zusammenfassung an, während die Konversation auf ihrem vollständigen Verlauf weiterläuft, und tausche den Block ein, sobald er eintrifft.
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
---

Die „background compaction“ (Hintergrund-Komprimierung), oft auch „async compaction“ (asynchrone Komprimierung) genannt, ändert zwei Dinge in der [Komprimierungsschleife](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#compact-in-a-loop): Die Komprimierungsanfrage läuft, während die Konversation auf ihrem vollständigen Verlauf weitergeht, und der Austausch wartet, bis der Block eintrifft. [Ab der Zusammenfassung fortfahren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#continue-from-the-summary) und [Fehlende Zusammenfassung oder Fehler behandeln](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#when-no-summary-comes-back) gelten unverändert.

## Wie der Austausch funktioniert, während die Arbeit weitergeht

Die Komprimierungsanfrage und der Block, den sie zurückgibt, sind dieselben wie in der Schleife. Dein Verlauf wächst zwischen dem Senden der Anfrage und der Verwendung ihres Ergebnisses, und der Austausch muss diesen Zuwachs unverändert lassen.

1. Sende die [Komprimierungsanfrage](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#request-a-summary) mit deinem Verlauf in seinem aktuellen Zustand und notiere, wie viele Nachrichten er enthielt.
2. Während diese Anfrage läuft, führe die Konversation auf dem vollständigen Verlauf weiter. Hänge jeden neuen Turn an, bearbeite nichts, was bereits im Verlauf steht, und starte keine weitere Komprimierungsanfrage, bis diese eingetauscht wurde oder fehlgeschlagen ist.
3. Wenn die Antwort mit `stop_reason` `"compaction"` eintrifft, entferne genau die Nachrichten, die du gesendet hast, vom Anfang deines Verlaufs und setze die zurückgegebene Nachricht an ihre Stelle. Jeder seit Schritt 1 angehängte Turn bleibt dahinter erhalten.
4. Sende den ausgetauschten Verlauf mit der ersten Anfrage nach dem Eintreffen des Blocks, damit das Thinking, das während des Schreibens der Zusammenfassung entstanden ist, gültig bleibt.

Wenn die Komprimierungsanfrage zum Beispiel die Nachrichten 1 bis 5 enthielt und die Konversation während ihrer Laufzeit die Nachrichten 6 bis 8 hinzugewonnen hat, besteht dein Verlauf nach dem Austausch aus dem Block, gefolgt von den Nachrichten 6 bis 8.

<Frame>
  ![Zeitleiste der „background compaction" (Hintergrund-Komprimierung): Die Komprimierungsanfrage wird mit den Nachrichten 1 bis 5 gesendet, während die Konversation auf ihrem vollständigen Verlauf weitergeht und die Nachrichten 6 bis 8 hinzugewinnt; wenn der Block eintrifft, ersetzt er die Nachrichten 1 bis 5 am Anfang des Verlaufs, und der Verlauf besteht dann aus dem Block, gefolgt von den Nachrichten 6 bis 8](https://platform.claude.com/docs/de/images/compaction-background-timeline.svg)
</Frame>

Wenn die Antwort einen anderen `stop_reason` hat, wurde keine Zusammenfassung erstellt, was in Schritt 2 als Fehlschlag gilt. Behalte den vollständigen Verlauf; [Fehlende Zusammenfassung oder Fehler behandeln](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#when-no-summary-comes-back) listet die Ursachen auf und was jeweils zu tun ist.

## Die Zusammenfassung im Hintergrund anfordern

Die Komprimierungsanfrage wird wie jede andere Anfrage auf deine „rate limits“ (Ratenlimits) angerechnet, und während sie läuft, hat deine Anwendung zwei Anfragen gleichzeitig offen. Die Konversation wächst bis zum Austausch auf ihrem vollständigen Verlauf weiter, also starte die Komprimierungsanfrage, solange das „context window“ (Kontextfenster) noch Platz für die Turns hat, die in der Zwischenzeit eintreffen.

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), wobei die Komprimierungsanfrage aus dem Pfad der Konversation herausgenommen wurde. Die hervorgehobenen Zeilen zeigen, wo es sich von der Schleife unterscheidet, und die folgende Liste behandelt sie in der Reihenfolge, in der das Programm sie ausführt.

<CodeGroup exclude="shell, php">
  ```python Python
  from concurrent.futures import Future, ThreadPoolExecutor

  import anthropic
  from anthropic.types.beta import BetaMessage, BetaMessageParam

  client = anthropic.Anthropic()
  executor = ThreadPoolExecutor(max_workers=1)

  # 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."

  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?",
  ]


  def swap_in(history: list[BetaMessageParam], summary: BetaMessage, sent: int) -> None:
      if summary.stop_reason == "compaction":
          # Ersetze genau die Nachrichten, die die Kompaktierungsanfrage enthielt.
          # Spätere Turns bleiben nach dem Block erhalten.
          history[:sent] = [{"role": "assistant", "content": summary.content}]
          print(f"Swapped {sent} messages")


  history: list[BetaMessageParam] = []
  pending: Future[BetaMessage] | None = None
  sent = 0
  for turn, question in enumerate(QUESTIONS, start=1):
      if pending is not None and pending.done():
          swap_in(history, pending.result(), sent)
          pending = None

      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)
          and pending is None
      ):
          sent = len(history)
          pending = executor.submit(
              client.beta.messages.create,
              model="claude-opus-5-5",
              max_tokens=4096,
              system=SYSTEM,
              betas=["compact-2026-09-04"],
              messages=history.copy(),
              compaction={"type": "summarize"},
          )

  # Setze eine noch ausstehende Zusammenfassung ein, bevor du speicherst
  # oder das Gespräch fortsetzt.
  if pending is not None:
      swap_in(history, pending.result(), sent)
  executor.shutdown()
  ```

  ```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?"
  ];

  function swapIn(
    history: Anthropic.Beta.Messages.BetaMessageParam[],
    summary: Anthropic.Beta.Messages.BetaMessage,
    sent: number
  ): Anthropic.Beta.Messages.BetaMessageParam[] {
    if (summary.stop_reason !== "compaction") {
      return history;
    }
    console.log(`Swapped ${sent} messages`);
    // Ersetze genau die Nachrichten, die die Kompaktierungsanfrage enthielt. Spätere Turns bleiben nach dem Block.
    return [{ role: "assistant", content: summary.content }, ...history.slice(sent)];
  }

  let history: Anthropic.Beta.Messages.BetaMessageParam[] = [];
  let pending: Promise<Anthropic.Beta.Messages.BetaMessage> | undefined;
  let settled = false;
  let sent = 0;
  for (const [index, question] of questions.entries()) {
    const turn = index + 1;
    if (pending && settled) {
      history = swapIn(history, await pending, sent);
      pending = undefined;
      settled = false;
    }

    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 ebenfalls mit, also zähle sie mit.
    const conversationTokens = response.usage.input_tokens + response.usage.output_tokens;
    if (conversationTokens > compactAtTokens && turn < questions.length && !pending) {
      sent = history.length;
      pending = client.beta.messages.create({
        model: "claude-opus-5-5",
        max_tokens: 4096,
        system: systemPrompt,
        betas: ["compact-2026-09-04"],
        messages: [...history],
        compaction: { type: "summarize" }
      });
      // Markiere die Anfrage in jedem Fall als abgeschlossen. Ein Await darauf liefert dann die Zusammenfassung oder wirft.
      const markSettled = () => {
        settled = true;
      };
      pending.then(markSettled, markSettled);
    }
  }

  // Setze eine noch ausstehende Zusammenfassung ein, bevor du das Gespräch speicherst oder fortsetzt.
  if (pending) {
    history = swapIn(history, await pending, sent);
  }
  ```

  ```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 tatsächliches Input-Budget. Hier ist es niedrig, damit 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?",
  ];

  static List<BetaMessageParam> SwapIn(List<BetaMessageParam> history, BetaMessage summary, int sent)
  {
      if (summary.StopReason != BetaStopReason.Compaction)
      {
          return history;
      }
      Console.WriteLine($"Swapped {sent} messages");
      // Ersetze genau die Nachrichten, die die Kompaktierungsanfrage enthielt. Spätere Turns bleiben nach dem Block.
      return
      [
          new()
          {
              Role = Role.Assistant,
              Content = summary.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
          },
          .. history[sent..],
      ];
  }

  List<BetaMessageParam> history = [];
  Task<BetaMessage>? pending = null;
  var sent = 0;
  foreach (var (index, question) in questions.Index())
  {
      var turn = index + 1;
      if (pending is { IsCompleted: true })
      {
          history = SwapIn(history, await pending, sent);
          pending = null;
      }

      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 && pending is null)
      {
          sent = history.Count;
          pending = 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"
          });
      }
  }

  // Setze eine noch ausstehende Zusammenfassung ein, bevor du das Gespräch speicherst oder fortsetzt.
  if (pending is not null)
  {
      history = SwapIn(history, await pending, sent);
  }
  ```

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

  // Setze dies nahe an dein tatsächliches 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
  var pending chan *anthropic.BetaMessage
  var sent int
  swapIn := func(summary *anthropic.BetaMessage) {
  	if summary.StopReason != anthropic.BetaStopReasonCompaction {
  		return
  	}
  	fmt.Printf("Swapped %d messages\n", sent)
  	// Ersetze genau die Nachrichten, die die Kompaktierungsanfrage enthielt. Spätere Turns bleiben nach dem Block.
  	history = slices.Replace(history, 0, sent, summary.ToParam())
  }

  for i, question := range questions {
  	turn := i + 1
  	// Empfangen von einem nil-Channel gelingt nie, daher wird dies übersprungen, wenn nichts aussteht.
  	select {
  	case summary := <-pending:
  		swapIn(summary)
  		pending = nil
  	default:
  	}

  	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 ebenfalls mit, also zähle sie mit.
  	conversationTokens := response.Usage.InputTokens + response.Usage.OutputTokens
  	if conversationTokens > compactAtTokens && turn < len(questions) && pending == nil {
  		sent = len(history)
  		pending = make(chan *anthropic.BetaMessage, 1)
  		go func(messages []anthropic.BetaMessageParam, result chan<- *anthropic.BetaMessage) {
  			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:  messages,
  				Compaction: anthropic.BetaCompactionConfigUnionParam{
  					OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
  				},
  			})
  			if err != nil {
  				log.Fatal(err)
  			}
  			result <- summary
  		}(slices.Clone(history), pending)
  	}
  }

  // Setze eine noch ausstehende Zusammenfassung ein, bevor du das Gespräch speicherst oder fortsetzt.
  if pending != nil {
  	swapIn(<-pending)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaCompactionConfig;
  import com.anthropic.models.beta.messages.BetaMessage;
  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 swapIn(List<BetaMessageParam> history, BetaMessage summary, int sent) {
      if (!summary.stopReason().map(BetaStopReason.COMPACTION::equals).orElse(false)) {
          return;
      }
      IO.println("Swapped " + sent + " messages");
      // Ersetze genau die Nachrichten, die die Compaction-Anfrage enthielt. Spätere Turns bleiben nach dem Block.
      history.subList(0, sent).clear();
      history.addFirst(summary.toParam());
  }

  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>();
      CompletableFuture<BetaMessage> pending = null;
      int sent = 0;
      for (int turn = 1; turn <= questions.size(); turn++) {
          if (pending != null && pending.isDone()) {
              swapIn(history, pending.join(), sent);
              pending = null;
          }

          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() && pending == null) {
              sent = history.size();
              var summaryParams = MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_5_5)
                  .maxTokens(4096)
                  .system(SYSTEM)
                  .addBeta(AnthropicBeta.COMPACT_2026_09_04)
                  .messages(List.copyOf(history))
                  .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize"
                  .build();
              pending = client.async().beta().messages().create(summaryParams);
          }
      }

      // Setze eine noch ausstehende Zusammenfassung ein, bevor du das Gespräch speicherst oder fortsetzt.
      if (pending != null) {
          swapIn(history, pending.join(), sent);
      }
      client.close();
  }
  ```

  <CodeGroupItem language="PHP">
    Das PHP SDK sendet Anfragen synchron, daher kann es die Komprimierungsanfrage nicht im Hintergrund ausführen, während die Konversation weitergeht.
  </CodeGroupItem>

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

  # 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."

  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?"
  ]

  def swap_in(history, summary, sent)
    return history unless summary.stop_reason == :compaction

    puts "Swapped #{sent} messages"
    # Ersetze genau die Nachrichten, die die Kompaktierungsanfrage enthielt. Spätere Turns bleiben nach dem Block.
    [{ role: "assistant", content: summary.content }, *history[sent..]]
  end

  history = []
  pending = nil
  sent = 0
  questions.each.with_index(1) do |question, turn|
    if pending && !pending.alive?
      history = swap_in(history, pending.value, sent)
      pending = nil
    end

    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 && pending.nil?
      sent = history.length
      pending = Thread.new(history.dup) do |snapshot|
        client.beta.messages.create(
          model: Anthropic::Model::CLAUDE_OPUS_5_5,
          max_tokens: 4096,
          system_: SYSTEM,
          betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
          messages: snapshot,
          compaction: { type: "summarize" }
        )
      end
    end
  end

  # Setze eine noch ausstehende Zusammenfassung ein, bevor du das Gespräch speicherst oder fortsetzt.
  history = swap_in(history, pending.value, sent) if pending
  ```
</CodeGroup>

* **Entscheiden, wann komprimiert wird:** Die Größenprüfung setzt zusätzlich voraus, dass keine Komprimierungsanfrage aussteht.
* **Die Anfrage starten:** Wo die Schleife auf die Komprimierungsantwort wartet, notiert diese Version, wie viele Nachrichten der Verlauf enthält, startet die Anfrage auf einer Kopie des Verlaufs mit dem jeweiligen Nebenläufigkeitswerkzeug der Sprache und fährt ohne Warten mit dem nächsten Turn fort.
* **Auf das Ergebnis prüfen:** Zu Beginn jedes Turns prüft das Programm, ob die ausstehende Anfrage abgeschlossen ist. Falls ja, führt das Programm den Austausch durch, bevor es die Anfrage dieses Turns sendet.
* **Den Austausch durchführen:** Wo die Schleife den gesamten Verlauf durch die zurückgegebene Nachricht ersetzt, ersetzt die Austauschfunktion dieser Version nur die Nachrichten, die die Anfrage enthielt, vom Anfang an gezählt, und behält alles bei, was seitdem angehängt wurde.
* **Die Schleife beenden:** Wenn die Komprimierungsanfrage beim Ende der Schleife noch aussteht, wartet das Programm auf sie und führt den Austausch durch, damit eine Zusammenfassung, die noch unterwegs ist, nicht verloren geht, bevor du die Konversation speicherst oder fortsetzt.

Die Prüfung von `stop_reason` ist gegenüber der Schleife unverändert: Eine Antwort ohne Block lässt den Verlauf so, wie er war. Da dann nichts mehr aussteht, kann das Programm anschließend eine neue Komprimierungsanfrage starten.

## Thinking gültig halten, während die Zusammenfassung erstellt wird

Turns, die eintreffen, während die Zusammenfassung geschrieben wird, sind beibehaltene Turns. 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 diesen 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.