Como funciona o esforço de raciocínio em LLM local
Entenda como o esforço de raciocínio muda os tokens internos, o tempo no CPU ou GPU e o uso da janela de contexto, sem alterar pesos ou quantização.
Que efeito tem o esforço de raciocínio num LLM local
O esforço de raciocínio é uma definição que indica ao modelo durante quanto tempo deve pensar antes de responder. Altera o comprimento do segmento de raciocínio e nada mais. Os pesos armazenados em disco são idênticos em todos os níveis, a quantização é idêntica e a resposta resulta da mesma passagem direta. O que muda é o número de tokens que o modelo utiliza primeiro no seu bloco de notas interno.
Essa distinção é importante devido ao local onde esses tokens são contabilizados. Numa API alojada, os tokens de raciocínio aparecem na fatura. Num VPS que controla, são pagos em tempo de geração no seu CPU ou GPU e em espaço dentro da janela de contexto. Um modelo deixado no nível máximo de esforço pode utilizar a maior parte da saída para raciocinar antes de apresentar a primeira palavra da resposta. Num hardware autoalojado, isso pode ser a diferença entre uma resposta em dois segundos e outra em dois minutos.
Onde o nível é definido: no modelo de chat, não nos pesos
Um modelo de raciocínio é treinado para emitir um segmento de raciocínio, normalmente delimitado pelas tags <think> e </think>, antes da resposta final. O nível de esforço é uma instrução que o modelo de chat escreve no prompt. Esse modelo é um ficheiro Jinja fornecido com o modelo. Ele lê uma variável como reasoning_effort e gera uma linha diferente ao nível do sistema para cada valor. O modelo foi treinado para encurtar ou alongar o seu bloco de trabalho em resposta a essa linha.
Isto tem duas consequências. Os nomes dos níveis pertencem ao modelo, não ao runtime. Por isso, um nome indicado no cartão de um modelo pode não significar nada para outro. Além disso, se algum componente da cadeia substituir o modelo de chat por um modelo genérico, a variável nunca é gerada e a configuração não produz efeito, sem apresentar qualquer erro.
Verificado em 2026-10-12, o cartão do modelo Qwen3.8-27B documenta três níveis de esforço: low, medium e xhigh, com xhigh como predefinição. Não existe high. O raciocínio é ativado com enable_thinking, que está ativo por predefinição. O cartão também documenta preserve_thinking, ativo por predefinição, que mantém o raciocínio de turnos anteriores no histórico da conversa. O gpt-oss usa low, medium e high. Muitas outras famílias aceitam apenas um valor booleano. Consulte o cartão da versão exata que instalou, porque estes nomes não são um padrão. Como executar um modelo 27B numa VPS vem primeiro. Esta página explica o que deve configurar depois de o modelo responder.
Por que um esforço de raciocínio maior custa mais numa VPS
Tokens de saída. Os tokens de raciocínio também são gerados. Passam pelo mesmo ciclo de decodificação que a resposta, à mesma velocidade de tokens por segundo que o seu hardware consegue atingir. Suponha que uma tarefa produza 200 tokens de resposta e 4,000 tokens de raciocínio. Foram gerados 4,200 tokens, mas o leitor viu apenas 200. A velocidade de decodificação depende da largura de banda da memória, da quantização escolhida e do número de threads: as próprias notas de ajuste do llama.cpp alertam que um valor --threads acima do número de núcleos físicos pode sobrecarregar a CPU e tornar a geração muito lenta. Depois destes parâmetros serem ajustados, resta controlar o próprio número de tokens.
Tempo de relógio. O utilizador espera pelo primeiro token da resposta, porque tudo o que aparece antes é um ecrã vazio ou um indicador de carregamento recolhido. O raciocínio é emitido primeiro, por isso a espera corresponde aproximadamente ao número de tokens de raciocínio dividido pela velocidade de decodificação, mais o processamento do prompt. Se duplicar o comprimento do raciocínio, duplica essa espera.
Contexto. Os tokens de raciocínio ocupam espaço na janela de contexto como qualquer outro token. Com preserve_thinking ativado, o bloco de trabalho da primeira interação continua no prompt na quinta interação. Assim, o processamento do prompt fica mais lento a cada interação, enquanto a janela é preenchida pelas duas extremidades. Aumentar num_ctx para o manter consome memória da cache KV, que numa VPS sem GPU corresponde a RAM do sistema que pode não estar disponível.
Quando aumentar o nível e quando o manter baixo
Aumente-o para tarefas em que um passo intermédio incorreto compromete o resultado: aritmética com várias etapas e conversão de unidades, planeamento de uma alteração em vários ficheiros, código que tem de compilar e problemas de restrições em que uma resposta tem de satisfazer várias condições ao mesmo tempo. Nestes casos, o bloco de trabalho está a fazer trabalho efetivo, e um bloco mais longo é uma forma barata de detetar um erro que, de outro modo, o modelo cometeria.
Mantenha-o baixo quando a resposta já está na entrada e a tarefa consiste em transferi-la. Extração, classificação, etiquetagem, tradução, reescrita, resumo e formatação enquadram-se nesta situação. O segmento de raciocínio limita-se, na maioria dos casos, a repetir a tarefa e dá ao modelo margem para rejeitar a primeira conclusão correta.
Mantenha-o baixo também para qualquer tarefa interativa. Numa caixa de chat ou num editor, está a intervir no processo; por isso, uma resposta rápida que possa corrigir é melhor do que uma resposta lenta pela qual tenha de esperar. Esse é o verdadeiro compromisso de apontar um agente de programação para um modelo local: um agente faz muitas chamadas pequenas, e o custo do raciocínio é cobrado em cada uma delas.
Como definir o nível no llama.cpp
O llama.cpp escreve a variável diretamente no template. Por isso, é o runtime em que pode confirmar que o nível chegou. Aponte -m para o GGUF que já tem.
llama-server -m ./qwen3.8-27b-Q4_K_M.gguf \
--jinja \
--reasoning-effort medium \
--reasoning-format deepseek \
-c 32768 \
--host 127.0.0.1 --port 8080--jinja usa o próprio chat template do modelo e está ativado por padrão nas builds atuais. --reasoning-effort aceita default, minimal, low, medium, high, xhigh ou max, em que default significa deixar o valor predefinido do template inalterado. Essa lista pertence ao vocabulário do llama.cpp, não ao do modelo. Por isso, passe apenas um nome que o card apresente: um nível que o template não defina pode causar um erro do template no momento do pedido. --reasoning-format deepseek move o raciocínio de message.content para message.reasoning_content. É isso que torna a divisão mensurável na secção seguinte.
Para desativar o raciocínio em vez de o encurtar, defina manualmente a variável do template:
llama-server -m ./qwen3.8-27b-Q4_K_M.gguf --jinja \
--chat-template-kwargs '{"enable_thinking": false}'--reasoning-budget é um mecanismo diferente. Limita o segmento de raciocínio em tokens. 0 termina-o imediatamente, enquanto -1 o deixa sem limite, em vez de pedir ao modelo que planeie um segmento mais curto. Ambos os flags definem o valor predefinido do servidor. Em 2026-10-12, o /v1/chat/completions do llama-server também aceita reasoning_effort e chat_template_kwargs no corpo do pedido, passando o nível ao template apenas nessa chamada, com none a desativar o raciocínio. Assim, um processo pode servir dois níveis de esforço.
O vLLM expõe a mesma variável por pedido, dentro do corpo compatível com a OpenAI:
{"model": "Qwen/Qwen3.8-27B",
"messages": [{"role": "user", "content": "Summarise this changelog in two lines."}],
"chat_template_kwargs": {"reasoning_effort": "medium"}}Como definir o nível no Ollama
Ollama tem o seu próprio campo, think, em /api/chat e /api/generate. Aceita true, false ou o nome de um nível. Em 2026-10-12, para um modelo que publica metadados de raciocínio, os nomes são definidos pelo próprio modelo: /api/show apresenta-os em thinking.values, com o valor predefinido ao lado, e um nome que o modelo não apresente recua para esse valor predefinido sem gerar um erro. Os modelos sem esses metadados usam o conjunto fixo mais antigo do Ollama: low, medium, high e max. Omita think para aplicar o valor predefinido do próprio modelo. No Qwen3.8, esse valor ativa o raciocínio.
ollama run qwen3.8:27b --think=low "Draft a one line commit message for a README typo fix"{"model": "qwen3.8:27b",
"messages": [{"role": "user", "content": "Which HTTP status code means the request body was too large?"}],
"think": "low",
"stream": false}O raciocínio é devolvido em message.thinking e a resposta em message.content, já separados. Numa sessão interativa de ollama run, /set think e /set nothink ativam ou desativam essa opção sem reiniciar, e /set think low seleciona um nível.
Agora veja onde isto pode falhar silenciosamente. O template do Qwen3.8 define low, medium e xhigh. Um modelo do Ollama inclui um template dentro da sua tag, em vez do ficheiro Jinja do repositório original, e o Ollama só encaminha um nível se o modelo empacotado o listar. Verifique primeiro o que a sua tag anuncia:
curl -s http://localhost:11434/api/show -d '{"model": "qwen3.8:27b"}' | jq .thinkingUm nome que não esteja em values, como high ou max neste modelo, é executado com o valor predefinido. Não presuma que funcionou. A medição demora cerca de um minuto.
Como medir se o nível foi realmente aplicado
Envie o mesmo prompt com mais de um nível e `temperature a 0. Depois, compare as contagens de tokens. Os três nomes abaixo são os que o card do Qwen3.8 indica. Se /api/show indicar nomes diferentes para a sua tag, use esses nomes. Aqui, jq` constrói o corpo para que não tenha de escapar as aspas manualmente.
for level in low medium xhigh; do
body=$(jq -n --arg lvl "$level" '{
model: "qwen3.8:27b",
messages: [{role: "user", content: "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take? Answer in minutes."}],
think: $lvl,
stream: false,
options: {temperature: 0, num_ctx: 8192}
}')
echo "== $level"
curl -s http://localhost:11434/api/chat -d "$body" | jq '{
thinking_chars: (.message.thinking // "" | length),
answer_chars: (.message.content | length),
eval_count: .eval_count,
seconds: (.total_duration / 1e9),
tok_per_sec: (.eval_count / (.eval_duration / 1e9))
}'
done`eval_count corresponde a todos os tokens gerados, incluindo o raciocínio. Por isso, a diferença entre dois níveis é quase toda devida ao raciocínio. thinking_chars fornece diretamente essa divisão. Duas condições devem verificar-se: os números devem variar entre os níveis, e a resposta deve continuar correta no nível mais baixo. Se eval_count permanecer dentro do ruído nas três execuções, o nível está a ser ignorado. Verifique primeiro os nomes em /api/show`, porque o Ollama usa o nível predefinido quando recebe um nome não listado. Se os nomes coincidirem, a correção é usar um runtime que transmita o nível.
O tempo total mostra apenas parte do problema. Meça também o intervalo até ao primeiro token da resposta, fazendo streaming e parando no primeiro bloco não vazio de `content. Para isso, são necessários jq e bc`.
start=$(date +%s.%N)
curl -sN http://localhost:11434/api/chat -d '{
"model": "qwen3.8:27b",
"messages": [{"role": "user", "content": "Explain what a reverse proxy does, in three sentences."}],
"think": "low",
"stream": true
}' |
while IFS= read -r line; do
if [ -n "$(printf '%s' "$line" | jq -r '.message.content // ""')" ]; then
echo "first answer token after $(echo "$(date +%s.%N) - $start" | bc)s"
break
fi
doneExecute-o em `low e depois novamente em xhigh`. A diferença é o tempo de espera adicional. No llama.cpp, os mesmos números são devolvidos dentro da resposta, sem necessidade de fazer cálculos no shell:
curl -s http://localhost:8080/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model": "local", "temperature": 0,
"messages": [{"role": "user", "content": "A pump fills a 4500 litre tank in 25 minutes. A second pump is 40 percent slower. How long do both together take?"}]}' | jq '{
reasoning_chars: (.choices[0].message.reasoning_content // "" | length),
answer_chars: (.choices[0].message.content | length),
predicted_n: .timings.predicted_n,
tok_per_sec: .timings.predicted_per_second
}'Faça este teste no seu próprio servidor. Uma comparação de esforço publicada foi medida em hardware que não é o seu. A sua taxa de descodificação é o termo que converte uma contagem de tokens em segundos. Medir tokens por segundo no seu próprio servidor fornece esse termo: os tokens de raciocínio divididos pela sua taxa de descodificação correspondem ao tempo de espera que acabou de adicionar.
O que pode correr mal
A resposta é truncada ou content fica vazio enquanto thinking está preenchido. O limite de geração foi consumido pelo raciocínio. O num_predict do Ollama limita toda a geração, incluindo o raciocínio, que ocorre primeiro. Por isso, um limite de 512 tokens com esforço elevado pode terminar a resposta antes de o conteúdo começar. O Ollama indica "done_reason": "length" nessa resposta. Aumente o limite ou reduza o nível de esforço. Como num_predict conta tokens explica esta interação em detalhe.
O nível não altera nada. As contagens de tokens são idênticas em todos os níveis. O runtime pode não estar a transmitir a variável, o template pode não a ler ou, no Ollama, o nome pode não estar entre os nomes indicados pela tag e ter sido usado o valor predefinido. Verifique o template que o runtime está realmente a utilizar, e não o template do repositório original. O llama.cpp com --jinja e --chat-template-kwargs escreve a variável manualmente, pelo que serve como controlo: se o nível funcionar aí e não noutro local, o modelo está correto e o outro runtime está a descartar a variável.
Um nome de nível é rejeitado. Um erro do template no momento do pedido, ou uma falha na primeira mensagem com um servidor que funciona corretamente, normalmente significa que foi enviado um nível que o template não define, como high para um modelo cujo cartão lista apenas low, medium e xhigh. No Ollama, um modelo sem metadados de raciocínio aceita apenas low, medium, high e max. Qualquer outro valor devolve um erro invalid think value.
Os chats com várias interações ficam mais lentos a cada turno. O raciocínio anterior está a ser mantido no histórico. Defina preserve_thinking como false se o modelo suportar essa opção ou remova o campo thinking das mensagens que envia novamente. Caso contrário, o processamento do prompt aumenta a cada turno, enquanto as respostas mantêm o mesmo tamanho.
A qualidade diminui com esforço baixo numa tarefa que considerava simples. Algumas operações de extração não são apenas extração. Se a entrada exigir uma conversão de unidades ou a aplicação sequencial de uma regra, trata-se de uma tarefa de raciocínio com uma saída curta. Aumente o nível apenas nessa chamada, em vez de o aumentar em todo o servidor.
Executar dois níveis em simultâneo
O llama.cpp define um nível predefinido no arranque com --reasoning-effort, mas as versões atuais também aceitam reasoning_effort por pedido. Assim, um processo e uma única cópia dos pesos podem servir um editor num nível baixo e uma tarefa batch noturna num nível mais alto. Se preferir fixar cada nível no arranque, também pode usar dois processos em duas portas. Nesse caso, são necessárias duas cópias dos pesos na memória, a menos que separe as tarefas no tempo. Em qualquer dos casos, as tarefas partilham a capacidade de descodificação de uma máquina. Por isso, num VPS, a opção mais económica costuma ser usar pouco esforço para tudo o que exige resposta imediata e agendar uma execução com mais esforço para tarefas que ninguém está a acompanhar. O que acontece quando vários utilizadores partilham um modelo local também se aplica aqui: os tokens de raciocínio exigem trabalho de descodificação. Por isso, aumentar o esforço reduz a concorrência efetiva aproximadamente pelo mesmo fator em que aumenta a contagem de tokens.
FAQ
Que nível de esforço de raciocínio devo usar por padrão?
Comece pelo nível mais baixo disponibilizado pelo modelo e aumente-o apenas para tarefas que tenha observado falhar. Vários modelos de raciocínio são distribuídos com um nível predefinido elevado, e o Qwen3.8-27B usa xhigh, o nível máximo, por padrão em outubro de 2026. Essa predefinição é escolhida para apresentar bons resultados em tabelas de benchmarks, mas uma tabela de benchmarks não cobra pelo tempo. No seu próprio hardware, o custo aparece em segundos. Por isso, torne o nível mais elevado uma opção por tarefa, em vez de o usar como configuração herdada por todos os pedidos.
Os tokens de raciocínio contam para o limite da janela de contexto?
Sim. São tokens normais na saída e ocupam espaço na janela de contexto juntamente com todo o restante conteúdo. A permanência desses tokens na interação seguinte depende do runtime e do modelo. O cartão do Qwen3.8 documenta preserve_thinking, ativado por padrão, que mantém o raciocínio anterior no histórico. Assim, uma conversa longa acumula todos os scratchpads produzidos. Defina-o como false ou remova o campo thinking das mensagens que reproduz. Dessa forma, o processamento dos prompts deixa de crescer.
Por que motivo alterar o nível de raciocínio não muda a contagem de tokens?
A configuração não está a chegar ao chat template. O nível é uma variável do template. Só funciona se o runtime a transmitir e se o template incluído a ler. Alguns runtimes distribuem o seu próprio template com o modelo, em vez do ficheiro Jinja do repositório original. Nesse caso, a variável é descartada sem qualquer erro. O Ollama também executa um nome de nível que o modelo não lista no nível predefinido, novamente sem apresentar um erro. Confirme-o enviando o mesmo prompt com o nível mais baixo e o mais alto, com temperature em 0, e compare eval_count. Se as contagens forem iguais dentro da variação normal, o nível está a ser ignorado.
Um esforço de raciocínio menor torna o modelo menos preciso?
Depende da tarefa. Deve medir o efeito em vez de o presumir. Quando a resposta já está presente na entrada, como em tarefas de extração ou reescrita, um scratchpad mais curto normalmente não altera o resultado. Quando uma etapa intermédia tem de estar correta antes de a etapa final poder estar correta, como em aritmética com vários passos ou em código que tem de compilar, a precisão diminui com um scratchpad mais curto. Crie um conjunto de vinte prompts da sua carga de trabalho real, execute-os em dois níveis com temperature em 0 e conte as respostas erradas. Esse número é específico da sua carga de trabalho. Nenhuma tabela publicada o pode fornecer.