# Leitfaden zur Konfiguration von Adaptive Thinking

**Adaptive Thinking** ist der Reasoning-Modus der nächsten Generation in der Claude-4.6/4.7/4.8-Familie: Das Modell entscheidet selbst, wann sich Reasoning lohnt und wie viele Tokens es dafür einsetzt – ein vom Entwickler vorab festgelegtes Budget gibt es nicht. Über den Parameter `effort` steuern Sie die Reasoning-Tiefe grob. Dieser Leitfaden behandelt die zugehörige API-Nutzung, die Modell-Support-Matrix sowie den Kompromiss zwischen Qualität und Kosten.

> **Zur 5er-Familie**: Die täglichen Standardmodelle bleiben `claude-sonnet-5` / `claude-opus-5` (4.x wird weiterhin angeboten). Die folgende Parametermatrix wurde an Claude 4.6 / 4.7 / 4.8 gemessen. Ob die `thinking`- / `effort`-Werte der 5er-Serie exakt mit der Tabelle übereinstimmen, wurde in diesem Durchgang **nicht unabhängig überprüft** – übertragen Sie daher Schlussfolgerungen, die nur für 4.x gelten (zum Beispiel, dass Opus 4.8 `budget_tokens` ablehnt, oder die Stufen `xhigh` / `max`), **nicht** auf die 5er-Familie. Zur Modellauswahl in der 5er-Serie siehe [Modellauswahl](/docs/usage/model-selection).

## Die wichtigsten Unterschiede zum bisherigen Extended Thinking

| Dimension | Bisheriges Extended Thinking (4.5 und früher) | Adaptive Thinking (4.6 / 4.7 / 4.8) |
|-----------|--------------------------------------------|-------------------------------|
| Auslöser-Parameter | `thinking={"type": "enabled", "budget_tokens": N}` | `thinking={"type": "adaptive"}` |
| Budgetsteuerung | Fester Token-Höchstwert (`budget_tokens` muss kleiner als `max_tokens` sein) | Das Modell reguliert sich selbst, optional abgestimmt über `effort` |
| Verhalten über Tool-Aufrufe hinweg | Standardmäßig nicht verschachtelt (erfordert den Beta-Header `interleaved-thinking-2025-05-14`) | Automatisch verschachtelt (kein Beta-Header nötig) |
| Kompatibilität mit Opus 4.8 | ❌ **400-Fehler** (`budget_tokens` wurde entfernt) | ✅ Der einzige unterstützte Modus |
| Kompatibilität mit Sonnet 4.6 | ⚠️ veraltet (funktioniert noch, wird aber nicht empfohlen) | ✅ Empfohlen |

**Kurzregel**: Verwenden Sie `adaptive` für die Modellfamilie 4.6 / 4.7 / 4.8; setzen Sie `budget_tokens` nur für 4.5 und früher ein.

## Modell-Support-Matrix

| Modell | Adaptive Thinking | budget_tokens | Parameter effort |
|-------|-------------------|---------------|------------------|
| `claude-opus-4-8` | ✅ Einzige Möglichkeit zur Aktivierung | ❌ 400-Fehler | ✅ low / medium / high / xhigh / max |
| `claude-sonnet-4-6` | ✅ Empfohlen | ⚠️ Funktioniert noch, ist aber veraltet | ✅ low / medium / high |
| `claude-opus-4-7` | ✅ Empfohlen | ⚠️ Funktioniert noch, ist aber veraltet | ✅ low / medium / high / max |
| `claude-haiku-4-5` | ✅ Unterstützt | ❌ Nicht unterstützt | ❌ Der Parameter effort führt zu einem Fehler |
| `claude-sonnet-4-5` und früher | ❌ Nicht unterstützt | ✅ Hierfür verwenden | ❌ |

> Beim Zugriff über das QCode.cc-Gateway sind alle oben genannten Modelle verfügbar (praktisch verifiziert).

## Der Parameter effort: Ein grober Regler für die Reasoning-Tiefe

`effort` steuert die Gesamtintensität von Adaptive Thinking (das umfasst Thinking-Tokens, die Anzahl der Tool-Aufrufe und die Gründlichkeit der Antwort).

| effort | Geeignet für | Ungefährer Kostenfaktor |
|--------|----------|------------------------------|
| `low` | Einfache Fragen und Antworten, Sub-Agents, latenzkritische Pfade | 1× |
| `medium` | Alltägliches Coding, Dokumentationsrecherche (die meisten Alltagsaufgaben) | 1.5-2× |
| `high` | Komplexes Reasoning, Refactoring über mehrere Dateien (**Standard**) | 2-3× |
| `xhigh` | Langfristige Agent-Workflows (exklusiv für Opus 4.8, Standard in Claude Code) | 3-4× |
| `max` | Maximale Qualität, Kosten zweitrangig (nur Opus 4.8 / 4.7) | 5× |

**Faustregel**: `high` ist für die meisten interaktiven Coding-Aufgaben der optimale Kompromiss; `xhigh` bietet bei langen Agent-Schleifen (z. B. mehrstufiges Code-Review, Deep Research) das beste Preis-Leistungs-Verhältnis; `max` lohnt sich nur, wenn Korrektheit deutlich wichtiger ist als Kosten (z. B. Codegenerierung für die Produktion, kritische Architekturentscheidungen).
## API-Nutzungsbeispiele

