> For the complete documentation index, see [llms.txt](https://docs.kontinent.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.kontinent.ai/documentation/dokumentation/features/reasoning.md).

# Reasoning

Reasoning-Modelle denken, bevor sie antworten. Jeder Anbieter schreibt das anders: OpenAI nimmt ein Stärke-Wort, Anthropic ein Token-Budget, Google eine verschachtelte Thinking-Konfiguration. Kontinent nimmt **eine** Form und übersetzt sie.

```json
{
  "model": "bedrock/claude-sonnet-5",
  "messages": [{ "role": "user", "content": "Ist 9,11 größer als 9,9?" }],
  "reasoning": { "effort": "high" }
}
```

| Feld         | Typ                                              | Bedeutung                                                                                                                                 |
| ------------ | ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `effort`     | `"minimal"` \| `"low"` \| `"medium"` \| `"high"` | Wie intensiv gedacht wird. Bei budgetbasierten Modellen wird daraus ein Anteil von `max_tokens` (high ≈ 80 %, medium ≈ 50 %, low ≈ 20 %). |
| `max_tokens` | Ganzzahl                                         | Ein exaktes Denk-Budget, für Modelle, die eines akzeptieren. Begrenzt auf 1024–128000.                                                    |
| `exclude`    | Boolean                                          | Trotzdem denken, die Gedanken aber nicht zurückgeben.                                                                                     |
| `enabled`    | Boolean                                          | `false` schaltet das Denken ab, wo das Modell es zulässt.                                                                                 |

Der ältere Boolean `include_reasoning: true` wird weiterhin akzeptiert und bedeutet `reasoning: { enabled: true }`.

{% hint style="info" %}
**Bei budgetbasierten Modellen** (Claude, über Bedrock und Vertex) werden `reasoning.max_tokens` und `max_tokens` gemeinsam aufgelöst: das Budget wird auf 1024–128000 begrenzt, und über ihm bleiben immer mindestens 1024 Tokens für die Antwort. Ist Ihr `max_tokens` zu klein für beides, wird zuerst das Budget gekürzt — Ihre Obergrenze bleibt, wo sie kann, unangetastet.

Geminis Denk-Budget wird unverändert weitergegeben, weil Google eigene Grenzen pro Modell hat und selbst durchsetzt. Bei effortbasierten Modellen (Azure) hat `reasoning.max_tokens` kein Gegenstück und wird ignoriert.
{% endhint %}

## Welche Modelle denken

`GET /v1/models` sagt es zweifach: in der flachen Liste `supported_parameters`, die jedes Modell trägt, und — bei denkenden Modellen — in einem `reasoning`-Objekt mit den Details. Bei Modellen ohne Reasoning fehlt das Objekt ganz, und `reasoning` fehlt in der Liste.

```json
{
  "id": "bedrock/claude-sonnet-5",
  "supported_parameters": ["max_tokens", "temperature", "top_p", "stop", "stream", "tools", "tool_choice", "reasoning", "include_reasoning"],
  "reasoning": {
    "supported_efforts": ["low", "medium", "high"],
    "default_effort": "medium",
    "supports_max_tokens": true,
    "mandatory": false
  }
}
```

`mandatory: true` heisst: der Upstream lässt sich das Denken nicht abschalten (Azures GPT-5-Familie, Gemini 2.5 Pro). Bei diesen Modellen wird `enabled: false` ignoriert statt mit einem Fehler beantwortet.

## Die Gedanken lesen

Jede Antwort trägt das Denken zweimal, mit Absicht:

* `reasoning` — ein einfacher String, den Sie aneinanderhängen und ausgeben können.
* `reasoning_details[]` — die strukturierte Form. Genau die schicken Sie zurück, um ein denkendes Gespräch fortzusetzen.

Ohne Streaming:

```json
{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "Nein — 9,9 ist größer.",
      "reasoning": "Zehntel vergleichen: 0,11 gegen 0,9…",
      "reasoning_details": [{
        "type": "reasoning.text",
        "text": "Zehntel vergleichen: 0,11 gegen 0,9…",
        "signature": "EqoBCkgIA…",
        "format": "anthropic-claude-v1",
        "index": 0
      }]
    }
  }]
}
```

Mit Streaming — das Denken kommt vor der Antwort, im selben `delta`, das ein Client schon liest:

```
data: {"choices":[{"delta":{"role":"assistant","reasoning":"Zehntel ","reasoning_details":[{"type":"reasoning.text","text":"Zehntel ","index":0}]}}]}

data: {"choices":[{"delta":{"reasoning":"vergleichen…","reasoning_details":[{"type":"reasoning.text","text":"vergleichen…","index":0}]}}]}

data: {"choices":[{"delta":{"reasoning_details":[{"type":"reasoning.text","signature":"EqoBCkgIA…","index":0}]}}]}

data: {"choices":[{"delta":{"content":"Nein — 9,9 ist größer."}}]}

data: {"choices":[],"usage":{"prompt_tokens":19,"completion_tokens":214,"total_tokens":233}}

data: [DONE]
```

### Detail-Typen

| `type`                | Enthält                   | Anmerkung                                                                                      |
| --------------------- | ------------------------- | ---------------------------------------------------------------------------------------------- |
| `reasoning.text`      | `text`, teils `signature` | Die Gedankenkette. Die Signatur ist ein Integritätsnachweis — behalten Sie sie.                |
| `reasoning.summary`   | `summary`                 | Eine vom Anbieter geschriebene Zusammenfassung, für Modelle, die ihre Gedanken nie offenlegen. |
| `reasoning.encrypted` | `data`                    | Denken, das existiert und nicht gelesen werden darf. **Nie** mit Klartext daneben.             |

## Verschlüsseltes Denken

Manche Modelle — vor allem Azures GPT-5- und o-Serie — denken und geben nur einen opaken Block zurück. Kontinent weist ihn als `reasoning.encrypted` ohne `text` aus.

```json
{ "type": "reasoning.encrypted", "data": "gAAAAAB…", "format": "openai-responses-v1", "index": 0 }
```

Das ist Absicht: wir erfinden keine lesbaren Gedanken für ein Modell, das keine geliefert hat — und wir werfen den Block auch nicht still weg, denn ohne ihn kann das Modell im nächsten Zug nicht auf seinem eigenen Denken aufbauen.

## Ein denkendes Gespräch fortsetzen

Schicken Sie den Assistant-Zug mit seinen `reasoning_details` zurück:

```json
{
  "model": "bedrock/claude-sonnet-5",
  "reasoning": { "effort": "high" },
  "messages": [
    { "role": "user", "content": "Ist 9,11 größer als 9,9?" },
    {
      "role": "assistant",
      "content": "Nein — 9,9 ist größer.",
      "reasoning_details": [{ "type": "reasoning.text", "text": "Zehntel vergleichen…", "signature": "EqoBCkgIA…", "format": "anthropic-claude-v1", "index": 0 }]
    },
    { "role": "user", "content": "Und 9,11 gegen 9,099?" }
  ]
}
```

Details gehen an Anbieter, die sie prüfen können, und werden bei allen anderen verworfen — eine Anthropic-Signatur bedeutet einem OpenAI-Deployment nichts, und sie mitzuschicken wäre ein Fehler statt einer Fortsetzung. Unsigniertes Denken wird ebenfalls verworfen: Claude lehnt Gedanken ab, die es sich nicht selbst zuordnen kann, ein Wiedereinspielen würde also die Anfrage scheitern lassen.

## Die Gedanken verbergen

`exclude: true` lässt das Modell denken und entfernt das Denken aus der Antwort.

```json
{ "reasoning": { "effort": "high", "exclude": true } }
```

### Sie zählen

Wo ein Anbieter den Denk-Anteil des Outputs ausweist, steht er in `usage.completion_tokens_details.reasoning_tokens`. Tut er es nicht, **fehlt** das Feld statt auf null zu stehen — Anthropic zählt das Denken innerhalb von `output_tokens` und trennt es nie ab, und eine Null würde behaupten, das Modell habe nicht gedacht.

{% hint style="warning" %}
Denk-Tokens werden abgerechnet, ob Sie sie lesen oder nicht — es sind Output-Tokens, die das Modell erzeugt hat. `exclude` betrifft Ihre Oberfläche, nicht die Kosten.
{% endhint %}

## Verwandt

{% content-ref url="/pages/ATkspY0HIzjnjThOkwf8" %}
[Streaming](/documentation/dokumentation/features/streaming.md)
{% endcontent-ref %}

{% content-ref url="/pages/1U0JLQ6A6ZWMnoz8dGsI" %}
[API-Referenz](/documentation/dokumentation/reference/api-reference.md)
{% endcontent-ref %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.kontinent.ai/documentation/dokumentation/features/reasoning.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.