---
title: "max_tokens em modelos de raciocínio: como dimensionar"
description: "Por que modelos de raciocínio devolvem respostas vazias com max_tokens baixo e como dimensionar o limite por percentis, janela de contexto e retentativas crescentes."
url: https://broadrouter.com/pt/blog/reasoning-model-max-tokens-budget/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/reasoning-model-max-tokens-budget/) (atualizado em 2026-11-15).

# Como definir max\_tokens em modelos de raciocínio: um método

Pela equipe da BroadNet Inference · 6 min de leitura · Publicado em 2026-11-15

Em um modelo de raciocínio, max\_tokens limita o raciocínio e a resposta juntos, então um limite apertado pode encerrar a resposta antes de qualquer texto visível. Meça o total de tokens de completion por tipo de tarefa, defina max\_tokens em cerca do percentil 95 mais 20%, mantenha prompt mais max\_tokens dentro da janela de contexto e repita respostas cortadas com orçamento dobrado, até um teto fixo.

## Pontos principais

-   max\_tokens é um teto, não uma cobrança. Você paga pelos tokens gerados, então um teto generoso não custa nada nas respostas que terminam antes.
-   O que custa dinheiro é o teto apertado: uma resposta cortada cobra o raciocínio, não entrega resposta e precisa ser enviada de novo.
-   Defina o orçamento por tipo de tarefa a partir dos seus próprios logs: o percentil 95 dos tokens de completion mais uma margem de 20% é um bom começo.
-   Tokens do prompt mais max\_tokens precisam caber na janela de contexto: 262.144 tokens no Qwen3.8 27B, 1.048.576 no GLM 5.3 e no DeepSeek V4.1 Flash.
-   Trate finish\_reason "length" como sinal: repita com orçamento dobrado ou reasoning\_effort menor, com um teto fixo.

**Nesta página**

1.  Por que o orçamento acaba antes da resposta?
2.  Um max\_tokens maior custa mais?
3.  Como medir o que uma tarefa precisa?
4.  Como a janela de contexto limita o orçamento?
5.  O que fazer quando uma resposta ainda é cortada?
6.  O que muda com streaming?
7.  Qual nome de parâmetro enviar?
8.  Onde a BroadNet Inference se encaixa

Um modelo de raciocínio pensa antes de responder, e na maioria das APIs compatíveis com a OpenAI as duas coisas saem de um único orçamento: `max_tokens`. Configure como faria em um modelo sem raciocínio, algumas centenas de tokens para uma resposta curta, e algumas respostas voltam vazias com `finish_reason: "length"`. A correção rápida está em [por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/). Este post é o método por trás de um orçamento confiável: medir, dimensionar por percentis, respeitar a janela de contexto e tratar as respostas que ainda forem cortadas.

