0Pricing
AI Agents · Aula

Modelos do mundo e antecipação

Preveja o resultado de uma ação antes de executá-la; escolha a ação com o melhor resultado previsto.

Modelos do mundo e antecipação é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 3 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 Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Preveja antes de agir

Os melhores agentes não apenas tentam fazer as coisas — eles primeiro preveem os resultados, escolhem a melhor opção e então agem. É a mesma ideia de calcular N jogadas à frente no xadrez.

O que é um modelo do mundo?

Um modelo do mundo prevê: dado o estado current S e a ação A, qual será o próximo estado S'?

Para um agente baseado em LLM, o próprio LLM pode ser o modelo do mundo:

prediction_prompt = '''
Current state: {state}
Proposed action: {action}
What is the most likely outcome? Return JSON: {new_state, success_probability}.
'''

Por que a antecipação ajuda

Algumas ações são irreversíveis (enviar um e-mail, excluir dados). Fazer uma previsão antes pode evitar erros dispendiosos.

Outras ações têm resultados incertos. Prever força o agente a pensar nas consequências.

Simple 1-Step Lookahead

candidates = [a1, a2, a3]
predictions = [predict(state, a) for a in candidates]
best = max(zip(predictions, candidates), key=lambda p: p[0].success_probability)[1]
act(best)

Antecipação de várias etapas (pesquisa em árvore)

Expanda várias etapas à frente. Para cada candidata, preveja os resultados e depois preveja os resultados desses resultados:

def search(state, depth=2):
    if depth == 0:
        return value(state)
    actions = candidate_actions(state)
    best_score = -math.inf
    for a in actions:
        next_state = predict(state, a)
        score = search(next_state, depth - 1)
        best_score = max(best_score, score)
    return best_score

Árvore de pensamentos

Yao et al. 2023 — amplia a cadeia de pensamento para uma árvore. O agente gera vários "caminhos de pensamento", avalia cada um e expande o mais promissor:

import random

def continue_thought(question):
    return question + ' -> idea' + str(random.randint(1, 100))

def score(t):
    return len(t)

def expand_top_k(thoughts, scores, k):
    ranked = sorted(zip(thoughts, scores), key=lambda x: -x[1])
    return [t for t, s in ranked[:k]]

def ToT(question):
    thoughts = [continue_thought(question) for _ in range(5)]
    for depth in range(2):
        scores = [score(t) for t in thoughts]
        thoughts = expand_top_k(thoughts, scores, k=3)
    return thoughts

result = ToT('How to reduce agent latency?')
print('Top thoughts:', result)

Pesquisa em árvore de Monte Carlo (MCTS)

Para árvores de pesquisa muito grandes: amostre caminhos, atribua pontuações aos resultados e propague as pontuações de volta para orientar seleções futuras. É muito usada em IAs que jogam, e está começando a ser usada na pesquisa sobre agentes.

Custo da antecipação

Cada ação prevista é uma chamada de LLM. Antecipação com profundidade=2 e ramificação=3 exige 9 chamadas apenas para decidir uma ação ONE. Use a antecipação somente em decisões de alto risco.

Poda heurística

Ignore previsões para ações obviamente ruins. Faça uma pré-filtragem das ações candidatas com um classificador ou uma regra barata.

Calibrando previsões

As previsões do LLM são imperfeitas. Faça a calibração comparando ocasionalmente os resultados previstos com os reais:

for trace in recent_traces:
    predicted = trace.predicted_outcome
    actual = trace.actual_outcome
    log.info('prediction-accuracy', match=(predicted == actual))

Quando NOT usar a antecipação

  • Ações baratas e reversíveis — simplesmente tente executá-las
  • Caminhos críticos para a latência
  • Tarefas cujos resultados são óbvios

Quando TO usar a antecipação

  • Ações irreversíveis (financeiras, de comunicação)
  • Planos de várias etapas em que os erros se acumulam
  • Domínios de alto risco (médico, jurídico)
  • Tarefas adversariais (jogos, debates)

Antecipação interna no estilo o1

Os modelos de raciocínio o1 / o3 da OpenAI fazem antecipação interna automaticamente durante a fase de "raciocínio". Eles exploram muitas continuações antes de se comprometer. Não é necessário implementá-la externamente.

Compromisso da antecipação

Qual é o principal custo da antecipação de várias etapas?

Recapitulação

Preveja antes de agir. A antecipação de 1 etapa é barata e útil; a pesquisa em árvore é dispendiosa, mas poderosa. Os modelos de raciocínio (o1, o3) automatizam isso. Use com moderação.

Perguntas Frequentes

A aula “Modelos do mundo e antecipação” é grátis?

Sim — o texto completo de “Modelos do mundo e antecipação” é 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 Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “Modelos do mundo e antecipação”?

Preveja o resultado de uma ação antes de executá-la; escolha a ação com o melhor resultado previsto. Você pratica AI Agents 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 Agents?

Nenhuma experiência prévia é necessária. AI Agents 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 3 de 4.

Quanto tempo leva a aula “Modelos do mundo e antecipação”?

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 Agents?

Sim. Cada aula de AI Agents 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

  1. Decomposição hierárquica de tarefas
  2. Pilhas de objetivos e retrocesso
  3. Modelos do mundo e antecipação
  4. Ciclos de reflexão e autocrítica
← Voltar para AI Agents