AI Prompt Engineering · Aula

Como os modelos de raciocínio são diferentes

Cadeia de pensamento interna versus modelos padrão: o que muda para quem escreve o prompt.

Como os modelos de raciocínio são diferentes é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que são modelos de raciocínio?

Modelos de raciocínio são LLMs treinados e configurados especificamente para realizar uma deliberação interna prolongada antes de produzir uma resposta. Entre os exemplos estão as séries o1/o3/o4 da OpenAI e o Claude da Anthropic com o raciocínio estendido habilitado.

Ao contrário dos modelos padrão, que geram texto token a token diretamente a partir do seu prompt, os modelos de raciocínio primeiro produzem uma longa cadeia interna de raciocínio e depois a resumem em uma resposta final.

Padrão versus raciocínio: o que você vê

Do ponto de vista do usuário da API, a diferença é:

Modelo padrão: entrada → saída (rápido e direto)
Modelo de raciocínio: entrada → [raciocínio interno, oculto ou transmitido] → saída (mais lento e mais preciso em problemas difíceis)

O processo de raciocínio é o rascunho privado do modelo. Ele pode conter caminhos equivocados, autocorreções e cálculos intermediários que nunca aparecem na resposta final.

Série o da OpenAI: comportamento da API

Os modelos o1/o3/o4 da OpenAI lidam internamente com o raciocínio — por padrão, você não vê os tokens de raciocínio. É possível observar a quantidade de tokens de raciocínio nos metadados de uso, mas não o conteúdo.

import openai

client = openai.OpenAI(api_key='sk-...')

# o3 — reasoning happens internally
response = client.chat.completions.create(
    model='o3',
    messages=[
        {'role': 'user', 'content': 'Solve: A train leaves Chicago at 9am going 60mph. Another leaves NYC at 10am going 80mph. If the distance is 790 miles, when do they meet?'}
    ],
    # reasoning_effort='high'  # Optional: 'low', 'medium', 'high'
)

print(response.choices[0].message.content)
# Check how many tokens were used for thinking:
print('Input tokens:', response.usage.prompt_tokens)
print('Output tokens:', response.usage.completion_tokens)

Raciocínio estendido do Claude: comportamento da API

O Claude da Anthropic disponibiliza tokens de raciocínio estendido por meio da API. Você pode transmiti-los e observar o processo de raciocínio do modelo em tempo real. O conteúdo do raciocínio aparece antes da resposta final.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# Enable extended thinking
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=16000,
    thinking={
        'type': 'enabled',
        'budget_tokens': 10000  # Max tokens for thinking
    },
    messages=[{
        'role': 'user',
        'content': 'What is the 100th prime number?'
    }]
)

# Response contains both thinking blocks and text blocks
for block in response.content:
    if block.type == 'thinking':
        print('THINKING:', block.thinking[:200], '...')
    elif block.type == 'text':
        print('ANSWER:', block.text)

Transmitindo tokens de raciocínio

Você pode transmitir o raciocínio estendido em tempo real, acompanhando o raciocínio do modelo à medida que ele se desenvolve. Isso é útil para a experiência do usuário — por exemplo, para mostrar uma animação de “raciocinando” ou permitir que usuários avançados observem o processo de raciocínio.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def stream_with_thinking(question):
    with client.messages.stream(
        model='claude-opus-4-5',
        max_tokens=16000,
        thinking={'type': 'enabled', 'budget_tokens': 8000},
        messages=[{'role': 'user', 'content': question}]
    ) as stream:
        current_block_type = None
        for event in stream:
            # Track which block type we're in
            if hasattr(event, 'type'):
                if 'thinking' in str(event.type):
                    current_block_type = 'thinking'
                elif 'text' in str(event.type):
                    current_block_type = 'text'
            # Print text delta
            if hasattr(event, 'delta') and hasattr(event.delta, 'text'):
                prefix = '[THINK] ' if current_block_type == 'thinking' else '[ANS] '
                print(prefix + event.delta.text, end='', flush=True)

stream_with_thinking('Explain why P != NP is unproven.')

O que acontece internamente: o rascunho

O raciocínio interno do modelo é um rascunho no qual ele pode:

Explorar várias abordagens antes de escolher uma
Fazer cálculos e verificá-los
Identificar seus próprios erros e voltar atrás
Considerar casos extremos
Planejar soluções em várias etapas

Essa deliberação interna explica por que os modelos de raciocínio superam amplamente os modelos padrão em matemática difícil, programação e planejamento estratégico — eles basicamente fazem uma revisão da literatura antes de escrever.

budget_tokens: controlando a profundidade do raciocínio

budget_tokens (Claude) ou reasoning_effort (OpenAI) controla quanto o modelo raciocina. Mais raciocínio significa maior precisão em problemas difíceis, mas também mais custo e latência.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def ask_with_budget(question, budget):
    r = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=budget + 2048,  # must exceed budget_tokens
        thinking={'type': 'enabled', 'budget_tokens': budget},
        messages=[{'role': 'user', 'content': question}]
    )
    thinking_tokens = sum(
        len(b.thinking.split()) * 1.3  # rough estimate
        for b in r.content if b.type == 'thinking'
    )
    answer = next(b.text for b in r.content if b.type == 'text')
    return answer, int(thinking_tokens)