Para saber quanto custa o raciocínio e como reduzir, veja [tokens de raciocínio: por que você paga mais saída do que vê](https://broadrouter.com/pt/blog/reasoning-tokens-cost/).

## Por que o orçamento acaba antes da resposta?

O modelo gera em ordem: primeiro o raciocínio, depois a resposta visível. Cada token dos dois conta em `max_tokens`. A documentação da BroadNet diz isso sobre o DeepSeek V4.1 Flash, o GLM 5.3 e o Qwen3.8 27B: “the reasoning counts toward max\_tokens” (tradução: o raciocínio conta em max\_tokens), e com um limite pequeno “the answer comes back empty” (tradução: a resposta volta vazia). A referência de Chat Completions da OpenAI define `max_completion_tokens` do mesmo jeito, como um limite superior “including visible output tokens and reasoning tokens” (tradução: incluindo tokens de saída visíveis e tokens de raciocínio).

Então a pergunta certa não é “qual o tamanho da minha resposta?”. É “qual o tamanho do raciocínio mais a resposta, nesta tarefa, com este effort?”. E isso varia mais do que se imagina. O guia da OpenAI diz que os modelos dela podem gerar “anywhere from a few hundred to tens of thousands of reasoning tokens” (tradução: de algumas centenas a dezenas de milhares de tokens de raciocínio), dependendo do problema.

## Um max\_tokens maior custa mais?

Não. Esse é o motivo mais comum de orçamentos apertados demais. [`max_tokens`](https://broadrouter.com/pt/glossary/max-tokens/) é um teto. Você paga pelos tokens efetivamente gerados. Uma resposta que precisa de 1.800 tokens custa o mesmo com teto de 4.000 ou de 40.000.

O que um teto apertado custa:

| Teto em relação à necessidade | O que você paga | O que você recebe |
| --- | --- | --- |
| Teto acima da necessidade | Os tokens gerados | A resposta |
| Teto abaixo da necessidade | O teto inteiro, todo em raciocínio | Nada aproveitável, mais uma retentativa |

Um exemplo. Suponha que um quarto das suas chamadas precise de mais de 1.000 tokens. Com `max_tokens=1000`, cada uma dessas chamadas cobra 1.000 tokens de saída de raciocínio, não devolve nada e é repetida. Isso dá, em média, 250 tokens de saída desperdiçados por chamada, considerando todas as chamadas, antes das próprias retentativas, mais a latência de uma segunda requisição. Com o teto em 4.000, nada se perde. No [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/), a saída custa $2.17 por 1M de tokens, então o desperdício pesa em volume.

O risco real de um teto alto é uma resposta descontrolada: um modelo que entra em loop ou pensa demais e gera muito mais do que o necessário. Um teto fixo limita isso. Escolha o teto com base em dados, como abaixo.

## Como medir o que uma tarefa precisa?

Rode prompts reais de um tipo de tarefa com um teto generoso e registre os tokens de completion e a parcela de raciocínio. Quando o modelo informa, `usage.completion_tokens_details.reasoning_tokens` traz a parte do raciocínio; a documentação da BroadNet lista esse campo.

```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")))
```

Regras para chegar a um número confiável:

1.  **Um tipo de tarefa por rodada.** Classificação, extração, code review e planejamento têm distribuições muito diferentes. Um `max_tokens` global único ou desperdiça dinheiro com retentativas ou deixa passar respostas descontroladas.
2.  **50 ou mais prompts reais.** O percentil 95 de dez amostras é só a maior delas.
3.  **Rode para cada effort que você usa.** `reasoning_effort="low"` muda a distribuição. A BroadNet documenta `low`; teste outros valores antes de depender deles.
4.  **Se `cut_off` não for zero, aumente o teto e rode de novo.** Uma amostra cortada esconde o tamanho real.
5.  **Rode de novo quando o modelo ou o prompt mudar.** Uma nova versão do modelo pode pensar mais ou menos.

Depois defina `max_tokens` por tarefa a partir de `recommend()`. O percentil 95 mais 20% deixa a maioria das chamadas bem abaixo do teto e manda só os raros casos longos para o caminho de retentativa descrito abaixo. A [ferramenta gratuita de orçamento de tokens de raciocínio](https://broadrouter.com/tools/reasoning-token-budget/) faz essa conta no navegador quando você já tem os seus números.

## Como a janela de contexto limita o orçamento?

A janela de contexto contém o prompt e a resposta juntos. O feed de preços da BroadNet define `context_length` como “the most tokens one request can hold, prompt and answer together” (tradução: o máximo de tokens que uma requisição comporta, prompt e resposta juntos). Portanto:

**max\_tokens ≤ tamanho do contexto − tokens do prompt**

| Modelo | Contexto | Espaço para max\_tokens com um prompt de 200.000 tokens |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) | 1.048.576 | 848.576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) | 1.048.576 | 848.576 |
| Qwen3.8 27B | 262.144 | 62.144 |

Isso importa em trabalhos com contexto longo. Um agente cujo histórico cresceu até 250.000 tokens no Qwen3.8 27B tem só cerca de 12.000 tokens livres para raciocínio e resposta. Tarefas de contexto longo também tendem a exigir mais raciocínio, então confira o espaço restante no momento da chamada, não uma vez só na inicialização. [Janela de contexto](https://broadrouter.com/pt/glossary/context-window/) e a [calculadora de janela de contexto](https://broadrouter.com/tools/context-window-calculator/) ajudam a fazer caber.

## O que fazer quando uma resposta ainda é cortada?

Confira `finish_reason` em toda chamada. Se for `length`, a resposta está faltando ou incompleta, mesmo quando `content` tem algum texto. Não faça o parsing como se estivesse completa; um objeto JSON truncado é uma fonte comum de erros mais adiante ([saída estruturada](https://broadrouter.com/pt/blog/structured-output-json-schema/)).

Repita com orçamento dobrado, dentro do espaço que o contexto permite, até um teto fixo:

```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
```

Duas alternativas a dobrar, dependendo da tarefa:

-   **Repita com `reasoning_effort="low"`** e o mesmo orçamento. Em tarefas simples, o modelo muitas vezes pensa demais, e menos effort resolve sem aumentar o teto.
-   **Divida a tarefa.** Se uma resposta continua batendo em um teto alto, a requisição geralmente está pedindo coisa demais de uma vez.

Registre cada corte com o tipo de tarefa. Uma taxa subindo significa que o prompt, o modelo ou os dados de entrada mudaram, e o orçamento precisa ser medido de novo. Retentativas são novas inferências e são cobradas de novo, então limite as tentativas, como em [agentes de longa duração: timeouts e retentativas](https://broadrouter.com/pt/blog/long-running-agents-timeouts-retries/).

## O que muda com streaming?

Com `stream=True`, o raciocínio acontece antes do primeiro token visível, então um modelo de raciocínio pode parecer travado no começo. Em uma interface de chat, mostre um estado de “pensando” até o conteúdo chegar e dimensione os timeouts do cliente para o tempo de raciocínio, não só para a resposta.

Alguns servidores também transmitem o próprio texto do raciocínio, em um campo separado. O nome não é padronizado: a API da DeepSeek usa `reasoning_content`, e o vLLM renomeou o campo de `reasoning_content` para `reasoning`, avisando que código de cliente antigo poderia ler em silêncio um campo vazio (texto original: “could silently read an empty” field). A documentação da BroadNet não documenta um campo com o texto do raciocínio, então não construa funcionalidades em cima dele sem conferir a resposta bruta do seu modelo. Se for ler, leia de forma defensiva:

```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))
```

O usage no último chunk exige `stream_options={"include_usage": True}`, que a BroadNet documenta. Mais sobre streams no [guia de streaming](https://broadrouter.com/pt/guides/streaming-chat-completions/) e em [SSE explicado](https://broadrouter.com/pt/blog/llm-streaming-sse-explained/).

## Qual nome de parâmetro enviar?

| API | Parâmetro | Inclui raciocínio |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens` (`max_tokens` obsoleto) | Sim |
| OpenAI Responses | `max_output_tokens` | Sim |
| BroadNet Inference (Chat Completions) | `max_tokens`, conforme a documentação | Sim |
| Servidores vLLM | `max_tokens`, mais `thinking_token_budget` opcional | Sim |

Ao levar código de um provedor para outro, envie o nome que o provedor documenta e confirme com uma chamada de teste que o limite tem efeito. Um limite ignorado em silêncio parece ok até chegar uma resposta descontrolada. O [checklist de migração](https://broadrouter.com/pt/blog/openai-compatible-api-migration-checklist/) cobre os outros parâmetros que mudam.

## Onde a BroadNet Inference se encaixa

Os três modelos de raciocínio da BroadNet informam os tokens de raciocínio em `usage` quando o modelo os fornece, então a medição acima funciona como está. O DeepSeek V4.1 Flash e o GLM 5.3 dão mais espaço, com 1.048.576 tokens de contexto. O Qwen3.8 27B tem 262.144. Se uma tarefa não precisa de raciocínio, o [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) não aparece como modelo de raciocínio e evita a questão do orçamento. Em um [plano de preço fixo do DeepSeek V4.1 Flash](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/), os tokens de raciocínio não têm cobrança por token, mas respostas cortadas ainda custam tempo, então o mesmo método vale. A BroadNet não documenta um teto separado para o raciocínio; se você precisar de um, use um provedor ou servidor self-hosted que ofereça isso.

Ferramentas gratuitas sobre o tema (em inglês)

-   [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.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Tokens de raciocínio (reasoning tokens)](https://broadrouter.com/pt/glossary/reasoning-tokens/)

Tokens de raciocínio são tokens que um modelo de raciocínio gera para trabalhar um problema antes de escrever a resposta visível. Normalmente são cobrados como tokens de saída, contam para o limite de saída e para a janela de contexto, e a API pode ocultá-los ou resumi-los.

[Janela de contexto (context window)](https://broadrouter.com/pt/glossary/context-window/)

A janela de contexto é o número máximo de tokens com que um modelo de linguagem consegue trabalhar em uma única requisição. Ela abrange o prompt, o histórico da conversa, as definições de ferramentas, as imagens e a saída gerada, incluindo os tokens de raciocínio. O que não couber precisa ser cortado, resumido ou dividido em várias requisições.

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

max\_tokens é um parâmetro de APIs de LLM que define o máximo de tokens que um modelo pode gerar em uma resposta. Quando a geração atinge o limite, ela para e a resposta é marcada como cortada, por exemplo com finish\_reason igual a "length".

[Tokens de entrada e de saída](https://broadrouter.com/pt/glossary/input-and-output-tokens/)

Tokens de entrada são os tokens que um modelo de linguagem lê em uma requisição, incluindo o system prompt, o histórico da conversa, as definições de ferramentas e as imagens. Tokens de saída são os que ele gera na resposta, incluindo o raciocínio. As APIs de LLM costumam cobrá-los separadamente, e a saída costuma custar mais.

[Streaming](https://broadrouter.com/pt/glossary/streaming/)

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

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

A Chat Completions API é o endpoint HTTP da OpenAI, POST /v1/chat/completions, que recebe o nome de um modelo e uma lista de mensagens marcadas com papéis e devolve a próxima mensagem do modelo. O formato da requisição e da resposta virou o padrão comum que provedores e SDKs compatíveis com a OpenAI reutilizam.

[Timeout de requisição (request timeout)](https://broadrouter.com/pt/glossary/request-timeout/)

Timeout de requisição é o tempo máximo que um cliente HTTP espera por um servidor antes de abandonar a requisição. Os clientes costumam dividi-lo em timeout de conexão, para abrir a conexão, e timeout de leitura, para esperar os dados. Chamadas a LLMs precisam de timeouts de leitura generosos, porque respostas longas levam tempo.

## Perguntas frequentes

### Por que meu modelo de raciocínio devolve uma resposta vazia?

O modelo gastou todo o orçamento de max\_tokens no raciocínio oculto antes de escrever a resposta. Nesse caso, finish\_reason é "length". Aumente max\_tokens, reduza reasoning\_effort, ou as duas coisas. Este post traz o link para um guia curto com a correção rápida.

### Qual max\_tokens devo usar em um modelo de raciocínio?

Meça primeiro. Rode 50 ou mais prompts reais com um teto generoso, pegue o percentil 95 de completion\_tokens daquela tarefa e some cerca de 20%. A documentação da BroadNet indica 1.000 tokens ou mais como piso; a OpenAI sugere reservar 25.000 quando você começa com os modelos dela.

### Um max\_tokens maior custa mais?

Não por si só. Você paga pelos tokens que o modelo gera, não pelo teto. Um teto maior só custa mais quando a resposta seria cortada de outra forma, e aí a resposta cortada já teria custado uma retentativa.

### max\_completion\_tokens é o mesmo que max\_tokens?

Na OpenAI, max\_completion\_tokens substitui o max\_tokens, que está obsoleto, e inclui explicitamente os tokens de raciocínio. Muitos provedores compatíveis com a OpenAI documentam max\_tokens. A documentação da BroadNet usa max\_tokens e diz que o raciocínio conta dentro dele.

### Dá para limitar o raciocínio separado da resposta?

Só se o servidor suportar. O vLLM tem o parâmetro thinking\_token\_budget, e alguns provedores têm o seu próprio. A BroadNet documenta reasoning\_effort em low, não um teto separado para o raciocínio, então dimensione os dois juntos.

## Continue lendo

-   [Tokens de raciocínio: por que você paga mais saída do que vê](https://broadrouter.com/pt/blog/reasoning-tokens-cost/)
-   [Streaming de LLM explicado: chunks SSE, deltas, usage e cancelamento](https://broadrouter.com/pt/blog/llm-streaming-sse-explained/)
-   [JSON mode vs json\_schema: saída estruturada que não quebra](https://broadrouter.com/pt/blog/structured-output-json-schema/)
-   [Agentes de longa duração: timeouts, retentativas e checkpoints](https://broadrouter.com/pt/blog/long-running-agents-timeouts-retries/)
-   [Migrar para uma API compatível com a OpenAI: checklist de migração](https://broadrouter.com/pt/blog/openai-compatible-api-migration-checklist/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)
-   [Guia: Streaming de chat completions e conexões que caem](https://broadrouter.com/pt/guides/streaming-chat-completions/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**Fontes**

-   [Referência da API da BroadNet Inference: o raciocínio conta em max\_tokens, 1.000 tokens ou mais, reasoning\_effort low, campos de usage (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [Referência de campos do pricing.json da BroadNet: context\_length inclui prompt e resposta juntos (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [Guia de raciocínio da OpenAI: respostas incompletas, reservar pelo menos 25.000 tokens no início (verificado em 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [Referência de Chat Completions da OpenAI: max\_completion\_tokens inclui tokens de raciocínio; max\_tokens obsoleto (verificado em 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Documentação da API da DeepSeek, thinking mode: campo reasoning\_content, níveis de effort (verificado em 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [Documentação do vLLM, reasoning outputs: campo reasoning (antes reasoning\_content), thinking\_token\_budget (verificado em 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
