---
title: Prompting für Claude Fable 5.1
url: https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1
description: Verhaltensunterschiede und Prompting-Muster für Claude Fable 5.1 und Claude Mythos 5.1, zu den Themen Effort, Fortschritts-Updates, Bündelung von Tool-Aufrufen, Gesprächsverlauf, Schreibstil, Formatierung, Aufgabenabschluss, Compaction-Zusammenfassungen, Umfang und Testabdeckung, Auslösen von Suchen, Fehlalarme der Schutzmaßnahmen, Dateibearbeitungen, lange Ausgaben, Subagenten und Vision.
---

Informationen zu den Fähigkeiten des Modells, API-Änderungen, Preisen und Verfügbarkeit findest du unter [Was ist neu in Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/whats-new-fable-5-1). Techniken, die für alle Claude-Modelle gelten, findest du unter [Best Practices für das Prompting](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices).

Deine bestehenden Prompts für Claude Fable 5 sollten auf Claude Fable 5.1 ohne Änderungen gut funktionieren, aber eine Handvoll Verhaltensunterschiede sind wissenswert. Beginne mit dem Abschnitt, der zu dem passt, was du beobachtest:

* Unsicher, welche Effort-Stufe du verwenden sollst, oder Latenz und Kosten sind höher, als die Aufgabe rechtfertigt: [Alle Effort-Stufen in Betracht ziehen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels)
* Wenig oder kein Text zwischen Tool-Aufrufen: [Nutzerseitige Fortschritts-Updates anfordern](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates)
* Ein Tool-Aufruf pro Turn in Agentenschleifen: [Unabhängige Tool-Aufrufe in Agentenschleifen bündeln](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#batch-independent-tool-calls-in-agent-loops)
* Anfragen schlagen mit `bound to a different conversation` fehl, oder dein Harness bearbeitet zwischen Anfragen frühere Turns: [Den Gesprächsverlauf append-only halten](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)
* Prosa wird lang und dicht: [Schreibdichte](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#writing-density)
* Chat-Antworten haben weniger Struktur, als der Inhalt braucht: [Formatierung im Chat](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#formatting-in-chat)
* Zusammenfassungen geben den Wortlaut der Quelle wieder, ohne ihn als Zitat zu kennzeichnen: [Abgerufene Quellen zitieren](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#quoting-retrieved-sources)
* Der Turn endet, bevor die Arbeit erledigt ist, oder das Modell bittet um Erlaubnis für Arbeit, die du bereits angefordert hast: [Die ganze Aufgabe abschließen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#finish-the-whole-task)
* Clientseitige Compaction-Zusammenfassungen lassen Einschränkungen, Entscheidungen oder genaue Details fallen: [Dem Modell sagen, was es in Compaction-Zusammenfassungen bewahren soll](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries)
* Nicht angeforderte Korrekturen oder Erweiterungen, oder mehr committete Testdateien, als die Aufgabe verlangte: [Änderungen und Tests auf das beschränken, was die Aufgabe verlangt](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-changes-and-tests-to-what-the-task-asks-for)
* Antworten aus dem Gedächtnis statt Suche bei niedrigem Effort: [Auslösen von Suchen bei niedrigem Effort](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort)
* Harmlose Coding-Anfragen liefern `stop_reason: "refusal"`: [Fehlalarme der Schutzmaßnahmen reduzieren](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#reduce-safeguard-false-positives)
* Ganze Dateien werden für kleine Änderungen neu geschrieben: [Gezielte Bearbeitungen statt Neuschreiben ganzer Dateien bevorzugen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#prefer-targeted-edits-over-whole-file-rewrites)
* Lange Ergebnisse bei `xhigh`- oder `max`-Effort dauern lange oder erreichen `max_tokens`: [Platz für lange Ausgaben bei xhigh- und max-Effort lassen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#leave-room-for-long-outputs-at-xhigh-and-max-effort)
* Der leitende Agent ist untätig, während Subagenten laufen: [Den leitenden Agenten weiterarbeiten lassen, während Subagenten laufen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#let-the-lead-agent-keep-working-while-subagents-run)
* Antworten zu Diagrammen und dichten Bildern übersehen Details: [Vision-Arbeit Tools zum Zuschneiden und Zoomen geben](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#give-vision-work-tools-to-crop-and-zoom)

<Note>
  Claude Fable 5.1 führt Sicherheitsklassifikatoren aus und kann `stop_reason: "refusal"` zurückgeben. Siehe [Ablehnungen, Fallback und Abrechnung](https://platform.claude.com/docs/de/models/fable-5-1/whats-new-fable-5-1#refusals-fallback-and-billing) und [Fehlalarme der Schutzmaßnahmen reduzieren](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#reduce-safeguard-false-positives).

  Prompts, Skills und Tool-Beschreibungen, die das Modell auffordern, sein Nachdenken oder sein Reasoning auszuschreiben, können mit der Kategorie `reasoning_extraction` abgelehnt werden. Bitte stattdessen um eine kurze Erklärung oder eine Zusammenfassung der durchgeführten Aktionen, oder lies das Reasoning aus Blöcken mit [zusammengefasstem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking#summarized-thinking) (`display: "summarized"`). Siehe [Reasoning in Thinking-Blöcken belassen](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks).
</Note>

## Alle Effort-Stufen in Betracht ziehen

Beginne mit der Standardstufe für [„effort“ (Aufwand)](https://platform.claude.com/docs/de/build-with-claude/effort), `high`, und teste dann die anderen Stufen (`low`, `medium`, `xhigh` und `max`) gegen deine eigenen Evals. Effort ist der primäre Regler, um auf Claude Fable 5.1 Intelligenz, Latenz und Kosten gegeneinander abzuwägen. Führe den Sweep erneut durch, auch wenn du bereits einen auf Claude Fable 5 durchgeführt hast: Die Namen der Effort-Stufen entsprechen nicht modellübergreifend derselben Menge an Nachdenken.

Die Fähigkeitsgewinne von Claude Fable 5.1 gegenüber Claude Fable 5 zeigen sich über alle Effort-Stufen hinweg und sind bei den höheren Einstellungen am größten. Bei `medium` entsprechen die Ergebnisse ungefähr Claude Fable 5 bei geringeren Kosten, gehe also auf `medium` oder `low` herunter, wo deine Evals zeigen, dass die Qualität hält. Bei `low` ist Claude Fable 5.1 bei den Kosten pro Aufgabe oft konkurrenzfähig mit Claude Opus- und Claude Sonnet-Modellen und erzielt dabei höhere Werte, nimm es also überall in den Vergleich auf, wo du sonst ein kleineres Modell auf einer höheren Effort-Stufe betreiben würdest.

Zwei effortspezifische Verhaltensweisen haben eigene Abschnitte: Bei `low` ruft Claude Fable 5.1 Such- und Retrieval-Tools seltener auf (siehe [Auslösen von Suchen bei niedrigem Effort](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#search-triggering-at-low-effort)), und bei `xhigh` und `max` kann es länger nachdenken, bevor es ein langes Ergebnis schreibt (siehe [Platz für lange Ausgaben bei xhigh- und max-Effort lassen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#leave-room-for-long-outputs-at-xhigh-and-max-effort)).

## Nutzerseitige Fortschritts-Updates anfordern

Das Standardverhalten von Claude Fable 5.1 ist es, während langer Turns mit Tool-Aufrufen weniger nutzerseitige „progress updates“ (Fortschritts-Updates) zu schreiben als Claude Fable 5. Dies wird bei höherem Effort und in längeren Tool-Ketten ausgeprägter. Nutzer sehen, wie der Agent minutenlang verstummt, oder eine abschließende Nachricht, die nur den letzten Schritt statt der ganzen Aufgabe abdeckt.

Prüfe zuerst, ob dein Client überhaupt Fortschritts-Updates empfängt. Die kurzen Notizen des Modells zwischen Tool-Aufrufen, was es gerade gefunden hat und was es als Nächstes tut, kommen als [Fortschritts-Update-`thinking`-Blöcke](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) zurück, und diese Blöcke sind unter dem Standardwert von `thinking.display`, `"omitted"`, leer. Setze `display: "updates"` (Beta, Header `thinking-display-updates-2026-08-18`) und rendere jeden nicht leeren `thinking`-Block als Statuszeile, oder setze `"summarized"`, um sie zusammen mit zusammengefasstem Reasoning zu erhalten. Wenn du sie nicht anforderst, erreichen die Updates des Modells deine Nutzer möglicherweise einfach nicht.

Zweitens: Prüfe deinen Prompt auf Anweisungen, die das Erzählen unterdrücken. Einige frühere Modelle gaben während der Arbeit eifrig Updates, was zu System-Prompt-Zeilen wie „halte alle Erkenntnisse für die abschließende Antwort zurück“ führte. Entferne solche Zeilen, bevor du etwas hinzufügst.

Wenn du dennoch mehr Updates möchtest, zum Beispiel beim Pair Programming oder bei anderer Human-in-the-Loop-Arbeit, füge eine kurze System-Prompt-Zeile hinzu, die sagt, wann du nutzerseitigen Text vom Modell möchtest und was jedes Update enthalten soll:

```text wrap
Before you start, say in a line what you're about to do; brief updates while you work help the user follow along. Close with a short recap that stands on its own — what you found, what you did, and what's next — so a reader who only sees the last message has the full picture.
```

Wenn dein Produkt Tool-Ausgaben einklappt oder ausblendet, sag es dem Modell. Andernfalls führt es möglicherweise Befehle aus, um dem Nutzer Ausgaben zu „zeigen“, die deine UI nie anzeigt. Übermittle den Hinweis in einer [„turn-scoped system message“ (auf den Turn begrenzten Systemnachricht)](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) (`clear_at: "next_user_message"`, Beta):

```text wrap
Only you see that command's output — the user's terminal shows at most a few lines of it. If the user needs to read any of it, put it in your reply.
```

## Unabhängige Tool-Aufrufe in Agentenschleifen bündeln

Claude Fable 5.1 gibt parallele Tool-Aufrufe normalerweise wie erwartet aus: Wenn eine Anfrage mehrere abzurufende Dinge nennt, gibt es diese Aufrufe parallel aus. Die Ausnahme sind Coding- und Computer-Use-Schleifen, in denen die nächsten unabhängigen Aufrufe durch die Aufgabe impliziert statt explizit angefordert werden (benutzerdefinierte Coding-Agenten, Bash-und-Editor-Harnesses, Computer Use): Dort gibt es sie möglicherweise einzeln pro Turn aus. Das beeinflusst die Antwortqualität nicht, aber jeder zusätzliche Turn kostet Token, einen Roundtrip und Echtzeit. Ein Ein-Satz-Anstoß am Ende der aktuellen Anfrage behebt das:

```text wrap
First privately list what you need next; then request every item that doesn't depend on another's result in this one response.
```

Jedes Mal, wenn du Tool-Ergebnisse zurücksendest, hänge ihn nach dieser User-Nachricht als [auf den Turn begrenzte Systemnachricht](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages) an: einen `role: "system"`-Eintrag in `messages` mit `clear_at: "next_user_message"`. Sobald eine spätere User-Nachricht existiert, löscht die API die früheren Kopien, sodass das Modell nur die neueste liest. Auf den Turn begrenzte Systemnachrichten sind in der Beta und erfordern den [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `mid-conversation-system-clear-at-2026-08-21`. Ohne die Beta platziere den Satz stattdessen in einem Textblock nach den `tool_result`-Blöcken in derselben User-Nachricht.

Hänge in jedem Turn eine frische Kopie an und lass die früheren Kopien Byte für Byte dort, wo sie sind. Sie bleiben im Array, aber sobald sie gelöscht sind, sieht das Modell sie nicht und sie kosten keine Input-Token. Sie zu löschen oder umzuschreiben ist eine Bearbeitung früherer Turns: Es startet den [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) ab diesem Punkt neu und macht die Thinking-Blöcke ungültig, die danach kamen (siehe [Den Gesprächsverlauf append-only halten](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#keep-the-conversation-history-append-only)).

Die folgende Schleife zeigt diese Platzierung. Jeder Assistant-Turn geht genau so zurück, wie er zurückgegeben wurde, jeder User-Turn trägt nur die Tool-Ergebnisse, und eine frische, auf den Turn begrenzte Kopie des Anstoßes folgt darauf.

<CodeGroup exclude="shell">
  ```python Python
  import anthropic
  from anthropic.types.beta import (
      BetaMessageParam,
      BetaToolParam,
      BetaToolResultBlockParam,
  )

  client = anthropic.Anthropic()

  BATCH_NUDGE = (
      "First privately list what you need next; then request every item "
      "that doesn't depend on another's result in this one response."
  )
  # In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  FILES = {
      "pyproject.toml": """\
  [project]
  name = "demo"
  version = "0.1.0"
  description = "Demo project for the batching example"
  """,
      "README.md": """\
  # demo

  A small demo project. Run `demo --help` for usage.
  """,
  }
  tools: list[BetaToolParam] = [
      {
          "name": "read_file",
          "description": "Read a UTF-8 text file from the working directory.",
          "input_schema": {
              "type": "object",
              "properties": {"path": {"type": "string"}},
              "required": ["path"],
          },
      }
  ]
  messages: list[BetaMessageParam] = [
      {"role": "user", "content": "Summarize pyproject.toml and README.md."}
  ]

  while True:
      response = client.beta.messages.create(
          model="claude-fable-5-1",
          max_tokens=16000,
          betas=["mid-conversation-system-clear-at-2026-08-21"],
          tools=tools,
          messages=messages,
      )
      # Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
      messages.append({"role": "assistant", "content": response.content})
      if response.stop_reason != "tool_use":
          break
      tool_results: list[BetaToolResultBlockParam] = []
      for block in response.content:
          if block.type == "tool_use":
              raw_path = block.input.get("path")
              path = raw_path if isinstance(raw_path, str) else ""
              if path in FILES:
                  tool_results.append(
                      {
                          "type": "tool_result",
                          "tool_use_id": block.id,
                          "content": FILES[path],
                      }
                  )
              else:
                  tool_results.append(
                      {
                          "type": "tool_result",
                          "tool_use_id": block.id,
                          "content": f"File not found: {path}",
                          "is_error": True,
                      }
                  )
      # Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
      # Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
      # sodass das Modell nur die neueste sieht.
      messages.append({"role": "user", "content": tool_results})
      messages.append(
          {"role": "system", "content": BATCH_NUDGE, "clear_at": "next_user_message"}
      )

  print(next((block.text for block in response.content if block.type == "text"), ""))
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";

  const client = new Anthropic();

  const BATCH_NUDGE =
    "First privately list what you need next; then request every item " +
    "that doesn't depend on another's result in this one response.";
  // In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  const FILES = new Map<string, string>([
    [
      "pyproject.toml",
      `[project]
  name = "demo"
  version = "0.1.0"
  description = "Demo project for the batching example"
  `,
    ],
    [
      "README.md",
      `# demo

  A small demo project. Run \`demo --help\` for usage.
  `,
    ],
  ]);
  const tools: Anthropic.Beta.Messages.BetaTool[] = [
    {
      name: "read_file",
      description: "Read a UTF-8 text file from the working directory.",
      input_schema: {
        type: "object",
        properties: { path: { type: "string" } },
        required: ["path"],
      },
    },
  ];
  const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
    { role: "user", content: "Summarize pyproject.toml and README.md." },
  ];

  let response: Anthropic.Beta.Messages.BetaMessage;
  while (true) {
    response = await client.beta.messages.create({
      model: "claude-fable-5-1",
      max_tokens: 16000,
      betas: ["mid-conversation-system-clear-at-2026-08-21"],
      tools,
      messages,
    });
    // Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
    messages.push({ role: "assistant", content: response.content });
    if (response.stop_reason !== "tool_use") {
      break;
    }
    const toolResults: Anthropic.Beta.Messages.BetaToolResultBlockParam[] = [];
    for (const block of response.content) {
      if (block.type !== "tool_use") {
        continue;
      }
      const { input } = block;
      const path =
        typeof input === "object" &&
        input !== null &&
        "path" in input &&
        typeof input.path === "string"
          ? input.path
          : "";
      const text = FILES.get(path);
      if (text === undefined) {
        toolResults.push({
          type: "tool_result",
          tool_use_id: block.id,
          content: `File not found: ${path}`,
          is_error: true,
        });
        continue;
      }
      toolResults.push({
        type: "tool_result",
        tool_use_id: block.id,
        content: text,
      });
    }
    // Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
    // Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
    // sodass das Modell nur die neueste sieht.
    messages.push({ role: "user", content: toolResults });
    messages.push({
      role: "system",
      content: BATCH_NUDGE,
      clear_at: "next_user_message",
    });
  }

  const finalText = response.content.find((block) => block.type === "text");
  console.log(finalText?.text ?? "");
  ```

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

  AnthropicClient client = new();

  const string BatchNudge =
      "First privately list what you need next; then request every item "
      + "that doesn't depend on another's result in this one response.";

  // In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  Dictionary<string, string> files = new()
  {
      ["pyproject.toml"] = """
          [project]
          name = "demo"
          version = "0.1.0"
          description = "Demo project for the batching example"
          """,
      ["README.md"] = """
          # demo

          A small demo project. Run `demo --help` for usage.
          """,
  };

  List<BetaToolUnion> tools =
  [
      new BetaTool
      {
          Name = "read_file",
          Description = "Read a UTF-8 text file from the working directory.",
          InputSchema = new InputSchema
          {
              Properties = new Dictionary<string, JsonElement>
              {
                  ["path"] = JsonSerializer.SerializeToElement(new { type = "string" }),
              },
              Required = ["path"],
          },
      },
  ];

  List<BetaMessageParam> messages =
  [
      new() { Role = Role.User, Content = "Summarize pyproject.toml and README.md." },
  ];

  BetaMessage response;
  while (true)
  {
      response = await client.Beta.Messages.Create(new MessageCreateParams
      {
          Model = Model.ClaudeFable5_1,
          MaxTokens = 16000,
          Betas = ["mid-conversation-system-clear-at-2026-08-21"],
          Tools = tools,
          Messages = messages,
      });
      // Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
      messages.Add(new()
      {
          Role = Role.Assistant,
          Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
      });
      if (response.StopReason != BetaStopReason.ToolUse)
      {
          break;
      }
      List<BetaContentBlockParam> toolResults = [];
      foreach (var block in response.Content)
      {
          if (block.TryPickToolUse(out var toolUse))
          {
              var path = toolUse.Input.TryGetValue("path", out var pathValue)
                  && pathValue.ValueKind == JsonValueKind.String
                  ? pathValue.GetString()!
                  : "";
              if (files.TryGetValue(path, out var fileText))
              {
                  toolResults.Add(new BetaToolResultBlockParam { ToolUseID = toolUse.ID, Content = fileText });
              }
              else
              {
                  toolResults.Add(new BetaToolResultBlockParam
                  {
                      ToolUseID = toolUse.ID,
                      Content = $"File not found: {path}",
                      IsError = true,
                  });
              }
          }
      }
      // Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
      // Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
      // sodass das Modell nur die neueste sieht.
      messages.Add(new() { Role = Role.User, Content = toolResults });
      messages.Add(new()
      {
          Role = Role.System,
          Content = BatchNudge,
          ClearAt = ClearAt.NextUserMessage,
      });
  }

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var text))
      {
          Console.WriteLine(text.Text);
          break;
      }
  }
  ```

  ```go Go
  package main

  import (
  	"context"
  	"encoding/json"
  	"fmt"
  	"log"

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

  const batchNudge = "First privately list what you need next; then request every item " +
  	"that doesn't depend on another's result in this one response."

  // In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  var files = map[string]string{
  	"pyproject.toml": `[project]
  name = "demo"
  version = "0.1.0"
  description = "Demo project for the batching example"
  `,
  	"README.md": `# demo

  A small demo project. Run "demo --help" for usage.
  `,
  }

  func main() {
  	client := anthropic.NewClient()
  	ctx := context.Background()

  	tools := []anthropic.BetaToolUnionParam{
  		{OfTool: &anthropic.BetaToolParam{
  			Name:        "read_file",
  			Description: anthropic.String("Read a UTF-8 text file from the working directory."),
  			InputSchema: anthropic.BetaToolInputSchemaParam{
  				Properties: map[string]any{
  					"path": map[string]any{"type": "string"},
  				},
  				Required: []string{"path"},
  			},
  		}},
  	}
  	messages := []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize pyproject.toml and README.md.")),
  	}

  	var response *anthropic.BetaMessage
  	for {
  		var err error
  		response, err = client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
  			Model:     anthropic.ModelClaudeFable5_1,
  			MaxTokens: 16000,
  			Betas:     []anthropic.AnthropicBeta{"mid-conversation-system-clear-at-2026-08-21"},
  			Tools:     tools,
  			Messages:  messages,
  		})
  		if err != nil {
  			log.Fatal(err)
  		}
  		// Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
  		messages = append(messages, response.ToParam())
  		if response.StopReason != anthropic.BetaStopReasonToolUse {
  			break
  		}
  		var toolResults []anthropic.BetaContentBlockParamUnion
  		for _, block := range response.Content {
  			toolUse, ok := block.AsAny().(anthropic.BetaToolUseBlock)
  			if !ok {
  				continue
  			}
  			var input struct {
  				Path string `json:"path"`
  			}
  			// Ein fehlender Pfad oder einer, der kein String ist, lässt input.Path leer, was in den Fehlerergebnis-Zweig führt.
  			if err := json.Unmarshal([]byte(toolUse.JSON.Input.Raw()), &input); err != nil {
  				input.Path = ""
  			}
  			text, found := files[input.Path]
  			if !found {
  				text = "File not found: " + input.Path
  			}
  			toolResults = append(toolResults, anthropic.NewBetaToolResultBlock(toolUse.ID, text, !found))
  		}
  		// Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
  		// Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
  		// sodass das Modell nur die neueste sieht.
  		messages = append(messages, anthropic.NewBetaUserMessage(toolResults...))
  		messages = append(messages, anthropic.BetaMessageParam{
  			Role:    anthropic.BetaMessageParamRoleSystem,
  			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock(batchNudge)},
  			ClearAt: anthropic.BetaMessageParamClearAtNextUserMessage,
  		})
  	}

  	for _, block := range response.Content {
  		if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
  			fmt.Println(textBlock.Text)
  			break
  		}
  	}
  }
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.core.JsonValue;
  import com.anthropic.models.beta.messages.BetaContentBlockParam;
  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.BetaTool;
  import com.anthropic.models.beta.messages.BetaTool.InputSchema;
  import com.anthropic.models.beta.messages.BetaToolResultBlockParam;
  import com.anthropic.models.beta.messages.BetaToolUseBlock;
  import com.anthropic.models.beta.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  static final String BATCH_NUDGE =
      "First privately list what you need next; then request every item "
          + "that doesn't depend on another's result in this one response.";

  // In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  static final Map<String, String> FILES = Map.of(
      "pyproject.toml", """
          [project]
          name = "demo"
          version = "0.1.0"
          description = "Demo project for the batching example"
          """,
      "README.md", """
          # demo

          A small demo project. Run `demo --help` for usage.
          """);

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

      BetaTool readFileTool = BetaTool.builder()
          .name("read_file")
          .description("Read a UTF-8 text file from the working directory.")
          .inputSchema(InputSchema.builder()
              .properties(JsonValue.from(Map.of("path", Map.of("type", "string"))))
              .required(List.of("path"))
              .build())
          .build();
      List<BetaMessageParam> messages = new ArrayList<>();
      messages.add(BetaMessageParam.builder()
          .role(BetaMessageParam.Role.USER)
          .content("Summarize pyproject.toml and README.md.")
          .build());

      BetaMessage response;
      while (true) {
          response = client.beta().messages().create(MessageCreateParams.builder()
              .model(Model.CLAUDE_FABLE_5_1)
              .maxTokens(16000)
              .addBeta("mid-conversation-system-clear-at-2026-08-21")
              .addTool(readFileTool)
              .messages(messages)
              .build());
          // Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
          messages.add(response.toParam());
          boolean requestedTools = response.stopReason()
              .map(BetaStopReason.TOOL_USE::equals)
              .orElse(false);
          if (!requestedTools) {
              break;
          }
          List<BetaToolUseBlock> toolUses = response.content().stream()
              .flatMap(block -> block.toolUse().stream())
              .toList();
          List<BetaContentBlockParam> toolResults = new ArrayList<>();
          for (BetaToolUseBlock toolUse : toolUses) {
              Map<String, JsonValue> input =
                  (Map<String, JsonValue>) toolUse._input().asObject().orElseThrow();
              JsonValue pathValue = input.get("path");
              String path = pathValue != null && pathValue.asString().isPresent()
                  ? pathValue.asStringOrThrow()
                  : "";
              String fileText = FILES.get(path);
              BetaToolResultBlockParam.Builder result = BetaToolResultBlockParam.builder()
                  .toolUseId(toolUse.id());
              if (fileText != null) {
                  result.content(fileText);
              } else {
                  result.content("File not found: " + path).isError(true);
              }
              toolResults.add(BetaContentBlockParam.ofToolResult(result.build()));
          }
          // Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
          // Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
          // sodass das Modell nur die neueste sieht.
          messages.add(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.USER)
              .contentOfBetaContentBlockParams(toolResults)
              .build());
          messages.add(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.SYSTEM)
              .content(BATCH_NUDGE)
              .clearAt(BetaMessageParam.ClearAt.NEXT_USER_MESSAGE)
              .build());
      }

      String finalText = response.content().stream()
          .flatMap(block -> block.text().stream())
          .map(textBlock -> textBlock.text())
          .findFirst()
          .orElse("");
      IO.println(finalText);
  }
  ```

  ```php PHP
  <?php

  use Anthropic\Beta\Messages\BetaStopReason;
  use Anthropic\Client;

  $client = new Client();

  const BATCH_NUDGE = 'First privately list what you need next; then request every item '
      . "that doesn't depend on another's result in this one response.";
  // In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  const FILES = [
      'pyproject.toml' => <<<'TOML'
          [project]
          name = "demo"
          version = "0.1.0"
          description = "Demo project for the batching example"
          TOML,
      'README.md' => <<<'MD'
          # demo

          A small demo project. Run `demo --help` for usage.
          MD,
  ];
  $tools = [
      [
          'name' => 'read_file',
          'description' => 'Read a UTF-8 text file from the working directory.',
          'input_schema' => [
              'type' => 'object',
              'properties' => ['path' => ['type' => 'string']],
              'required' => ['path'],
          ],
      ],
  ];
  $messages = [
      ['role' => 'user', 'content' => 'Summarize pyproject.toml and README.md.'],
  ];

  while (true) {
      $response = $client->beta->messages->create(
          model: 'claude-fable-5-1',
          maxTokens: 16000,
          betas: ['mid-conversation-system-clear-at-2026-08-21'],
          tools: $tools,
          messages: $messages,
      );
      // Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
      $messages[] = ['role' => 'assistant', 'content' => $response->content];
      if ($response->stopReason !== BetaStopReason::TOOL_USE->value) {
          break;
      }
      $toolResults = [];
      foreach ($response->content as $block) {
          if ($block->type === 'tool_use') {
              $path = is_string($block->input['path'] ?? null) ? $block->input['path'] : '';
              if (array_key_exists($path, FILES)) {
                  $toolResults[] = [
                      'type' => 'tool_result',
                      'tool_use_id' => $block->id,
                      'content' => FILES[$path],
                  ];
              } else {
                  $toolResults[] = [
                      'type' => 'tool_result',
                      'tool_use_id' => $block->id,
                      'content' => "File not found: {$path}",
                      'is_error' => true,
                  ];
              }
          }
      }
      // Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
      // Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
      // sodass das Modell nur die neueste sieht.
      $messages[] = ['role' => 'user', 'content' => $toolResults];
      $messages[] = [
          'role' => 'system',
          'content' => BATCH_NUDGE,
          'clear_at' => 'next_user_message',
      ];
  }

  $textBlock = array_find($response->content, fn ($block) => $block->type === 'text');
  echo $textBlock?->text ?? '', PHP_EOL;
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::Client.new

  BATCH_NUDGE =
    "First privately list what you need next; then request every item " \
    "that doesn't depend on another's result in this one response."
  # In-Memory-Dateien ersetzen ein Arbeitsverzeichnis, damit das Beispiel überall läuft.
  FILES = {
    "pyproject.toml" => <<~TOML,
      [project]
      name = "demo"
      version = "0.1.0"
      description = "Demo project for the batching example"
    TOML
    "README.md" => <<~MD
      # demo

      A small demo project. Run `demo --help` for usage.
    MD
  }
  tools = [
    {
      name: "read_file",
      description: "Read a UTF-8 text file from the working directory.",
      input_schema: {
        type: "object",
        properties: {path: {type: "string"}},
        required: ["path"]
      }
    }
  ]
  messages = [{role: "user", content: "Summarize pyproject.toml and README.md."}]

  response = nil
  loop do
    response = client.beta.messages.create(
      model: "claude-fable-5-1",
      max_tokens: 16000,
      betas: ["mid-conversation-system-clear-at-2026-08-21"],
      tools: tools,
      messages: messages
    )
    # Hänge den Assistant-Turn genau wie zurückgegeben an, inklusive Thinking-Blöcke.
    messages << {role: "assistant", content: response.content}
    break unless response.stop_reason == :tool_use

    tool_results = response.content.filter_map do |block|
      next unless block.type == :tool_use

      path = block.input[:path]
      if FILES.key?(path)
        {type: "tool_result", tool_use_id: block.id, content: FILES[path]}
      else
        {
          type: "tool_result",
          tool_use_id: block.id,
          content: "File not found: #{path}",
          is_error: true
        }
      end
    end
    # Sende die Tool-Ergebnisse als User-Turn, dann eine frische Kopie des Anstoßes als
    # Turn-bezogene Systemnachricht. Lass frühere Kopien stehen: Die API leert sie,
    # sodass das Modell nur die neueste sieht.
    messages << {role: "user", content: tool_results}
    messages << {role: "system", content: BATCH_NUDGE, clear_at: "next_user_message"}
  end

  puts response.content.find { it.type == :text }&.text
  ```
</CodeGroup>

## Den Gesprächsverlauf append-only halten

Hänge jeden Assistant-Turn genau so an den Verlauf an, wie die API ihn zurückgegeben hat, einschließlich der Thinking-Blöcke, und bearbeite frühere Turns zwischen Anfragen nicht. Für neue Konten, die am oder nach dem 31. August 2026 erstellt wurden, sind die Thinking-Blöcke von Claude Fable 5.1 [nur in genau dem Gespräch gültig, das sie erzeugt hat](https://platform.claude.com/docs/de/build-with-claude/thinking#preserved-in-conversation): Eine Anfrage, die einen Thinking-Block erneut sendet, nachdem sich sein Präfix (der System-Prompt, die Tool-Liste oder eine frühere Nachricht) geändert hat, liefert einen 400-Fehler zurück oder verwirft die betroffenen Blöcke, wenn du `thinking.block_binding.prefix_mismatch_behavior: "drop_block"` setzt (Beta, Header `thinking-binding-controls-2026-08-01`). Übernimm dieses Muster auch dann, wenn die Prüfung für dein Konto nicht erzwungen wird, damit derselbe Code auf jedem Konto funktioniert.

Die Verlaufsbearbeitungen, die die Prüfung auslösen, sind dieselben, die den [Prompt-Cache](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) neu starten: das Einfügen und Entfernen von Erinnerungen pro Turn, das Zusammenfassen älterer Turns an Ort und Stelle oder das Ändern des System-Prompts mitten in der Sitzung. Sende Erinnerungen pro Turn als [auf den Turn begrenzte Systemnachrichten](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#turn-scoped-system-messages), ändere Anweisungen oder Tools mit einer [Systemnachricht mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages), statt `system` oder `tools` umzuschreiben, und überlasse jegliches Kürzen der serverseitigen [„compaction“ (Verdichtung)](https://platform.claude.com/docs/de/build-with-claude/compaction) oder dem [Context Editing](https://platform.claude.com/docs/de/build-with-claude/context-editing). Wenn du auf dem Client komprimierst, ist die einfachste Form, den gesamten Verlauf durch eine Zusammenfassungsnachricht plus den neuen User-Turn zu ersetzen und sonst nichts erneut zu senden: Keine Thinking-Blöcke werden übernommen, also schlägt nichts fehl, und das Modell denkt über das komprimierte Gespräch neu nach (siehe [Benutzerdefinierte Compaction auf dem Client](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#custom-compaction-on-the-client)). Da Cache-Lesevorgänge jetzt günstiger sind (siehe [Preise](https://platform.claude.com/docs/de/models/fable-5-1/whats-new-fable-5-1#pricing)), ist frühes Komprimieren zur Kostenersparnis auf Claude Fable 5.1 möglicherweise nicht mehr der richtige Kompromiss zwischen Kosten und Intelligenz, experimentiere also mit späteren Compaction-Punkten.

Um Bearbeitungen zu finden, die dein Harness bereits vornimmt, führe eine Sitzung mit `prefix_mismatch_behavior: "drop_block"` aus und protokolliere `input_transformations`, wie in [So erkennst du, ob deine Integration betroffen ist](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted) beschrieben, oder erfasse die genauen Anfragen, die es über einige normale Turns sendet, und bestätige, dass aufeinanderfolgende Anfragen bis zu den angehängten Turns byteidentisch sind.

## Schreibdichte

Die Texte von Claude Fable 5.1 enthalten wenige Floskeln und wenig unerklärten Fachjargon. In manchen Fällen ist seine Prosa jedoch dichter als die von Claude Fable 5: Die Sätze sind länger und es gibt weniger Absatzumbrüche. Eine Anweisung, die das Anti-Muster – manierierte Prosa – definiert, hilft. Füge sie einer User-Nachricht (bevorzugt) oder dem System-Prompt hinzu:

```text wrap
Mannered prose substitutes metaphor and flourish for direct statement. Instead of "a parameter worth varying," the mannered writer produces "a dial worth turning." Instead of "this point still matters," they write "this point earns its keep." The phrases exist to display the writer, not to convey the idea, and readers can tell. That is why mannered prose irritates: it makes the reader work harder so the writer can perform. It is also imprecise. Metaphors drag in connotations the writer did not choose and cannot control. The fix is to say what you mean. When a literal phrase is available, use it.
```

Die Kurzversion funktioniert in der Regel ebenfalls:

```text wrap
Please remove all mannered prose.
```

## Formatierung im Chat

Frühere Modelle nutzten Aufzählungspunkte und Fettdruck im Chat übermäßig, und viele Prompts enthalten Anti-Formatierungsregeln, die geschrieben wurden, um das einzudämmen. Claude Fable 5.1 neigt in die andere Richtung: Es verwendet Fettdruck seltener und greift weniger wahrscheinlich zu Überschriften, Listen oder Anführungszeichen. Wenn dein Prompt Anti-Formatierungssprache enthält, entferne sie oder ersetze sie durch eine Regel, die sagt, wann bestimmte Formatierung angemessen ist, wie die folgende:

```text wrap
Use lists and bullet points when asked to, or when the content is multifaceted enough that they help with clarity. If the person explicitly requests minimal formatting, always format your responses without bullet points, headers, lists, or bold emphasis, as requested. In conversational, personal, or emotional exchanges, keep to plain prose.
```

## Abgerufene Quellen zitieren

Beim Zusammenfassen von Dokumenten gibt Claude Fable 5.1 mit höherer Wahrscheinlichkeit als Claude Fable 5 Passagen des Quelltexts wieder, ohne sie als Zitate zu kennzeichnen. Um dem zu begegnen, füge dem System-Prompt ein vollständiges Beispiel einer korrekten Antwort hinzu: die Anfrage des Nutzers, die Antwort und einen Satz, der erklärt, warum die Antwort korrekt ist.

```text wrap
<example>
<user>look up how the Riverton Ledger and the Coast Dispatch each covered the Harbor Bridge closure and compare their reporting</user>
<response>
[web_search: Harbor Bridge closure Riverton Ledger]
[web_search: Harbor Bridge closure Coast Dispatch]
Both outlets agree on the basics: the bridge closed on March 3 after inspectors found cracked welds, and the state expects repairs to take about eight months. Where they differ is emphasis. The Ledger treats it as a local-economy story. The Dispatch frames it as a funding failure; its editorial calls the closure "entirely foreseeable." Read together, the Ledger explains who is affected now and the Dispatch explains how it came to this — neither account alone gives the whole picture.
</response>
<rationale>CORRECT: The response is organized around where the two outlets agree and differ, not as a walk through either article. Each outlet's reporting is conveyed in one or two sentences of the assistant's own indirect speech. One short marked phrase from one source; every other claim is reworded. The response is still specific and complete.</rationale>
</example>
```

Ersetze die beiden `[web_search: ...]`-Zeilen durch den Namen deines eigenen Tools, damit das Modell sie als Tool-Ausgabe nach Vorlage liest und nicht als wörtlichen Text, den es ausgeben soll.

## Die ganze Aufgabe abschließen

Claude Fable 5.1 kann sehr lange Aufgaben ohne viel Anleitung zur Methodik ausführen, besonders wenn das Ziel klar ist. Bei komplexen asynchronen Workloads solltest du es jedoch anstoßen, seinen Turn nicht zu beenden, bevor die Arbeit erledigt ist. Ohne den Anstoß beschreibt das Modell manchmal, was es als Nächstes tun würde, statt es zu tun („Als Nächstes werde ich …“), oder hält an, um für einen Schritt um Erlaubnis zu bitten, den die ursprüngliche Anfrage bereits abdeckte („Soll ich das anwenden?“). Nutzer müssen „weiter“ oder „mach weiter“ antworten, was zu Pair Programming und anderer Human-in-the-Loop-Arbeit passt, aber nicht die volle Langzeithorizont-Fähigkeit des Modells nutzt.

Zwei Ergänzungen des System-Prompts mildern dies gemeinsam. Wende beide an. Wenn du die Prompt-Länge begrenzen musst, verwende nur die erste, die den größten Teil der Wirkung behält. Die erste sagt dem Modell, nicht nach bereits angeforderter Arbeit zu fragen und die nächsten Schritte, die es genannt hat, auszuführen:

```text wrap
You are operating autonomously. The user is not watching in real time and cannot answer questions mid-task, so asking 'Want me to…?' or 'Shall I…?' will block the work. For reversible actions that follow from the original request, proceed without asking. Stop only for destructive actions or genuine scope changes the user must decide. Offering follow-ups after the task is done is fine; asking permission before doing the work is not.

Exception: when the user is describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment. Report your findings and stop. Don't apply a fix until they ask for one.

Before ending your turn, check your last paragraph. If it is a plan, an analysis, a question, a list of next steps, or a promise about work you have not done ('I'll…', 'let me know when…'), do that work now with tool calls. That includes retrying after errors and gathering missing information yourself. Do not stop because the context or session is long. End your turn only when the task is complete or you are blocked on input only the user can provide.

Before running a command that changes system state (such as restarts, deletes, or config edits), check that the evidence actually supports that specific action. A signal that pattern-matches to a known failure may have a different cause.
```

Der Eröffnungssatz, der dem Modell sagt, dass der Nutzer nicht zusieht, trägt einen Großteil der Wirkung. Behalte ihn wie geschrieben bei. Wenn dein Produkt erfordert, dass das Modell für bestimmte Bestätigungen anhält, füge danach einen Satz hinzu, der sie auflistet. Dieser Block kann das Modell auch weniger geneigt machen, bei mehrdeutigen Anfragen nachzufragen, prüfe diesen Kompromiss also an deinen eigenen Aufgaben.

Die zweite definiert die Anfrage des Nutzers als den Umfang des Ergebnisses:

```text wrap
# Delivering work
The user's request — or the plan they approved — sets the scope, and the scope is the deliverable: don't quietly narrow, widen, or swap it. Read ambiguity the way a careful colleague would: make routine judgment calls yourself, and check in only when different readings would lead to materially different work. If you see a real problem with the task as specified, say so in a sentence or two and keep building under stated assumptions; if the user hears the concern and reaffirms, that is their decision, so deliver the full request.

If a question comes up partway, first do everything that doesn't depend on the answer; then state the assumption you made, or — when going ahead on a wrong guess would be unsafe or would make the work useless — put the question at the end of a turn that also delivers that progress. If one part turns out to be blocked, complete every other part in full and say exactly what you left out and why — the whole task is the deliverable, and scaling it down is the user's call, not yours. A step you have decided on is something to run, not to announce: describing the next step and ending the turn leaves it undone until the user replies.

Keep changes to what the request needs. Something else you notice worth doing — cleanup or documentation the task didn't call for, a change to a file the task didn't require — is a suggestion to make at the end, not a change to make; actions clearly beyond what the ask implies, and risky or destructive ones, still need the user's go-ahead.
```

## Dem Modell sagen, was es in Compaction-Zusammenfassungen bewahren soll

Claude Fable 5.1 reagiert gut darauf, wenn ihm explizit gesagt wird, was seine Zusammenfassung beibehalten muss, wenn ein langes Gespräch komprimiert wird. Serverseitige [Compaction](https://platform.claude.com/docs/de/build-with-claude/compaction) tut dies bereits. Wenn du clientseitig komprimierst, verwende die folgende Zusammenfassungsanweisung:

```text wrap
Summarize the transcript inside <summary></summary> tags. Include relevant information in the summary such that this conversation will be continued by a new context window without needing to redo work or be reprovided with relevant constraints or context. Be sure to preserve: (1) any difficulties or problems that came up, and how they were handled or resolved; (2) any possibilities, options, or approaches that were raised, tried, or set aside, and why; (3) anything that was asked for, decided, agreed, ruled out, or established as a preference, constraint, or boundary — stated exactly; (4) exactly where things stand now — what has been covered, settled, or completed so far; (5) anything still open, unresolved, promised, or expected to happen next; (6) specific details that would be hard to reconstruct — names, numbers, dates, exact wording, links or references — kept exactly. Be complete on these even at the cost of length; keep everything else concise. Weight the two voices differently: keep what the user said, asked for, shared, or established carefully and close to their own words; your own explanations and reasoning can be condensed much further, to what they concluded or produced — as long as nothing in the six items above is dropped.
```

## Änderungen und Tests auf das beschränken, was die Aufgabe verlangt

Wenn Claude Fable 5.1 gebeten wird, ein offen formuliertes Feature zu implementieren, liefert es das Verlangte und manchmal mehr: Es korrigiert möglicherweise benachbarten Code, erweitert Verhalten, das die Aufgabe nicht erwähnte, oder committet mehr Testdateien, als die Änderung rechtfertigt. Es reagiert gut auf explizite Anweisungen dazu, was wegzulassen ist. Mit der folgenden Anweisung gehen nicht angeforderte Ergänzungen und committeter Testcode deutlich zurück, ohne messbare Änderung beim Aufgabenerfolg:

```text wrap
If, while working or testing, you find a pre-existing bug, a performance concern, or behavior the task doesn't mention, don't fix, optimize or extend it in this change unless the requested behavior cannot work without it; report it as a follow-up in your summary. Where the task is ambiguous, implement the reading its wording and the surrounding code most directly support, state that assumption in your summary, and don't build for the other readings as well. Verify your work however you like; scratch scripts and quick checks need not be kept. Commit tests only where the task asks for them or this repository already keeps tests for this kind of change, sized like the neighboring test files — roughly one focused test per stated behavior — and don't turn scratch checks into additional permanent test files. This is about extras only: implement every behavior the task asks for, completely.
```

## Auslösen von Suchen bei niedrigem Effort

Bei `low`-Effort ruft Claude Fable 5.1 mit geringerer Wahrscheinlichkeit als Claude Fable 5 ein Such- oder Retrieval-Tool auf und antwortet mit höherer Wahrscheinlichkeit aus dem Gedächtnis. In manchen Fällen ist die einfachste Lösung, den Effort für die betroffenen Turns statt für das ganze Gespräch zu erhöhen. Siehe [Effort mitten im Gespräch ändern](https://platform.claude.com/docs/de/build-with-claude/effort#changing-effort-mid-conversation).

In anderen Fällen hilft ein Prompt-Anstoß in Richtung Verifizierung. Sage im System-Prompt, dass das Wiedererkennen eines Namens nicht dasselbe ist wie das Kennen seines aktuellen Zustands, und dass solche Namen so gesucht werden sollten, wie der Nutzer sie geschrieben hat:

```text wrap
When a query centers on a name you do not confidently recognize, or recognize from a fast-moving area like AI models and developer tools where the landscape shifts within months, the name itself is the thing to verify: search before answering, and include the name as the user wrote it in at least one query alongside any reformulations. This holds even when you have some background on it — partial background is exactly what makes an out-of-date answer sound authoritative, so familiarity is not a reason to skip the search.
```

## Fehlalarme der Schutzmaßnahmen reduzieren

Die Sicherheitsklassifikatoren von Claude Fable 5.1 erzeugen weniger „false positives“ (Fehlalarme) als die von Claude Fable 5 beim Launch, und das Finden von Schwachstellen in Quellcode ist erlaubt. Fehlalarme treten weiterhin auf, und eine blockierte Anfrage gibt `stop_reason: "refusal"` zurück (siehe [Ablehnungen, Fallback und Abrechnung](https://platform.claude.com/docs/de/models/fable-5-1/whats-new-fable-5-1#refusals-fallback-and-billing)). Drei Situationen machen sie wahrscheinlicher:

* **Formulierungen zur Kompilierprüfung:** Frage statt „Kompiliert dieses Programm ohne Fehler?“ lieber „Gibt es Bugs in diesem Programm?“
* **Weniger bekannte Programmiersprachen:** Gib dem Modell Kontext dazu, was die Sprache ist und wie sie funktioniert, zum Beispiel indem du ihm Zugriff auf die Dokumentation der Sprache gibst.
* **Base64 in Tool-Ausgaben:** Tools, die base64-kodierte Daten in den Kontext des Modells zurückgeben, können Fehlalarme auslösen, daher ist ihr Entfernen die empfohlene Lösung.

## Gezielte Bearbeitungen statt Neuschreiben ganzer Dateien bevorzugen

Wenn Claude Fable 5.1 für kleine Änderungen ganze Dateien neu schreibt, hänge die folgende Anweisung an den System-Prompt oder die erste User-Nachricht an. Claude Fable 5.1 schreibt mit höherer Wahrscheinlichkeit als Claude Fable 5 eine ganze Textdatei neu, statt eine gezielte Bearbeitung vorzunehmen. Die resultierende Datei ist normalerweise dieselbe, aber sofern die Datei nicht kurz ist oder sich der Großteil davon ändert, kostet ein Neuschreiben mehr Output-Token und Zeit. Die Anweisung bringt Claude Fable 5.1 für kleine und mittlere Änderungen wieder auf eine Linie mit Claude Fable 5.

```text wrap
The number of tokens used to edit files is best minimized, all else being equal. Therefore, when it will not affect the end result, try to surgically edit a file rather than rewrite the entire thing.
```

## Platz für lange Ausgaben bei xhigh- und max-Effort lassen

Bei `xhigh`- und besonders `max`-Effort kann Claude Fable 5.1 länger nachdenken, bevor es mit dem Schreiben seiner Antwort beginnt. Wenn eine einzelne Anfrage ein langes Ergebnis verlangt, etwa eine vollständige Neufassung eines langen Dokuments, entwirft es möglicherweise einen Großteil dieses Ergebnisses in seinem Nachdenken und schreibt es dann als Antwort erneut aus, was eine längere Wartezeit und mehr Output-Token bedeutet. Der einfachste Ansatz ist, solche Anfragen bei `high`, dem empfohlenen Ausgangspunkt, auszuführen und nur dort zu `xhigh` oder `max` zu wechseln, wo du einen Qualitätsgewinn gemessen hast (siehe [Alle Effort-Stufen in Betracht ziehen](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels)). Wenn du sie doch bei `xhigh` oder `max` ausführst:

* Setze `max_tokens` so, dass Platz für das Nachdenken und die Antwort bleibt, nicht nur für die Antwortlänge, die du erwartest.
* Hänge den folgenden Hinweis an das Ende der User-Nachricht an. Er macht das Nachdenken bei Prosa- und Code-Anfragen deutlich kürzer. Ersetze `[max_tokens]` durch den tatsächlichen `max_tokens`-Wert der Anfrage, zum Beispiel 64.000.

```text wrap
Everything produced in one reply, including any reasoning or drafting done before the reply, counts toward a single limit of about [max_tokens] tokens. If that limit is reached before the reply is finished, the person receives a cut-off response and has to start over. Composing an entire output or deliverable in full as reasoning and then again as a reply would double the length of the turn without improving the result, so don't do that.

Instead, when the person has asked for a long or effort-intensive deliverable such as a multi-section document, a large table or dataset, or a complete code file, spend extra effort on understanding the request, checking the inputs the answer depends on, settling the structure and other difficult decisions, and otherwise using the reasoning space to reason and the output space to write an output. Usually it is not needed to draft an output multiple times.
```

## Den leitenden Agenten weiterarbeiten lassen, während Subagenten laufen

Wenn dein Coding-Agent Claude Fable 5.1 Arbeit an „subagents“ (Subagenten) delegieren lässt, zwinge den leitenden Agenten nicht, anzuhalten und auf jeden einzelnen zu warten. Bei Coding-Aufgaben senkt es die durchschnittliche Zeit bis zum Abschluss bei ähnlicher Qualität, Token-Nutzung und Kosten, wenn der leitende Agent weiterarbeitet, während Subagenten laufen. So richtest du das ein:

* Lass das Tool, das einen Subagenten startet, sofort zurückkehren.
* Gib das Ergebnis jedes Subagenten in einer späteren `user`-Nachricht an den leitenden Agenten zurück, sobald es bereit ist.
* Gib dem leitenden Agenten ein separates Tool, das er aufrufen kann, wenn er auf ein Ergebnis warten möchte.

Das Modell entscheidet sich trotzdem oft zu warten. Die Zeitersparnis kommt aus den Durchläufen, in denen es mit anderer Arbeit weitermacht.

## Vision-Arbeit Tools zum Zuschneiden und Zoomen geben

Claude Fable 5.1 hat von Haus aus bessere Vision-Fähigkeiten, und bei komplexen visuellen Eingaben wie dichten Diagrammen leistet es seine beste Arbeit, wenn es iterativ analysieren, zuschneiden und visuell verifizieren kann, was es sieht. Um den vollen Nutzen zu erhalten, betreibe das Modell als Agenten mit Zugriff auf einen Container, der die Rohbilder oder -videos enthält und in dem grundlegende Bildverarbeitungsbibliotheken (wie PIL und OpenCV) vorinstalliert sind. Wenn der Betrieb eines Containers zu viel Overhead ist, liefert ein Bildzuschneide-Tool allein den größten Teil der Verbesserung: Ein Tool, das einen gewählten Bereich des Bildes zugeschnitten und vergrößert zurückgibt, lässt das Modell bestimmte Details eingehender untersuchen und skaliert Test-Time-Compute mit Bild-Token. Das [Crop-Tool-Rezept](https://platform.claude.com/cookbook/multimodal-crop-tool) enthält eine funktionierende Definition.