### Python (anthropic SDK)

```python
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.qcode.cc/api",
    api_key="cr_xxxxxxxx",
)

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "Refactor the authentication logic of the user service module..."}],
)

for block in response.content:
    if block.type == "thinking":
        print(f"[Thinking] {block.thinking}")
    elif block.type == "text":
        print(f"[Answer] {block.text}")
```

### TypeScript (@anthropic-ai/sdk)

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

const client = new Anthropic({
  baseURL: "https://api.qcode.cc/api",
  apiKey: "cr_xxxxxxxx",
});

const response = await client.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 16000,
  thinking: { type: "adaptive" },
  output_config: { effort: "xhigh" },
  messages: [{ role: "user", content: "Refactor user service..." }],
});
```

### Claude Code CLI

In der CLI wechseln Sie die effort-Stufe mit der `Tab`-Taste; die aktuelle effort-Stufe wird in der Statusleiste angezeigt. Opus 4.8 verwendet standardmäßig `xhigh` — wechseln Sie manuell auf `medium`, um Tokens zu sparen.

## Darstellung von Thinking-Inhalten

Opus 4.8 zeigt **standardmäßig keinen Thinking-Text** an (`thinking.display: "omitted"`); das Schlussfolgern erfolgt ausschließlich intern. Um den Thinking-Trace in Ihrer UI sichtbar zu machen:

```python
thinking={"type": "adaptive", "display": "summarized"}
```

`display: "summarized"` weist das Modell an, eine Thinking-Zusammenfassung auszugeben (sichtbare Thinking-Blöcke); `omitted` zählt die Thinking-Tokens, ohne sichtbaren Text zu erzeugen. Sonnet 4.6 / Haiku 4.5 verwenden standardmäßig `summarized`.

## Task-Budgets (Opus 4.8 Beta)

Wenn Sie einen Agent-Loop ausführen und eine globale Obergrenze für den gesamten Turn möchten (die Thinking + Tools + finale Ausgabe abdeckt), verwenden Sie `task_budget`:

```python
response = client.beta.messages.create(
    betas=["task-budgets-2026-03-13"],
    model="claude-opus-4-8",
    max_tokens=64000,
    thinking={"type": "adaptive"},
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[...],
)
```

Das Modell sieht einen Countdown des verbleibenden Budgets und reguliert sich selbst, um eine Überschreitung zu vermeiden. Der Mindestwert für `total` beträgt 20.000.

## Tipps zur Kostenobservabilität

Sobald adaptive Thinking aktiviert ist, steigen sowohl Input- als auch Output-Tokens tendenziell; beobachten Sie dies entsprechend:

```python
print(response.usage)
# Watch: input_tokens, output_tokens, cache_read_input_tokens
# Adaptive thinking does not bill thinking tokens separately — they roll into output_tokens
```

Für QCode.cc-Nutzer werden Anfragen an [probe.qcode.cc](https://probe.qcode.cc) gemeldet — dort können Sie das Verhältnis von Input / Output / Thinking pro Anfrage einsehen.

## FAQ

### Wie wechsle ich von budget_tokens zu adaptivem Thinking?

Es gibt keine lineare Umrechnung. `budget_tokens=8000` entspricht keiner bestimmten effort-Stufe. Beginnen Sie mit `effort: "medium"` und passen Sie den Wert anhand der Antwortqualität und des Tokenverbrauchs an. Wenn Sie eine harte Obergrenze durchsetzen müssen, verwenden Sie `task_budget` (siehe oben).

### Meine Anfrage an Opus 4.8 gibt 400 zurück und meldet, dass budget_tokens nicht erlaubt ist

Ersetzen Sie jedes `thinking={"type": "enabled", "budget_tokens": N}` durch `thinking={"type": "adaptive"}`. Das Feld `budget_tokens` wurde in Opus 4.8 vollständig entfernt (jeder Wert führt zu 400).

### Sollte ich budget_tokens in Sonnet 4.6 weiterhin verwenden?

Nicht empfohlen. Verwenden Sie adaptives Thinking für gesamten neuen Code. `budget_tokens` funktioniert in 4.6 noch, befindet sich jedoch auf einem veralteten Pfad und wird in einer zukünftigen Version entfernt.

### Wie ändere ich die effort-Stufe in der Claude Code CLI?

Wechseln Sie die in der CLI-Statusleiste angezeigte effort-Stufe mit `Tab`; der gespeicherte Standardwert befindet sich im Feld `"effort"` in `~/.claude/settings.json`.

## Nächste Schritte

- [Modellauswahl-Handreichung](/docs/usage/model-selection) — Preis- und Funktionsvergleich über alle Modelle
- [Bewährte Praktiken](/docs/usage/best-practices) — Prompting-Techniken für große Kontexte und Agent-Workflows
- [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) — Vollständige Referenz für die Ingress-Domains von QCode.cc
- [Claude Code Tutorial](/docs/getting-started/claude-code-tutorial) — Vollständige Funktionsreferenz der CLI