---
title: "max_tokens для моделей с рассуждениями: расчёт бюджета"
description: "Почему модели с рассуждениями возвращают пустой ответ при низком max_tokens и как подобрать бюджет по перцентилям, контекстному окну и повтору с ростом лимита."
url: https://broadrouter.com/ru/blog/reasoning-model-max-tokens-budget/
lang: ru
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Переведено с английского с помощью ИИ. [Читать оригинал на английском](https://broadrouter.com/blog/reasoning-model-max-tokens-budget/) (обновлён 2026-11-15).

# max\_tokens для моделей с рассуждениями: как рассчитать бюджет

Команда BroadNet Inference · 6 мин чтения · Опубликовано 2026-11-15

У модели с рассуждениями max\_tokens ограничивает рассуждения и ответ вместе, поэтому тесный лимит может оборвать ответ раньше, чем появится видимый текст. Измерьте общее число выходных токенов по каждому типу задач, задайте max\_tokens около 95-го перцентиля плюс 20%, держите промпт вместе с max\_tokens в пределах контекстного окна и повторяйте оборванные ответы с удвоенным бюджетом до жёсткого потолка.

## Главное

-   max\_tokens — это потолок, а не плата. Вы платите за сгенерированные токены, так что щедрый потолок ничего не стоит на ответах, которые заканчиваются раньше.
-   Деньги стоит как раз тесный потолок: оборванный ответ оплачивается за рассуждения, не возвращает ответа и должен быть отправлен заново.
-   Задавайте бюджет по типу задач на основе своих логов: 95-й перцентиль выходных токенов плюс запас 20% — разумная отправная точка.
-   Токены промпта плюс max\_tokens должны помещаться в контекстное окно: 262 144 токена у Qwen3.8 27B, 1 048 576 у GLM 5.3 и DeepSeek V4.1 Flash.
-   Считайте finish\_reason «length» сигналом: повторяйте запрос с удвоенным бюджетом или более низким reasoning\_effort, с жёстким потолком.

**На этой странице**

1.  Почему бюджет заканчивается раньше ответа?
2.  Стоит ли больший max\_tokens дороже?
3.  Как измерить, сколько нужно задаче?
4.  Как контекстное окно ограничивает бюджет?
5.  Что делать, если ответ всё равно обрывается?
6.  Что меняет стриминг?
7.  Какое имя параметра отправлять?
8.  Где здесь BroadNet Inference

Модель с рассуждениями думает, прежде чем ответить, и в большинстве OpenAI-совместимых API рассуждения и ответ расходуют один бюджет — `max_tokens`. Задайте его так, как для модели без рассуждений, — несколько сотен токенов на короткий ответ, — и часть ответов придёт пустой с `finish_reason: "length"`. Быстрое исправление описано в руководстве [почему модель с рассуждениями возвращает пустой ответ](https://broadrouter.com/ru/guides/reasoning-tokens-empty-response/). А эта статья — о методе, который даёт бюджет, которому можно доверять: измерить, рассчитать по перцентилям, учесть контекстное окно и обработать ответы, которые всё-таки обрываются.

О том, сколько стоят рассуждения и как сократить расходы на них, читайте в статье [токены рассуждений: почему вы платите за больший вывод, чем видите](https://broadrouter.com/ru/blog/reasoning-tokens-cost/).

## Почему бюджет заканчивается раньше ответа?

Модель генерирует по порядку: сначала рассуждения, потом видимый ответ. Каждый токен и того и другого засчитывается в `max_tokens`. Документация BroadNet говорит об этом для DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B прямо: «the reasoning counts toward max\_tokens» (перевод: «рассуждения засчитываются в max\_tokens»), а при маленьком лимите «the answer comes back empty» (перевод: «ответ возвращается пустым»). Справочник OpenAI Chat Completions определяет `max_completion_tokens` так же — как верхнюю границу «including visible output tokens and reasoning tokens» (перевод: «включая видимые выходные токены и токены рассуждений»).

Поэтому правильный вопрос — не «какой длины мой ответ?», а «какой длины рассуждения и ответ вместе на этой задаче при этом уровне усилий?» Разброс тут больше, чем обычно ожидают. Руководство OpenAI говорит, что её модели могут генерировать «anywhere from a few hundred to tens of thousands of reasoning tokens» (перевод: «от нескольких сотен до десятков тысяч токенов рассуждений») в зависимости от задачи.

## Стоит ли больший max\_tokens дороже?

Нет. И это самая частая причина, по которой бюджеты ставят слишком тесными. [`max_tokens`](https://broadrouter.com/ru/glossary/max-tokens/) — это потолок. Вы платите за реально сгенерированные токены. Ответ, которому нужно 1800 токенов, стоит одинаково при потолке 4000 и 40 000.

А вот чего стоит тесный потолок:

| Потолок и потребность | Что вы платите | Что получаете |
| --- | --- | --- |
| Потолок выше потребности | Сгенерированные токены | Ответ |
| Потолок ниже потребности | Весь потолок, целиком на рассуждения | Ничего полезного, плюс повторный запрос |

Возьмём пример. Допустим, четверти ваших вызовов нужно больше 1000 токенов. При `max_tokens=1000` каждый такой вызов оплачивает 1000 выходных токенов рассуждений, ничего не возвращает и повторяется. Это в среднем 250 впустую потраченных выходных токенов на каждый вызов по всем вызовам — ещё до самих повторов, плюс задержка второго запроса. При потолке 4000 ничего не теряется. На [Qwen3.8 27B](https://broadrouter.com/ru/models/qwen3.8-27b/) выход стоит $2.17 за 1 млн токенов, так что на объёме потери накапливаются.

Настоящий риск высокого потолка — неуправляемый ответ: модель зацикливается или слишком долго думает и генерирует гораздо больше нужного. Жёсткий потолок это ограничивает. Выбирайте его по данным, как описано ниже.

## Как измерить, сколько нужно задаче?

Прогоните реальные промпты одного типа задач со щедрым потолком и запишите число выходных токенов и долю рассуждений. Если модель её сообщает, `usage.completion_tokens_details.reasoning_tokens` даёт часть, ушедшую на рассуждения; это поле есть в документации BroadNet.

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
```

Правила, чтобы получить число, которому можно доверять:

1.  **Один тип задач на прогон.** У классификации, извлечения данных, ревью кода и планирования очень разные распределения. Единый глобальный `max_tokens` либо тратит деньги на повторы, либо пропускает неуправляемые ответы.
2.  **50 и больше реальных промптов.** 95-й перцентиль из десяти замеров — это просто самый большой из них.
3.  **Прогоните на каждом уровне усилий, который используете.** `reasoning_effort="low"` меняет распределение. BroadNet документирует `low`; другие значения проверьте, прежде чем на них полагаться.
4.  **Если `cut_off` не ноль, поднимите потолок и прогоните заново.** Оборванный замер скрывает свою истинную длину.
5.  **Перезапускайте при смене модели или промпта.** Новая версия модели может думать больше или меньше.

Затем задайте `max_tokens` для каждой задачи по `recommend()`. 95-й перцентиль плюс 20% оставляет большинство вызовов заметно ниже потолка и отправляет на описанный ниже путь повтора лишь редкие длинные ответы. Бесплатный [калькулятор бюджета токенов рассуждений](https://broadrouter.com/tools/reasoning-token-budget/) проделает эту арифметику в браузере, когда у вас будут свои цифры.

## Как контекстное окно ограничивает бюджет?

Контекстное окно вмещает промпт и ответ вместе. Прайс-фид BroadNet определяет `context_length` как «the most tokens one request can hold, prompt and answer together» (перевод: «наибольшее число токенов, которое вмещает один запрос, промпт и ответ вместе»). Отсюда:

**max\_tokens ≤ длина контекста − токены промпта**

| Модель | Контекст | Место для max\_tokens при промпте в 200 000 токенов |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/ru/models/glm-5.3/) | 1 048 576 | 848 576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/ru/models/deepseek-v4.1-flash/) | 1 048 576 | 848 576 |
| Qwen3.8 27B | 262 144 | 62 144 |

Это важно для работы с длинным контекстом. У агента, чья история на Qwen3.8 27B разрослась до 250 000 токенов, остаётся всего около 12 000 токенов на рассуждения и ответ. Задачи с длинным контекстом к тому же обычно требуют больше рассуждений, так что проверяйте остаток места в момент вызова, а не один раз при старте. Подробности — в статье о [контекстном окне](https://broadrouter.com/ru/glossary/context-window/) и в [калькуляторе контекстного окна](https://broadrouter.com/tools/context-window-calculator/).

## Что делать, если ответ всё равно обрывается?

Проверяйте `finish_reason` в каждом вызове. Если он равен `length`, ответа нет или он неполный, даже если в `content` есть какой-то текст. Не разбирайте его как завершённый: обрезанный JSON-объект — частый источник ошибок дальше по цепочке ([структурированный вывод](https://broadrouter.com/ru/blog/structured-output-json-schema/)).

Повторяйте с удвоенным бюджетом в пределах места, которое оставляет контекст, до жёсткого потолка:

```python
import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt
```

Две альтернативы удвоению, в зависимости от задачи:

-   **Повторите с `reasoning_effort="low"`** при том же бюджете. На простых задачах модель часто слишком много думает, и меньшее усилие решает проблему без увеличения потолка.
-   **Разбейте задачу.** Если ответ раз за разом упирается в высокий потолок, запрос обычно требует слишком много за один раз.

Логируйте каждый обрыв вместе с типом задачи. Растущая доля обрывов означает, что изменились промпт, модель или входные данные, и бюджет нужно измерить заново. Повторы — это новые инференсы, и они оплачиваются снова, так что ограничивайте число попыток, как в статье [долгие агенты: таймауты и повторы](https://broadrouter.com/ru/blog/long-running-agents-timeouts-retries/).

## Что меняет стриминг?

С `stream=True` рассуждения идут до первого видимого токена, поэтому модель с рассуждениями в начале может казаться зависшей. В чат-интерфейсе показывайте состояние «думает», пока не придёт контент, и рассчитывайте клиентские таймауты с учётом времени на рассуждения, а не только на ответ.

Некоторые серверы стримят и сам текст рассуждений в отдельном поле. Его название не стандартизовано: собственный API DeepSeek использует `reasoning_content`, а vLLM переименовал поле из `reasoning_content` в `reasoning`, предупредив, что старый клиентский код «could silently read an empty» (перевод: «может молча читать пустое») поле. В документации BroadNet поле с текстом рассуждений не описано, так что не стройте на нём функции, не проверив сырой ответ своей модели. Если всё же читаете его, делайте это осторожно:

```python
for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
```

Usage в последнем чанке требует `stream_options={"include_usage": True}` — BroadNet это документирует. Больше о потоках — в [руководстве по стримингу](https://broadrouter.com/ru/guides/streaming-chat-completions/) и в статье [SSE простыми словами](https://broadrouter.com/ru/blog/llm-streaming-sse-explained/).

## Какое имя параметра отправлять?

| API | Параметр | Включает рассуждения |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens` (`max_tokens` устарел) | Да |
| OpenAI Responses | `max_output_tokens` | Да |
| BroadNet Inference (Chat Completions) | `max_tokens`, как в документации | Да |
| Серверы vLLM | `max_tokens`, плюс необязательный `thinking_token_budget` | Да |

Перенося код между провайдерами, отправляйте то имя, которое документирует провайдер, и одним тестовым вызовом убедитесь, что лимит действует. Молча проигнорированный лимит выглядит нормально, пока не придёт неуправляемый ответ. Остальные параметры, которые меняются при переезде, описаны в [чек-листе миграции](https://broadrouter.com/ru/blog/openai-compatible-api-migration-checklist/).

## Где здесь BroadNet Inference

Три модели BroadNet с рассуждениями сообщают токены рассуждений в `usage`, когда модель их предоставляет, так что описанное выше измерение работает как есть. Больше всего места дают DeepSeek V4.1 Flash и GLM 5.3 — 1 048 576 токенов контекста. У Qwen3.8 27B — 262 144. Если задаче рассуждения не нужны, [Gemma 4 VL 26B](https://broadrouter.com/ru/models/gemma-4-vl-26b/) не значится моделью с рассуждениями и вообще снимает вопрос бюджета. На фиксированном [тарифе DeepSeek V4.1 Flash](https://broadrouter.com/ru/guides/unlimited-llm-api-sessions/) за токены рассуждений не берётся плата за токен, но оборванные ответы всё равно стоят времени, так что то же планирование бюджета применимо и там. Отдельного лимита на рассуждения BroadNet не документирует; если он вам нужен, используйте провайдера или собственный сервер, который его предлагает.

Бесплатные инструменты по теме (на английском)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Бесплатные инструменты (на английском)](https://broadrouter.com/tools/)

## Термины в этой статье

[Токен (token)](https://broadrouter.com/ru/glossary/token/)

Токен — это единица текста, которую языковая модель читает и пишет: слово, часть слова, знак препинания или последовательность байтов, которую выдаёт токенизатор модели. LLM API считают, ограничивают и обычно тарифицируют использование в токенах.

[max\_tokens](https://broadrouter.com/ru/glossary/max-tokens/)

max\_tokens — это параметр LLM API, который задаёт максимальное число токенов, которое модель может сгенерировать в одном ответе. Когда генерация доходит до лимита, она останавливается, а ответ помечается как обрезанный, например значением finish\_reason "length".

[Токены рассуждений (reasoning tokens)](https://broadrouter.com/ru/glossary/reasoning-tokens/)

Токены рассуждений — это токены, которые модель с рассуждениями генерирует, чтобы проработать задачу, прежде чем написать видимый ответ. Обычно они оплачиваются как выходные токены, учитываются в лимите на ответ и в контекстном окне, а API может их скрывать или выдавать в сжатом виде.

[Входные и выходные токены (input and output tokens)](https://broadrouter.com/ru/glossary/input-and-output-tokens/)

Входные токены — это токены, которые языковая модель читает в запросе: системный промпт, история диалога, описания инструментов и изображения. Выходные токены — это токены, которые она генерирует в ответ, включая рассуждения. LLM API обычно тарифицируют их по отдельности, и выход, как правило, дороже.

[Контекстное окно (context window)](https://broadrouter.com/ru/glossary/context-window/)

Контекстное окно — это максимальное число токенов, с которым языковая модель может работать в одном запросе. В него входят промпт, история диалога, описания инструментов, изображения и сгенерированный ответ, включая токены рассуждений. Всё, что не помещается, приходится обрезать, сжимать в краткое изложение или делить на несколько запросов.

[Chat Completions API](https://broadrouter.com/ru/glossary/chat-completions-api/)

Chat Completions API — это HTTP-эндпоинт OpenAI, POST /v1/chat/completions, который принимает имя модели и список сообщений с ролями и возвращает следующее сообщение модели. Формат его запроса и ответа стал общим стандартом, который повторяют OpenAI-совместимые провайдеры и SDK.

[Вызов инструментов (tool calling)](https://broadrouter.com/ru/glossary/tool-calling/)

Вызов инструментов (function calling) — это функция LLM API, при которой модель возвращает структурированный запрос на выполнение функции, заданной разработчиком, с аргументами в JSON. Приложение выполняет функцию и отправляет результат обратно; сама модель код никогда не выполняет.

[vLLM](https://broadrouter.com/ru/glossary/vllm/)

vLLM — это библиотека с открытым кодом для инференса и сервинга LLM, изначально созданная в Sky Computing Lab Калифорнийского университета в Беркли. Она управляет памятью KV-кэша с помощью PagedAttention, непрерывно батчит входящие запросы, поддерживает многие форматы квантизации и предоставляет OpenAI-совместимый HTTP-сервер.

## Вопросы и ответы

### Почему модель с рассуждениями возвращает пустой ответ?

Модель потратила весь бюджет max\_tokens на скрытые рассуждения, не успев написать ответ. finish\_reason в таком случае равен «length». Увеличьте max\_tokens, понизьте reasoning\_effort или сделайте и то и другое. Короткое руководство с быстрым исправлением есть по ссылке в этой статье.

### Какой max\_tokens ставить для модели с рассуждениями?

Сначала измерьте. Прогоните 50 или больше реальных промптов со щедрым потолком, возьмите 95-й перцентиль completion\_tokens для этой задачи и добавьте около 20%. Документация BroadNet называет минимум в 1000 токенов или больше; OpenAI советует на старте резервировать 25 000 для своих моделей.

### Стоит ли больший max\_tokens дороже?

Сам по себе нет. Вы платите за токены, которые сгенерировала модель, а не за потолок. Более высокий потолок обходится дороже, только когда ответ иначе был бы оборван, — а оборванный ответ всё равно стоил бы вам повторного запроса.

### max\_completion\_tokens и max\_tokens — это одно и то же?

У OpenAI max\_completion\_tokens заменяет устаревший max\_tokens и явно включает токены рассуждений. Многие OpenAI-совместимые провайдеры вместо него документируют max\_tokens. В документации BroadNet используется max\_tokens, и сказано, что рассуждения в него входят.

### Можно ли ограничить рассуждения отдельно от ответа?

Только там, где это поддерживает сервер. У vLLM есть параметр thinking\_token\_budget, у некоторых провайдеров — свои. BroadNet документирует reasoning\_effort со значением low, а не отдельный лимит на рассуждения, так что планируйте бюджет на оба сразу.

## Читайте также

-   [Токены рассуждений: почему вы платите за выход, которого не видите](https://broadrouter.com/ru/blog/reasoning-tokens-cost/)
-   [Стриминг LLM: чанки SSE, дельты, usage и отмена](https://broadrouter.com/ru/blog/llm-streaming-sse-explained/)
-   [JSON mode или json\_schema: надёжный структурированный вывод LLM](https://broadrouter.com/ru/blog/structured-output-json-schema/)
-   [Долгоживущие ИИ-агенты: таймауты, повторы и чекпойнты](https://broadrouter.com/ru/blog/long-running-agents-timeouts-retries/)
-   [Переход на OpenAI-совместимый API: чек-лист миграции](https://broadrouter.com/ru/blog/openai-compatible-api-migration-checklist/)
-   [GPU-парк и подход к инференсу BroadNet — по описанию самой BroadNet](https://broadrouter.com/ru/blog/broadnet-gpu-fleet-and-serving/)
-   [Кэширование ответов LLM API: кэш точных совпадений на Python](https://broadrouter.com/ru/blog/cache-llm-responses-cut-cost/)
-   [Руководство: Почему рассуждающая модель возвращает пустой ответ](https://broadrouter.com/ru/guides/reasoning-tokens-empty-response/)
-   [Руководство: Стриминг chat completions и обрыв соединения](https://broadrouter.com/ru/guides/streaming-chat-completions/)
-   [Руководство: OpenAI Python SDK и BroadNet Inference](https://broadrouter.com/ru/guides/openai-python-sdk/)

Проверьте на своей реальной нагрузке. Новые аккаунты получают стартовый грант US$5 на Gemma и распознавание речи. Для DeepSeek, GLM и Qwen3.8 нужно пополнить баланс.

[Начать](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**Источники**

-   [Справочник BroadNet Inference API: рассуждения входят в max\_tokens, 1000 токенов или больше, reasoning\_effort low, поля usage (дата обращения 2026-11-15) (на английском)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [Описание полей pricing.json от BroadNet: context\_length вмещает промпт и ответ вместе (дата обращения 2026-11-15) (на английском)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [Руководство OpenAI по рассуждениям: незавершённые ответы, резервируйте не меньше 25 000 токенов на старте (дата обращения 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [Справочник OpenAI Chat Completions: max\_completion\_tokens включает токены рассуждений; max\_tokens устарел (дата обращения 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Документация DeepSeek API, режим thinking: поле reasoning\_content, уровни effort (дата обращения 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [Документация vLLM, вывод рассуждений: поле reasoning (раньше reasoning\_content), thinking\_token\_budget (дата обращения 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