# Same hard question with different budgets
q = 'Prove that the square root of 2 is irrational.'
ans_small, tok_small = ask_with_budget(q, 1024)
ans_large, tok_large = ask_with_budget(q, 8000)
print(f'Small budget ({tok_small} thinking tokens): {ans_small[:100]}')
print(f'Large budget ({tok_large} thinking tokens): {ans_large[:100]}')

Temperatura e modelos de raciocínio

Os modelos de raciocínio se comportam de maneira diferente com as configurações de temperatura:

Para a série o da OpenAI: a temperatura padrão é 1 e nem sempre pode ser alterada
Para o raciocínio estendido do Claude: a temperatura normalmente é definida como 1 durante o raciocínio

Não tente usar a temperatura para controlar o comportamento de modelos de raciocínio — use budget_tokens ou reasoning_effort em vez disso.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

# For Claude with extended thinking, temperature=1 is the default
# and best practice
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=10000,
    temperature=1,  # Required to be 1 when extended thinking is enabled
    thinking={
        'type': 'enabled',
        'budget_tokens': 5000
    },
    messages=[{
        'role': 'user',
        'content': 'Write a Python function to find all prime numbers up to N.'
    }]
)
print(response.content[-1].text[:300])

Referências de desempenho: onde o raciocínio se destaca

Os modelos de raciocínio superam os modelos padrão de maneira mais expressiva em:

Matemática de competições: AIME, AMC (o3 próximo do nível de um especialista humano)
Programação complexa: programação competitiva (Codeforces)
Raciocínio científico: GPQA (ciência de nível de pós-graduação)
Lógica em várias etapas: problemas que exigem dedução sequencial

Em tarefas simples (gramática, resumo, perguntas e respostas factuais), os modelos padrão apresentam desempenho igualmente bom a um custo 10 a 100 vezes menor.

A realidade da latência

Os modelos de raciocínio são lentos. Um problema difícil com alto esforço de raciocínio pode levar de 30 a 60 segundos. Planeje sua experiência do usuário de acordo:

Mostre indicadores de progresso com a mensagem 'raciocinando...'
Utilize transmissão contínua para mostrar resultados parciais assim que estiverem disponíveis
Não utilize modelos de raciocínio em conversas em tempo real nas quais a latência seja importante
Pré-calcule as saídas dos modelos de raciocínio para perguntas difíceis conhecidas

import time
import anthropic

client = anthropic.Anthropic(api_key='sk-ant-...')

def timed_reasoning_call(question, budget):
    start = time.time()
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=budget + 2000,
        thinking={'type': 'enabled', 'budget_tokens': budget},
        messages=[{'role': 'user', 'content': question}]
    )
    elapsed = time.time() - start
    answer = next(b.text for b in response.content if b.type == 'text')
    print(f'Latency: {elapsed:.1f}s | Answer: {answer[:100]}')
    return answer

# Hard problem — expect 20-45 seconds
timed_reasoning_call(
    'Design a database schema for a multi-tenant SaaS billing system.',
    budget=8000
)

Modelos de raciocínio e instruções de sistema

Os modelos de raciocínio respondem às instruções de sistema de maneira diferente dos modelos padrão. Como deliberam internamente antes de responder, conseguem seguir instruções complexas de várias etapas com mais confiabilidade.

No entanto, instruções de sistema muito longas e restritivas podem entrar em conflito com o raciocínio interno. A prática recomendada é manter as instruções de sistema concisas para modelos de raciocínio — defina a função e o formato da saída e deixe que o raciocínio interno do modelo cuide da estratégia.

Verificação de conhecimento: raciocínio dos modelos

Qual é a principal diferença entre o que o autor da instrução fornece e o que acontece internamente em um modelo de raciocínio?

Recapitulação: como os modelos de raciocínio diferem

Modelos de raciocínio como o1/o3 e Claude com raciocínio estendido executam uma cadeia de raciocínio interna antes de responder. O autor da instrução fornece um problema; o modelo delibera internamente, explora abordagens e corrige a si mesmo, depois produz uma resposta final. É possível controlar a profundidade do raciocínio com budget_tokens (Claude) ou reasoning_effort (OpenAI). Os modelos de raciocínio se destacam em matemática complexa, programação e lógica em várias etapas, mas são de 10 a 100 vezes mais caros e de 10 a 100 vezes mais lentos que os modelos padrão. Utilize transmissão contínua e indicadores de progresso para gerenciar a latência na sua experiência do usuário.

Perguntas Frequentes

A aula “Como os modelos de raciocínio são diferentes” é grátis?

Sim — o texto completo de “Como os modelos de raciocínio são diferentes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Como os modelos de raciocínio são diferentes”?

Cadeia de pensamento interna versus modelos padrão: o que muda para quem escreve o prompt. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Como os modelos de raciocínio são diferentes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Como os modelos de raciocínio são diferentes
Prompts eficazes para raciocínio prolongado
Quando usar modelos de raciocínio ou modelos padrão
Relações de compromisso entre custo e latência

← Voltar para AI Prompt Engineering