claude-regelwerk/AI/Regelwerk/haiku-5-5.md

---
type: resource
title: "Arbeiten mit Claude Haiku 5.5"
status: pending-review
summary: "Haiku 5.5 als Abschrift-Executer, Quorum-Ersatzstimme, Verbrauchsablesung und Sitzungsmodell: Effort je Rolle nach Messung vom 2026-10-09, Prüfpunkte, offene Entscheidungen, Verhalten und Prompt-Muster, Spezifikation und API-Brüche."
tags: [regelwerk, modelle, haiku, prompting]
created: 2026-10-09
updated: 2026-10-17
source: "https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5"
---

# Arbeiten mit Claude Haiku 5.5

> **Geltungsbereich — zuerst lesen.**
> - Diese Datei gilt für **Claude Haiku 5.5** (`claude-haiku-5-5`). Läufst du selbst als Haiku 5.5, ob als Hauptsitzung oder als Subagent, sind Teil A und Teil B deine Arbeitsweise.
> - Schreibt ein Koordinator einen Auftrag an einen Haiku-Subagenten, nimmt er Teil A. Für Fable 5.1 als Koordinator ist das verbindlich, Opus 5.5 entscheidet selbst.
> - Die Rollentabelle im Stamm ([[CLAUDE|Claude.md]], „Agenten & Modelle") nennt Haiku 5.5 für Abschrift, Quorum-Ersatz, die Verbrauchsablesung (`verbrauch-ableser`) und die Haiku-Sitzung (A5); die Zuordnung der übrigen Rollen ändert sich nicht. Haiku 4.5 beschreibt [[AI/Regelwerk/sonnet-5|sonnet-5.md]], C3.
> - Angeordnet von Pascal am 2026-10-09. Quellen: Anthropic-Doku (Rohtext am 2026-10-09 per curl abgerufen), Modellkatalog und Systemprompt-Bausteine im Programmabbild von Claude Code 2.1.296 (gelesen, nicht gelaufen), die Transkripte des Vaults und eine eigene Messung (A3). Wo die Doku eine Bedingung nennt, steht sie hier mit.

## Wozu diese Datei

Seit dem 2026-10-07 läuft alles, was im Vault `haiku` heißt, auf Haiku 5.5 — ohne dass eine Agentendatei geändert wurde. Haiku 5.5 kennt Effort, Haiku 4.5 nicht; mehrere Regeln und Workflows gehen noch vom alten Modell aus. Die Tabelle führt vom Symptom zum Abschnitt.

| Beobachtung | Abschnitt |
|---|---|
| Unklar, mit welchem Effort ein Haiku-Agent läuft oder laufen soll | A1, A2 |
| Die Ablesung in `verbrauch` lief bis 2026-10-17 mit `max` | A1, A7 |
| Task mit `modell: haiku` und typografischen Zeichen | A3, A4 |
| Pascal startet eine Sitzung auf Haiku | A5 |
| Haiku-Executer meldet „fertig" ohne echte Prüfung | B3 |
| Haiku hört bei langem Agent-Auftrag früh auf und gibt die Aufgabe zurück | A4, B2 |
| Antwort aus dem Gedächtnis statt Suche | B4 |
| Werkzeugaufruf fehlt bei JSON-Ausgabe ohne Thinking | B5 |
| Nutzernachricht mitten im Zug wird übergangen | B6 |
| Denktext steht in der sichtbaren Antwort | B7 |
| Chatbot gibt bei Drängen nach | B8 |
| `stop_reason: "refusal"`, kein Ausweichmodell | B9 |
| 400 bei `budget_tokens`, `temperature`, Prefill oder geändertem Verlauf | C2 |
| Nach dem Wechsel von Opus auf Haiku fehlt das frühere Denken | A5, C4 |

Zwei Sorten von Punkten sind gemischt: Manche greifen **in dieser Claude-Code-Sitzung oder bei Subagenten** (Kennung „Sitzung"), andere erst, **wenn wir selbst gegen die Claude-API bauen** (Kennung „API-Integration").

# Teil A — Was im Vault gilt

## A1 Wo Haiku 5.5 im Vault läuft

- Der Alias `haiku` löst im Katalog von Claude Code 2.1.296 auf der Anthropic-API auf `claude-haiku-5-5` auf. Auf Bedrock, Vertex, Foundry, Mantle, `anthropic_aws`, `anthropic_google_cloud` und Gateway löst er weiter auf `claude-haiku-4-5` auf.
- In den Transkripten des Vaults steht der erste Haiku-5.5-Eintrag am 2026-10-07 um 20:55 UTC (CLI 2.1.293), der letzte Haiku-4.5-Eintrag am selben Tag um 11:58 UTC (CLI 2.1.292).
- Haiku 5.5 ist das erste Haiku mit Effort. Ein Effort aus dem Frontmatter einer Agentendatei oder aus der Sitzung kommt jetzt beim Modell an. Bei Haiku 4.5 fehlte das Feld `effort` im Transkript (2026-09-23), und der Katalog führt dort keine Effort-Fähigkeit.

| Rolle | Gestartet von | Effort, der ankommt | Beleg |
|---|---|---|---|
| `executer` bei `modell: haiku` (Abschrift) | `executer-welle`, `agentType: executer`, ohne `effort` | `medium` aus dem Frontmatter des Executers | Transkripte 2026-10-09; Messung A3 |
| Task mit `modell: haiku` und eigenem `effort:` | `executer-welle` | trotzdem `medium`: `effortFuer()` verwirft den Task-Effort und loggt ihn als „wirkungslos" | `.claude/workflows/executer-welle.js` |
| `quorum-stimme` als Ersatz für Codex | `quorum`, `agentType: quorum-stimme`, ohne `effort` | `high` aus dem Frontmatter | Messung A3 |
| Ablesung in `verbrauch` | `verbrauch.js`, `agentType: verbrauch-ableser`, ohne `effort` | `low` aus dem Frontmatter; bis 2026-10-17 ohne `agentType` der Effort der aufrufenden Sitzung, am 2026-10-09 `max` oder `xhigh` | Echtläufe 2026-10-17 (`wf_1901f51f-dd3`, `wf_4d8a69f9-51a`); Transkripte 2026-10-09 |
| Hauptsitzung | Modellwahl in der App | Sitzungseinstellung, Standard `medium` | Transkripte 2026-10-09; Katalog |

## A2 Effort je Rolle

| Rolle | Effort | Grund |
|---|---|---|
| `executer`, Abschrift | `medium` (Frontmatter, unverändert) | Messung: `low`, `medium` und `high` gleich treu, je Lauf 0,008–0,009 $; `low` sparte keine Ausgabe. Doku: `medium` ist der Start für agentisches Coding; auf `low` hört Haiku in langen Agent-Prompts eher früh auf, auf `low` und `medium` meldet es Änderungen teils ohne Prüfung als fertig (B2, B3). |
| `quorum-stimme`, Ersatz | `high` (Frontmatter, unverändert) | Messung: 9 von 9 auf jeder Stufe; `high` brachte je Lauf zwei berechtigte Zusatzfunde, `low` einen, bei höchstens 0,010 $ je Lauf. Doku: `high` für strenges Befolgen von Anweisungen. |
| Ablesung in `verbrauch` | `low` (Frontmatter von `verbrauch-ableser`, seit 2026-10-17) | Feste Ablesung ohne Urteil; Doku: `low` für kurze Werkzeugaufgaben. Echtlauf 2026-10-17: vier von vier Ablesungen richtig, je drei Werkzeugaufrufe, Werte gleich der eigenen Ablesung. |
| Hauptsitzung | `medium` (Standard) | Doku: Startpunkt für die meiste Arbeit; `xhigh` und `max` nur mit Gewinn in eigenen Evals, dann auch Sonnet 5.5 vergleichen. Nicht gemessen. |

## A3 Messung vom 2026-10-09

Aufbau: Workflows in Claude Code 2.1.293 (laut Transkript), je Lauf ein Subagent mit `agentType` und `model` wie im echten Einsatz; „Standard" heißt ohne `effort`-Parameter, also Frontmatter. Effort und Modell je Lauf aus dem Transkript belegt. Abschrift und Quorum: Prüfstände vom 2026-09-23; Typografie: neuer Prüfstand vom 2026-10-09.

**Abschrift** — Task mit deutschen Anführungszeichen im Docstring, der Escape-Folge für U+2028 und einem Prüf-grep, der den Docstring trifft; Byte-Vergleich mit `cmp`:

| Einstellung | Läufe | Ende byte-gleich | „ “ erhalten | Widerspruch gemeldet | Ausgabetokens (Median) | Kosten je Lauf | Dauer |
|---|---|---|---|---|---|---|---|
| Haiku 5.5, Standard (`medium`) | 2 | 2 von 2 | 2 von 2 | 2 von 2 | 1.781 | 0,008 $ | 40–42 s |
| Haiku 5.5, `low` | 2 | 2 von 2 | 2 von 2 | 2 von 2 | 2.244 | 0,008–0,009 $ | 29–52 s |
| Haiku 5.5, `high` | 2 | 2 von 2 (ein Lauf erzeugte die Testdatei per awk aus der Taskdatei) | 2 von 2 | 2 von 2 | 2.279 | 0,008 $ | 41–50 s |
| Sonnet 5.5, Standard (`medium`), Gegenprobe | 2 | 2 von 2 | 2 von 2 | 2 von 2 | 1.413 | 0,105–0,130 $ | 31–33 s |

**Quorum-Stimme** — neun eingebaute Fehler gegen eine SPEC, als echtes Prüfpaket mit `quorum_werkzeug.py` gebaut, Auftrag wortgleich mit `quorum.js`; ein Sonnet-Richter glich blind ab und prüfte jedes Zitat:

| Einstellung | Läufe | Schlüssel mit Zitat | Zusatzfunde je Lauf | Fehlalarme | Ausgabetokens (Median) | Kosten je Lauf | Dauer |
|---|---|---|---|---|---|---|---|
| Haiku 5.5, `low` | 2 | 9 von 9 | 1 und 1 | 0 | 4.072 | 0,004–0,007 $ | 18–20 s |
| Haiku 5.5, `medium` | 2 | 9 von 9 | 2 und 1 | 0 | 6.055 | 0,004–0,008 $ | 26–30 s |
| Haiku 5.5, Standard (`high`) | 2 | 9 von 9 | 2 und 2 | 0 | 8.321 | 0,005–0,010 $ | 35–40 s |
| Sonnet 5.5, Standard (`high`) | 2 | 9 von 9 | 2 und 2 | 0 | 3.411 | 0,042–0,125 $ | 24–27 s |

**Typografie** — zweiter Abschrift-Task mit allen elf Zeichen der früheren Ausnahme („ “ ” ‚ ‘ ’ « » – — …), 47 Vorkommen in Docstring, Kommentar, Zeichenketten und Testerwartungen; Byte-Vergleich mit `cmp`:

| Einstellung | Läufe | Ende byte-gleich | Ausgabetokens (Median) | Kosten je Lauf | Dauer |
|---|---|---|---|---|---|
| Haiku 5.5, Standard (`medium`) | 4 | 4 von 4 | 1.425 | 0,005–0,009 $ | 21–53 s |
| Haiku 5.5, `low` | 2 | 2 von 2 | 1.258 | 0,005–0,006 $ | 16–19 s |

Alle sechs schrieben per Write, und jede Write-Eingabe war schon beim ersten Mal richtig. Ein Lauf (Standard) legte die Hilfsdatei `_blocks.txt` neben der Taskdatei an, also außerhalb seines Laufordners, nannte sie im Bericht und löschte sie; derselbe Lauf versuchte per awk zwei Dateien weit außerhalb des Arbeitsbaums zu schreiben, die nicht entstanden und die er nicht meldete. Auf diese Messung hin hat Pascal am 2026-10-09 die Ausnahme für Haiku 5.5 aufgehoben ([[AI/Regelwerk/codeworkflow|codeworkflow.md]], Schritt 3).

Was beim Abschrift- und beim Quorum-Prüfstand auffiel:

- **Write-Weg:** In 5 von 6 Haiku-Läufen stand die Escape-Folge schon in der Eingabe des Write-Aufrufs als echtes Zeichen; ob das Modell oder die Harness-Schicht es erzeugte, zeigt das Transkript nicht. Alle fünf fanden es selbst per Bytesuche und setzten die Folge zurück, und alle fünf nennen dabei die Harness-Erinnerung zu Unicode-Escapes.
- **Bash-Weg:** Ein Haiku-Lauf und beide Sonnet-Läufe schrieben per Heredoc. Dort kam die Escape-Folge richtig an, aber in der Testdatei gingen zuerst Backslashes verloren (3 von 3), sichtbar als SyntaxWarning bei grünen Tests.
- Haiku 4.5 ersetzte am 2026-09-23 im selben Task U+201C in 2 von 2 Läufen still durch ein gerades Zeichen. Haiku 5.5 hat „ und “ in 6 von 6 Läufen erhalten.
- **Verbotene Hilfsdateien:** Ein Haiku-Lauf (`low`) legte zwei Skripte kurz außerhalb seines Laufordners ab, meldete das und löschte sie. Ein zweiter (`high`) legte drei Hilfsdateien im Laufordner an und löschte sie wieder, ohne es zu melden.
- **Kosten:** Haiku 5.5 kostete beim Executer etwa ein Fünfzehntel, bei der Quorum-Stimme (Standard gegen Standard) etwa ein Elftel von Sonnet 5.5; die Kosten streuen mit den Cache-Treffern. Haiku 4.5 kostete im selben Abschrift-Task am 2026-09-23 0,076 $ je Lauf (Median).

Was die Messung nicht belegt:

- Alle drei Prüfstände sind klein: ein Modul mit 73 Zeilen (Quorum), eines mit 25 Zeilen (Abschrift), eines mit 39 Zeilen Code und 18 Zeilen Tests (Typografie).
- Beim Quorum fanden alle acht Läufe alle neun Fehler. Der Prüfstand trennt die Stufen deshalb nicht, nur über Zusatzfunde und Kosten.
- Die Selbstkorrektur ist kein Vorsprung von Haiku: Sonnet 5.5 war unter denselben Bedingungen ebenso byte-treu. Dass alle fünf betroffenen Haiku-Läufe die Harness-Erinnerung nennen, spricht dafür, dass sie die Korrektur auslöste; bewiesen ist das nicht.
- Der Vergleich mit Haiku 4.5 ist kein kontrollierter Versuch: anderer Tag, eine andere Fassung der Escape-Erinnerung im Index und weitere Erinnerungen zum Byte-Vergleich. Die Erinnerung selbst stand auch am 2026-09-23 im Kontext.
- Typografisch gemessen sind zwei kleine Tasks. Lange Aufträge, in denen ein Executer viel Text abschreibt, sind nicht gemessen.
- Lange Tasks mit vielen Dateien, Ermessen und langer Agentenschleife sind nicht gemessen — genau dort nennt die Doku frühes Aufhören auf `low` (B2).
- Hauptsitzung und `verbrauch`-Ablesung sind nicht gemessen.

Rohwerte je Lauf: [[AI/secondbrain/regelwerk-memory/2026-10-09-haiku-5-5-messung|Messbericht Haiku 5.5]].

## A4 Aufträge an Haiku-Subagenten

- **Executer bei `modell: haiku`:** Die Vorlage aus [[AI/Regelwerk/sonnet-5-5|sonnet-5-5.md]], A2, gilt. Ihr Stoppsatz deckt nur die zweite Hälfte des Doku-Mittels aus B2 (aufhören, wenn erledigt und geprüft; keine Zusatzarbeit), ihr Prüfbefehl mit Erwartung den Doku-Absatz aus B3.
- **Bei langen Haiku-Aufträgen** (viele Dateien, lange Werkzeugschleife) kommt die erste Hälfte als eigene Zeile dazu: „Arbeite weiter, bis alles Beauftragte erledigt ist; frag nur, wenn es ohne den Auftraggeber nicht weitergeht, oder vor einem riskanten Schritt."
- **Wann Haiku statt Sonnet:** das Kriterium „Abschrift, nicht Autorschaft" aus [[AI/Regelwerk/codeworkflow|codeworkflow.md]], Schritt 3. Typografische Zeichen sind für Haiku 5.5 kein Grund mehr für Sonnet; die Regel steht dort.
- **Quorum-Ersatz:** Der Auftrag steht fest in `quorum.js`; zu formulieren ist nichts.
- **Agent ohne `agentType`:** bekommt `model` und `effort` (Stamm). Bei Haiku 4.5 war ein fehlender Effort folgenlos, bei Haiku 5.5 erbt der Agent den Effort der Sitzung.

## A5 Haiku 5.5 als Sitzungsmodell (Sitzung)

- **Wofür eine Haiku-Sitzung da ist (Pascals Entscheidung vom 2026-10-09):** Fragen und Nachschlagen. Vor Planen, Gegenprüfen, Committen oder Arbeit an Produktivsystemen wechselt die Sitzung auf Opus 5.5 — oder du sagst Pascal, dass der nächste Schritt das verlangt. Grund: Die Rollentabelle weist Klären, Entscheiden und Committen dem Koordinator auf Opus 5.5 zu.
- **Subagenten aus einer Haiku-Sitzung:** zum Nachschlagen etwa `recherche` mit `model: sonnet` — jeder Subagent bekommt `model` ausdrücklich, sonst erbt er Haiku. `planer` und `pruefer` startet erst die Sitzung nach dem Wechsel auf Opus.
- **Effort-Erbe:** Ein Agent ohne `effort:` erbt den Effort der Haiku-Sitzung, Standard `medium`.
- **Wofür Anthropic Haiku 5.5 baut:** „high-volume, latency-sensitive work such as classification, routing, extraction, and subagent tasks" (What's new). Eine Messung für Vault-Sitzungen gibt es nicht.
- **Was Claude Code selbst einfügt:** Claude Code 2.1.296 baut für Haiku 5.5 einen eigenen Absatz in den Systemprompt (Abschnitt `heron_brook`, Fähigkeit `haiku_5_5_early_stopping_guidance`, Schalter `tengu_idempotent_wolf`, im Programm mit an vorbelegt). Ein ferngesteuert gesetzter Ersatztext für denselben Abschnitt hat Vorrang. Was in Pascals Konto gilt und ob Subagenten den Absatz bekommen, ist nicht beobachtet. Kurz gefasst sagt er:
  - Der Effort steuert das Denken, nicht den Umfang; eine große Aufgabe ist kein Grund, vorher nachzufragen. Der Zug endet, wenn der Auftrag erledigt ist oder ohne den Nutzer nichts mehr geht.
  - Vorher fragen nur, wenn die wahrscheinlichste Lesart nicht benennbar ist oder die Aufgabe an einem Fakt, einer Datei oder einem Zugang hängt, den nur der Nutzer hat. Sonst handeln und die gewählte Lesart in der Schlussnachricht nennen. Die Zustimmung zu einer Wahl, die das Modell selbst treffen kann, ist kein Grund zu fragen.
  - Schwer umkehrbare und nach außen wirkende Schritte brauchen weiter die Bestätigung. Will der Nutzer etwas vorher freigeben, etwa einen Plan, dort anhalten; eine reine Reihenfolge wie „erst planen, dann bauen" ist kein Haltepunkt. Eine Frage oder ein offenes Abwägen will eine Antwort, keine Änderung; ist zusätzlich Arbeit verlangt, erst antworten, dann arbeiten.
  - Dateiänderungen im Arbeitsbaum gelten nicht als schwer umkehrbar, solange sie keine laufenden Änderungen des Nutzers überschreiben. Offene Entscheidungen trifft das Modell selbst und listet sie in der Schlussnachricht.
  - Ist ein Teil blockiert, den Rest fertig machen und die Schlussnachricht mit dem Blockierten beginnen; einen vermutlich scheiternden Schritt erst versuchen. Das Projekt bau- und testfähig machen, etwa deklarierte Abhängigkeiten installieren, zählt zur Arbeit.
- **Wo der Absatz auf Vault-Regeln trifft:**

| Der Absatz sagt | Im Vault gilt |
|---|---|
| Zustimmung zu einer Wahl, die das Modell selbst treffen kann, ist kein Grund zu fragen | Jede Freigabe aus Stamm und Regelwerk bleibt Pflicht, etwa für Produktivsysteme, Push und Echtgeld |
| „Erst planen, dann bauen" ist kein Haltepunkt | Die Standardschleife aus [[AI/Regelwerk/codeworkflow|codeworkflow.md]] legt die Schritte fest; der Absatz ändert sie nicht |
| Deklarierte Abhängigkeiten installieren zählt zur Arbeit | `executer.md`: keine neuen Abhängigkeiten ohne Auftrag; im Zweifel entscheidet der Auftrag |

- **Der Stamm geht vor.** Jede Regel aus [[CLAUDE|Claude.md]] gilt unverändert, auch wo der eingefügte Absatz zum Weitermachen drängt.
- **Modellwechsel mitten in der Sitzung:** Laut Doku verwirft die API die Thinking-Blöcke von Opus 5, Opus 5.5, Sonnet 5.5 sowie den Fable- und Mythos-Modellen ohne Fehler, wenn Haiku 5.5 übernimmt. Wer von Opus auf Haiku wechselt, verliert das frühere Denken; sichtbarer Text und Werkzeugergebnisse bleiben. Umgekehrt lesen Opus 5.5 und Sonnet 5.5 auf der Claude-API und Google Cloud die Blöcke von Haiku 5.5. In Claude Code nicht beobachtet. Vor einem Wechsel auf Haiku wichtige Zwischenstände als Text oder Datei festhalten.
- **Das Sitzungsprotokoll** aus dem Stamm gilt für jedes Modell.

## A6 Prüfpunkte statt Garantie

| Fehlerquelle | Prüfpunkt |
|---|---|
| Executer weicht still ab | Byte-Vergleich Plan gegen Datei, Pflicht wie bei jedem Modell ([[AI/Regelwerk/codeworkflow|codeworkflow.md]], Schritt 4) |
| Escape-Folgen | Byte-Vergleich. Am 2026-10-09 stand die Escape-Folge über den Write-Weg in 5 von 5 Läufen zuerst als echtes Zeichen in der Werkzeugeingabe; sichtbar nur per Bytesuche. Beim Schreiben des Messberichts traf es auch den Koordinator auf Opus 5.5, im Write-Werkzeug wie im Bash-Heredoc |
| Backslashes | Über den Bash-Heredoc-Weg gingen sie in 3 von 3 Läufen (1 Haiku, 2 Sonnet) zuerst verloren; sichtbar als SyntaxWarning bei grünen Tests, also Testausgabe ganz lesen |
| Fertigmeldung ohne Prüfung | Prüfbefehl mit Erwartung im Auftrag; der Koordinator wiederholt ihn selbst (B3) |
| Frühes Aufhören bei langem Auftrag | Weiterarbeiten-Zeile aus A4 im Auftrag; offene Teile stehen im Bericht |
| Hilfsdateien trotz Verbot | Wieder gelöschte Dateien und gescheiterte Schreibversuche zeigt kein Vergleich danach, nur das Transkript; bei Verdacht dort die Werkzeugaufrufe lesen. Beide Prüfstände vom 2026-10-09 hatten je mindestens einen solchen Lauf (A3) |
| Effort geerbt statt gesetzt | Feld `effort` im Transkript; ein Agent ohne `agentType` bekommt `effort` |
| Ablehnung ohne Ausweichmodell | Bericht führt sie als abgelehnt, nicht umformulieren, bis es durchgeht ([[AI/Regelwerk/sonnet-5|sonnet-5.md]], B4, sinngemäß); B9 |
| Denken nach Modellwechsel verloren | Zwischenstände vor dem Wechsel auf Haiku als Text oder Datei (A5) |

## A7 Angenommen, Umsetzung offen

Pascal hat die Vorschläge am 2026-10-09 angenommen; umgesetzt werden sie als eigene Aufgabe, weil die Workflows Fall- und Mutantensuiten haben.

| Stelle | Befund | Umsetzung |
|---|---|---|
| `verbrauch.js`: Haiku-Ablesung ohne `effort` | lief mit dem Effort der Sitzung, am 2026-10-09 `max` | **Erledigt am 2026-10-17:** Der Ableser läuft als `agentType: verbrauch-ableser` mit `effort: low` im Frontmatter; die Grundlinie in `faelle_workflows.mjs` prüft Typ und fehlenden `effort`-Parameter |
| `executer-welle.js`: Task-Effort bei `haiku` verworfen, Logzeile „wirkungslos"; Kommentare „etwa low für Abschrift mit typografischen Zeichen" und „Haiku kennt keinen Effort" | stimmt seit Haiku 5.5 nicht mehr | Effort durchreichen wie bei Sonnet, Kommentar und Logzeile berichtigen; dieselbe Aufgabe |
| `plankritik.js`, Linse „abdeckung": verlangt für Abschrift mit typografischen Zeichen `modell sonnet` und `effort low` statt `haiku` | würde jeden Plan nach der neuen Regel in Schritt 3 als Fehler melden | Linsentext an die Entscheidung vom 2026-10-09 anpassen, Fälle der Plankritik mitziehen; dieselbe Aufgabe |
| Codex-Hilfsagenten im Quorum auf `sonnet` statt `haiku` (Kommentar in `quorum.js`) | Die Begründung beruht auf Haiku 4.5; die Ausnahme ist für Haiku 5.5 seit 2026-10-09 aufgehoben | Kommentar berichtigen; ob die Hilfsagenten auf `haiku` wechseln, gehört in dieselbe Aufgabe |

# Teil B — Verhalten und Prompt-Muster

Aus „Prompting Claude Haiku 5.5" (Rohtext 2026-10-09). Bestehende Haiku-4.5-Prompts laufen laut Doku ohne Änderung gut. Antwortlänge, Formatierung, Fortschrittsmeldungen, parallele Werkzeugaufrufe und Delegation behandelt die Seite nicht. Die Prompttexte der Doku stehen hier sinngemäß auf Deutsch; den Wortlaut hat die Doku im jeweiligen Abschnitt.

## B1 Effort und Thinking (Sitzung, API-Integration)

- `low`: billigste und schnellste Stufe; für Chat, kurze Werkzeugaufgaben und einfache Massenanfragen. In langen Agent-Prompts überspringt das Modell hier eher eine Suche, hört früh auf oder lässt eine Prüfung aus.
- `medium`: Standard; Start für die meiste Arbeit, auch für agentisches Coding.
- `high`: für Wissensarbeit, längere Agentenaufgaben und strenges Befolgen von Anweisungen.
- `xhigh` und `max`: nur, wenn eigene Evals einen Qualitätsgewinn zeigen. Denken und Antworten werden deutlich länger; dann laut Doku auch Sonnet 5.5 auf Leistung, Kosten und Tempo vergleichen.
- Thinking ist standardmäßig an und zählt zu `max_tokens` (bis 128.000). Wer weniger Denken will, senkt den Effort; die Anweisung im Prompt, direkt zu antworten, stoppte das Denken in Anthropics Tests nicht.
- Sitzung: Claude Code lässt Thinking für Haiku 5.5 nicht abschalten (Katalog `rejects_disabled_thinking`, Meldung „Thinking can't be turned off" im Abbild 2.1.296; gelesen, nicht gelaufen).
- API-Integration: `thinking: {"type": "disabled"}` geht nur bei `low`, `medium` und `high`, bei `xhigh` und `max` kommt 400.
- API-Integration: Auf `xhigh` schreibt das Modell in mehrstufigen Chats manchmal die ganze Antwort ins Thinking und endet ohne sichtbaren Text. Jede Antwort auf Leere prüfen.
- API-Integration: Ein geänderter Effort zwischen Anfragen entwertet den Prompt-Cache der Nachrichten. Ein Effort-Wechsel je Nachricht (Beta, Claude-API und Google Cloud, Header `mid-conversation-output-config-2026-07-01`, nur mit adaptivem Thinking) behält ihn.

## B2 Frühes Aufhören und Zusatzarbeit (Sitzung)

- Mit kurzem Systemprompt hört Haiku 5.5 selten zu früh auf. Mit langem Coding-Agent-Systemprompt auf `low` gibt es die Aufgabe manchmal früh an den Nutzer zurück.
- Gegenmittel laut Doku, sinngemäß im Systemprompt, zwei Teile: (1) weiterarbeiten, bis alles Verlangte erledigt ist, und nur fragen, wenn es ohne den Nutzer nicht weitergeht oder vor einem riskanten Schritt; (2) ist die Arbeit erledigt und geprüft, aufhören und berichten, keine ungefragten Features, Doku oder Refactorings, Vorschläge ans Ende.
- Im Vault deckt der Stoppsatz der Executer-Vorlage ([[AI/Regelwerk/sonnet-5-5|sonnet-5-5.md]], A2) nur Teil (2). Die gleichlautende Regel in `.claude/agents/executer.md` steht im Abschnitt zu Sonnet 5.5; für Haiku trägt also die Vorlage. Teil (1) steht für lange Haiku-Aufträge in A4. Für die Hauptsitzung fügt Claude Code einen eigenen Absatz ein (A5).
- Höherer Effort hilft ebenfalls: Ohne den Text halbierte der Schritt von `low` auf `medium` das frühe Aufhören etwa und mehr als verdoppelte die Ausgabetokens je Versuch (Anthropics Tests).
- API-Integration: Neue Systemprompt-Texte nur in neuen Gesprächen ergänzen. Ein Gespräch, das mit geändertem `system` Thinking-Blöcke zurückschickt, kann mit 400 scheitern. Mitten im Gespräch gehört eine neue Anweisung in den neuesten Zug oder, auf Claude-API, Bedrock und Google Cloud, in eine System-Nachricht.

## B3 Änderungen echt prüfen (Sitzung)

- Auf `low` und `medium` meldet Haiku 5.5 eine Codeänderung manchmal als erledigt, ohne eine Prüfung gefahren zu haben.
- Gegenmittel laut Doku, sinngemäß im Systemprompt: Nach einer lauffähigen Codeänderung eine echte Prüfung fahren, die die Änderung ausübt — Tests, Typprüfung, Build oder der geänderte Befehl selbst. Eine reine Syntaxprüfung oder ein Prüfbefehl, der nicht startete, zählt nicht. Fehlen nur die deklarierten Abhängigkeiten, sie mit Paketmanager und Lockfile des Projekts installieren, nie über `sudo` oder den Systempaketmanager, sofern nicht anders angewiesen. Geht keine echte Prüfung, sagen, welche nicht lief und warum, statt die Änderung als erledigt zu melden.
- In Anthropics Tests prüfte das Modell damit öfter und leistete mehr, bei mehr Tokens.
- Im Vault abgedeckt durch `executer.md` (Arbeitsweise Punkt 4) und den Prüfbefehl mit Erwartung im Auftrag. Den Satz „Syntaxprüfung zählt nicht" führt `executer.md` im Abschnitt zu Sonnet 5.5; für Haiku steht er dort nicht ausdrücklich.

## B4 Suche und Datum (Sitzung, API-Integration)

- Mit einem Suchwerkzeug das heutige Datum mitgeben, im Systemprompt oder in der Werkzeugbeschreibung. Das Datum einmal zu Gesprächsbeginn einsetzen und `system` und `tools` danach unverändert lassen; an einem späteren Tag das neue Datum im neuesten Zug nennen.
- Auf `low` und bei langen Systemprompts sucht Haiku 5.5 manchmal nicht. Gegenmittel laut Doku, sinngemäß direkt nach dem Datum: Das Training endet lange vor heute; Rekorde, Amtsinhaber, Preise, Versionen, Regeln und alles „Neueste" vor der Antwort suchen, auch wenn du dir sicher bist; Unveränderliches braucht keine Suche; hängt die Antwort vom Ort ab, Land oder Region in die Suchanfrage.
- Wirkung in Anthropics Tests: mehr Suchen bei Fragen mit veränderter Antwort, bei Fragen ohne Suchbedarf nur 0 bis 3 Prozent zusätzliche Suchen. Bei kurzem Systemprompt kann der Zusatztext entfallen; auf `medium` ließ dort schon das Datum allein das Modell öfter suchen.
- Pauschalsätze wie „bei jeder Gegenwartsfrage suchen, egal wie sicher" vermeiden: In Anthropics Tests suchte das Modell damit bei der Hälfte der Fragen ohne Bedarf, ohne mehr richtige Antworten.
- Im Vault: Der Suchsatz der Recherche-Vorlage ([[AI/Regelwerk/sonnet-5-5|sonnet-5-5.md]], A3) gilt auch, wenn ein Recherche-Auftrag auf Haiku läuft.

## B5 JSON-Ausgabe mit eigenen Werkzeugen (API-Integration)

- Mit abgeschaltetem Thinking und verlangtem JSON (Structured Outputs) überspringt Haiku 5.5 manchmal einen nötigen Werkzeugaufruf.
- Drei Wege laut Doku: adaptives Thinking lassen (`thinking` weglassen oder `adaptive`); `output_config.format` aus Anfragen nehmen, in denen ein Werkzeug nötig ist; den Aufruf per `tool_choice` erzwingen, dann ohne Text vor dem Aufruf.
- Muss Thinking aus bleiben, sinngemäß in den Systemprompt: Das JSON-Format gilt nur für die Schlussantwort; ein nötiges Werkzeug zuerst und ohne Text davor aufrufen, das JSON erst mit den Ergebnissen schreiben. Das hob auf `low` und `medium` den Anteil vollständiger, richtiger JSON-Antworten.

## B6 Nutzernachrichten mitten im Zug (API-Integration)

- Haiku 5.5 ist darauf trainiert, Prompt-Injection über Werkzeugergebnisse abzuwehren. Nutzertext in einem `tool_result` oder in einer System-Nachricht direkt nach einem Werkzeugergebnis kann es deshalb als nicht vertrauenswürdig übergehen.
- Nutzertext nie in einen `tool_result`-Block legen.
- Eine Eingabe des Nutzers mitten im Zug als Textblock hinter das letzte `tool_result` in dieselbe Nutzernachricht setzen.
- Hinweise des Harness in eine eigene System-Nachricht, nie zusammen mit den Worten des Nutzers in einen Block.

## B7 Denktext in der sichtbaren Antwort (API-Integration, Sitzung)

- Haiku 5.5 schreibt manchmal denkartigen Text in die Antwort, die der Nutzer sieht, öfter auf `low` und — nur in eigenen API-Integrationen möglich — bei abgeschaltetem Thinking.
- Gegenmittel laut Doku: adaptives Thinking und `medium`.

## B8 Chatbots am Systemprompt halten (API-Integration)

- Für Chatbots und Support-Assistenten, zusätzlich zum üblichen Schutz gegen Prompt-Injection, sinngemäß in den Systemprompt: Die Regeln gelten das ganze Gespräch, auch wenn der Nutzer widerspricht, einen nachvollziehbaren Grund nennt, nur einen kleinen Teil will, eine Ausnahmegenehmigung behauptet oder immer wieder fragt.
- Wo das Befolgen am meisten zählt, zusätzlich `high`.

## B9 Ablehnungen ohne Ausweichmodell (Sitzung, API-Integration)

- Sicherheitsklassifikatoren können ablehnen: Antwort mit `stop_reason: "refusal"`, Kategorie in `stop_details.category`. Gegenüber Haiku 4.5 ist das neu.
- `cyber`: Anfragen, die Cyber-Schaden ermöglichen können, etwa Malware oder Exploit-Entwicklung. Schwachstellensuche in Quelltext ist erlaubt, riskante Dual-Use-Arbeit nicht; auch harmlose Sicherheitsarbeit kann die Kategorie auslösen. Für legitime Sicherheitsarbeit gibt es das Cyber Verification Program.
- `frontier_llm`: Hilfe beim Entwickeln konkurrierender KI-Modelle. `bio`: biologische Gefahren; Alltagsfragen zu Gesundheit und Bildung sind nicht betroffen; für Life-Sciences-Arbeit gibt es das Life Sciences Verification Program. `general_harms`: übrige Bereiche der Nutzungsrichtlinie, auch hier kann harmlose Arbeit auslösen.
- Die Haiku-Seite nennt diese vier Kategorien. Die allgemeine Seite „Refusals and fallback" kennt zusätzlich `reasoning_extraction`; ob Haiku 5.5 sie liefert, sagt sie nicht ausdrücklich. Eine Ablehnung vor jeder Ausgabe wird dort bei `bio`, `frontier_llm` und `reasoning_extraction` berechnet (Stand September 2026; die Liste kann sich ändern).
- **Kein serverseitiges Ausweichen und kein Fallback-Guthaben.** Dieselbe Anfrage noch einmal an Haiku 5.5 bringt laut Doku meist wieder eine Ablehnung. API-Integration: clientseitig auf ein anderes Modell ausweichen, über die Refusal-Fallback-Middleware des SDK oder einen eigenen Retry. Ohne Fallback-Guthaben zahlt das Ausweichen das Cache-Schreiben des Ausweichmodells voll.
- Sonnet 5.5 weicht bei `cyber` und `frontier_llm` auf Sonnet 5 aus ([[AI/Regelwerk/sonnet-5-5|sonnet-5-5.md]], C3), Haiku 5.5 nicht. Für den Vault: Bei Tasks aus Härtungs-, Firewall- und Sicherheitsprojekten bringt `modell: haiku` keinen Ausweichweg. Lehnt ein Haiku-Executer ab, führt er das im Bericht als abgelehnt (A6).

# Teil C — Spezifikation und API

## C1 Spezifikation

| Punkt | Wert | Quelle |
|---|---|---|
| Modell-ID | `claude-haiku-5-5`; veröffentlicht 2026-10-07, Stilllegung nicht vor 2027-10-07 | Doku, Übersicht |
| Plattformen | Claude-API, Amazon Bedrock (`anthropic.claude-haiku-5-5`), Google Cloud, Microsoft Foundry, Claude Platform on AWS | Doku, Übersicht |
| Kontext / Ausgabe | 1M / 128k; Batch bis 300k mit Header `output-300k-2026-03-24` | Doku; Katalog 1M / 128k |
| Preis je Mio. Tokens, Prompt bis 100.000 Tokens | 0,10 $ Eingabe, 0,50 $ Ausgabe, 0,125 $ Cache-Schreiben 5 min, 0,20 $ Cache-Schreiben 1 h, 0,01 $ Cache-Lesen | Doku; Katalog `haiku_55` |
| Preis je Mio. Tokens, Prompt über 100.000 Tokens | 0,50 $, 2,50 $, 0,625 $, 1 $, 0,05 $ | Doku; Katalog `haiku_55` |
| Was als Promptlänge zählt | alle Eingabetokens einer Anfrage, auch Cache-Lesen und Cache-Schreiben; jede Anfrage wird einzeln eingestuft | Doku, Preise |
| Batch | 50 % Nachlass auf Eingabe und Ausgabe | Doku, Übersicht |
| Cache-Lesen | 10 % des Eingabepreises (Opus 5.5 und Sonnet 5.5: 5 %) | Doku, Übersicht |
| Cache-Mindestlänge | 512 Tokens (Haiku 4.5: 4.096) | Doku, What's new |
| Wissensstand | Juni 2026 | Doku; Katalog |
| Effort | alle fünf Stufen; Standard `medium` auf der API und in Claude Code | Doku; Katalog `default_effort` |
| Kostenfaktoren je Stufe | im Katalog nicht hinterlegt | Katalog |
| Latenz | „Fastest" in der Vergleichstabelle (Sonnet 5.5: „Fast") | Doku, Übersicht |
| Tokenizer | wie Claude 4.7 und später; derselbe Text etwa 30 % mehr Tokens als bei Haiku 4.5 | Doku, What's new |
| Bilder | hochauflösende Stufe; große Bilder kosten mehr visuelle Tokens als bei Haiku 4.5 (Rechenbeispiel der Doku: 2000 × 1500 px etwa das 2,5-Fache) | Doku, Migration |
| Priority Tier | nicht unterstützt | Doku, Migration |
| Fast Mode | nicht in der Liste der unterstützten Modelle (dort nur Opus) | Doku, Fast Mode |
| Datenhaltung | kein Covered Model: Die 30-Tage-Pflicht gilt nur für Fable 5.1, Mythos 5.1, Fable 5 und Mythos 5. Eine eigene Aussage zu Zero Data Retention für Haiku 5.5 gibt es nicht | Doku, API and data retention |
| Fähigkeiten im Katalog 2.1.296 | `effort`, `max_effort`, `xhigh_effort`, `adaptive_thinking`, `rejects_disabled_thinking`, `per_turn_effort`, `mid_conv_tool_change`, `context_management`, `lean_prompt`, `org_locked_thinking`, `haiku_5_5_early_stopping_guidance`; kein `refusal_fallback`, kein `mid_conv_system` | Katalog |
| Widersprüche Katalog gegen Doku | `rejects_disabled_thinking` gegen „`disabled` bis `high` erlaubt": Claude Code schaltet Thinking nicht ab, die Erlaubnis gilt nur für eigene API-Integrationen. Fehlendes `mid_conv_system` gegen die Doku, siehe C5 | Katalog; Doku |

## C2 Brüche und Änderungen gegenüber Haiku 4.5 (API-Integration)

Brüche mit 400:

- `thinking: {"type": "enabled", "budget_tokens": N}`. Ersatz: `thinking` weglassen oder `{"type": "adaptive"}`, gesteuert über den Effort.
- `temperature`, `top_p`, `top_k`: erlaubt sind nur `temperature` 1 und `top_p` 0,99. Jeder andere Wert liefert 400, auch `top_p` 1, jeder `top_k`-Wert und `temperature` zusammen mit `top_p`.
- Prefill, also eine abschließende Assistant-Nachricht, auch bei abgeschaltetem Thinking. `messages` endet mit einer Nutzernachricht.
- `computer_20250124` auf Claude-API und Google Cloud. Ersatz: `computer_toolset_20260801`.
- Thinking-Blöcke zurückschicken, nachdem `system`, `tools` oder frühere `messages` geändert wurden. Gespräche nur anhängen, nie ändern ([[AI/Regelwerk/api-mechanik|api-mechanik.md]]). Konten von vor dem 2026-08-31, 00:00 UTC, bekommen den Fehler nur mit gesetztem `thinking.block_binding.prefix_mismatch_behavior`.

Weitere Brüche, Fehlerbild in der Doku nicht genannt:

- `computer_20250124` nimmt Haiku 5.5 auch auf Bedrock nicht an. Ersatz dort: `computer_20251124` mit Header `computer-use-2025-11-24`.
- Structured Outputs gibt es für Haiku 5.5 auf Bedrock nicht; dort das Format im Prompt beschreiben oder ein Werkzeug ohne `strict` nutzen und die Ausgabe im Code prüfen.
- Ablehnungen über `stop_reason: "refusal"` sind neu (B9).
- Priority Tier fällt weg (C1).

Geändert:

- Eine Antwort kann mit Thinking-Blöcken beginnen; Inhaltsblöcke nach `type` wählen, nicht nach Position.
- Thinking-Text kommt standardmäßig leer zurück, nur mit Signatur; eine Zusammenfassung gibt es mit `"display": "summarized"`.
- Thinking zählt zu `max_tokens`. Ein kleines `max_tokens` aus Haiku-4.5-Zeiten kann nach dem Thinking-Block und vor jedem Text enden.
- Thinking-Blöcke aller früheren Züge bleiben im Kontext und zählen als Eingabe; Haiku 4.5 behielt nur die des letzten Zugs. Entfernen über Thinking Block Clearing.
- Thinking-Blöcke gelten nur im erzeugenden oder einem damit verknüpften Konto.
- Derselbe Text zählt etwa 30 % mehr Tokens, große Bilder mehr visuelle Tokens (C1): Prompts, `max_tokens` und Kostenschätzungen neu zählen.
- Context-Awareness-Tags werden nicht eingefügt; für ein Budget in Agentenschleifen gibt es Task Budgets (Beta, Header `task-budgets-2026-03-13`).

Neu: das Browser-Use-Werkzeug auf Claude-API und Google Cloud.

## C3 Unterschiede zu Sonnet 5.5 (API-Integration)

| Punkt | Haiku 5.5 | Sonnet 5.5 |
|---|---|---|
| Preis je Mio. Tokens | 0,10 $ / 0,50 $, über 100.000 Prompt-Tokens 0,50 $ / 2,50 $ | 2 $ / 10 $ |
| Cache-Lesen | 10 % des Eingabepreises | 5 % |
| Standard-Effort auf der API | `medium` | `high` |
| Thinking abschalten | `disabled` bis `high` erlaubt (nicht in Claude Code, C1) | `disabled` liefert 400 ([[AI/Regelwerk/sonnet-5-5|sonnet-5-5.md]], C2) |
| Erzwungene Werkzeugwahl (`tool_choice` `any` oder `tool`) | angenommen, die Antwort beginnt dann ohne Thinking-Block mit dem Aufruf | 400 |
| Serverseitiges Ausweichen bei Ablehnung | keins, auch kein Fallback-Guthaben | Sonnet 5 für `cyber` und `frontier_llm` |
| Latenz laut Vergleichstabelle | „Fastest" | „Fast" |
| Gleich | 1M / 128k, Wissensstand Juni 2026, Sampling-Grenzen, Prefill-Verbot, Ausgabe nur Text | |

## C4 Thinking-Blöcke zwischen Modellen (API-Integration, Sitzung)

- Haiku 5.5 liest die Thinking-Blöcke von Sonnet 5, Opus 4.8, Haiku 4.5 und älteren Modellen. Ein Gespräch, das von Haiku 4.5 auf Haiku 5.5 wechselt, behält sein Denken.
- Die Blöcke von Opus 5, Opus 5.5, Sonnet 5.5 und allen Fable- und Mythos-Modellen liest es nicht; die API verwirft sie ohne Fehler.
- Auf Claude-API und Google Cloud lesen Opus 5.5 und Sonnet 5.5 die Blöcke von Haiku 5.5.
- Folge für die Sitzung: A5, „Modellwechsel mitten in der Sitzung".

## C5 Weitere Funktionen

- Effort je Nachricht: Beta, Claude-API und Google Cloud, nicht Bedrock (B1).
- System-Nachrichten mitten im Gespräch: laut Doku auf Claude-API, Bedrock und Google Cloud. Der Katalog von Claude Code 2.1.296 führt für Haiku 5.5 aber kein `mid_conv_system`; welche Seite für Claude Code gilt, ist offen. Nutzertext gehört trotzdem in den Nutzerzug (B6).
- Werkzeugwechsel mitten im Gespräch: Beta auf denselben Modellen, auf der Claude-API mit Header `inline-tools-2026-09-15`. Für Änderungen, die ein Werkzeug per Referenz nennen, gilt der Header `mid-conversation-tool-changes-2026-07-01` auf Claude-API, Bedrock und Google Cloud.
- Task Budgets: Beta (C2).
- Computer Use nur über das Toolset (C2); dazu das Browser-Use-Werkzeug.

## Wohin die Punkte im Regelwerk zeigen

| Regelwerk-Datei | Verweist auf Abschnitt |
|---|---|
| [[CLAUDE|Claude.md]] (Rollentabelle, Regelwerk-Liste) | Gesamtdatei |
| [[AI/Regelwerk/codeworkflow|codeworkflow.md]] (Schritt 3, Quorum, Effort je Rolle) | A1, A3, A7 |
| [[AI/Regelwerk/sonnet-5|sonnet-5.md]] (C3, Haiku 4.5) | Gesamtdatei, A1 |
| [[AI/Regelwerk/fable-5-1|fable-5-1.md]] (Geltungsbereich) | Gesamtdatei |
| [[AI/Regelwerk/prompting|prompting.md]] (Geltungsbereich) | Gesamtdatei |
| `.claude/agents/planer.md` (Kriterium `modell:`, typografische Zeichen) | A3, A4 |

## Referenzen

- [[CLAUDE|↑ Claude.md (Stamm)]] — Rollentabelle
- [[AI/Regelwerk/codeworkflow|codeworkflow.md]] — Standardschleife, Modellzuordnung, Effort je Rolle, Quorum
- [[AI/Regelwerk/sonnet-5-5|sonnet-5-5.md]] — Auftragsvorlagen für Executer und Recherche
- [[AI/Regelwerk/sonnet-5|sonnet-5.md]] — Haiku 4.5 (C3), Cyber-Schutz (B4)
- [[AI/Regelwerk/opus-5|opus-5.md]] und [[AI/Regelwerk/fable-5-1|fable-5-1.md]] — die Schwestermodelle
- [[AI/Regelwerk/prompting|prompting.md]] — modellübergreifende Techniken
- [[AI/Regelwerk/api-mechanik|api-mechanik.md]] — Mechanik für eigene API-Integrationen
- [[AI/secondbrain/regelwerk-memory/2026-10-09-haiku-5-5-messung|Messbericht Haiku 5.5]] — Rohwerte der Messung
- Quellen (Rohtext abgerufen 2026-10-09): https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5, https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5, https://platform.claude.com/docs/en/models/haiku-5-5/overview, https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide, https://platform.claude.com/docs/en/build-with-claude/effort, https://platform.claude.com/docs/en/about-claude/pricing, https://platform.claude.com/docs/en/build-with-claude/refusals-and-fallback, https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages, https://platform.claude.com/docs/en/build-with-claude/task-budgets, https://platform.claude.com/docs/en/build-with-claude/fast-mode, https://platform.claude.com/docs/en/build-with-claude/thinking, https://platform.claude.com/docs/en/build-with-claude/context-windows, https://platform.claude.com/docs/en/build-with-claude/api-and-data-retention