Modelos do mundo e planejamento preditivo
Agentes que simulam estados futuros antes de agir: simulação mental para IA.
Modelos do mundo e planejamento preditivo é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 2 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.
O que é um modelo do mundo?
Um modelo do mundo é a representação interna que o agente tem do ambiente: quais objetos existem, quais são seus estados, quais regras determinam como eles mudam e o que o agente pode fazer para afetá-los. É a simulação mental que o agente faz do mundo.
Sem um modelo do mundo, o agente só pode reagir às observações. Com um modelo, ele pode prever e planejar.
Representação do estado do mundo
Um estado do mundo é um snapshot de todos os fatos relevantes sobre o ambiente em determinado momento. Para um agente de IoT, isso pode incluir as leituras atuais dos sensores e os estados dos dispositivos. Para um agente de software, pode incluir o estado dos arquivos, das APIs e dos bancos de dados que ele gerencia.
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any
@dataclass
class WorldState:
timestamp: str = ''
entities: dict = field(default_factory=dict) # entity_id -> attributes
relationships: list = field(default_factory=list)
agent_position: str = 'idle'
pending_actions: list = field(default_factory=list)
def __post_init__(self):
if not self.timestamp:
self.timestamp = datetime.utcnow().isoformat()
def update_entity(self, entity_id: str, attributes: dict):
current = self.entities.get(entity_id, {})
self.entities[entity_id] = {**current, **attributes}
def snapshot(self) -> dict:
return {
'timestamp': self.timestamp,
'entities': dict(self.entities),
'agent_position': self.agent_position
}
# Example:
world = WorldState()
world.update_entity('server_room', {'temp_c': 22.5, 'humidity': 55})
world.update_entity('hvac_unit_1', {'status': 'off', 'setpoint': 22})
print(world.snapshot())Modelo de transição
Um modelo de transição define como o estado do mundo muda em resposta a uma ação: next_state = transition(current_state, action). Ele permite que o agente preveja como o mundo ficará depois de executar uma ação, sem executá-la de fato.
import copy
def transition(state: WorldState, action: dict) -> WorldState:
"""
Predict next state given current state and action.
Returns a new WorldState (does not modify original).
"""
next_state = copy.deepcopy(state)
action_type = action.get('type')
target = action.get('target')
params = action.get('params', {})
if action_type == 'TURN_ON_HVAC':
next_state.update_entity(target, {
'status': 'on',
'setpoint': params.get('setpoint', 22)
})
# Simulate temperature effect (simplified linear model)
room = action.get('room', 'server_room')
current_temp = next_state.entities.get(room, {}).get('temp_c', 25)
next_state.update_entity(room, {
'temp_c': max(current_temp - 2, params.get('setpoint', 22))
})
elif action_type == 'SEND_ALERT':
next_state.pending_actions.append({'alert_sent': True})
return next_state
# Predict effect of turning on HVAC:
action = {'type': 'TURN_ON_HVAC', 'target': 'hvac_unit_1',
'room': 'server_room', 'params': {'setpoint': 20}}
next_world = transition(world, action)
print('After action:', next_world.entities.get('server_room'))Planejamento lookahead
O planejamento lookahead simula N etapas no futuro antes de se comprometer com uma ação. O agente explora várias sequências de ações, avalia cada estado resultante e escolhe a sequência que leva ao melhor resultado previsto.
def evaluate_state(state: WorldState) -> float:
"""
Compute a scalar utility score for a world state.
Higher = better for the agent's goals.
"""
score = 1.0
server_room = state.entities.get('server_room', {})
temp = server_room.get('temp_c', 25)
# Penalty for high temperature
if temp > 30:
score -= (temp - 30) * 0.2
# Penalty for very low temperature (over-cooling)
if temp < 18:
score -= (18 - temp) * 0.1
return max(0.0, score)
def lookahead(state: WorldState, possible_actions: list, depth: int = 3) -> dict:
"""Evaluate top-level actions by simulating depth steps ahead."""
best_action = None
best_score = -float('inf')
for action in possible_actions:
simulated = transition(state, action)
# Simulate depth more steps (simplified: no branching)
for _ in range(depth - 1):
simulated = transition(simulated, {'type': 'NOOP'})
score = evaluate_state(simulated)
if score > best_score:
best_score = score
best_action = action
return {'best_action': best_action, 'expected_score': round(best_score, 3)}LLM como modelo do mundo
Em ambientes complexos e difíceis de formalizar, o próprio LLM pode servir como modelo do mundo. Peça que ele preveja o que acontecerá se o agente executar uma ação específica. Isso troca precisão por generalidade: o LLM consegue raciocinar sobre domínios arbitrários.
import anthropic
import json
client = anthropic.Anthropic(api_key='YOUR_API_KEY')
def llm_predict(
current_state: dict,
proposed_action: dict,
domain_description: str = ''
) -> dict:
prompt = (
f'Domain: {domain_description}\n\n'
f'Current state: {json.dumps(current_state, indent=2)}\n\n'
f'Proposed action: {json.dumps(proposed_action, indent=2)}\n\n'
'Predict the next world state after this action. '
'Consider direct effects and second-order effects.\n'
'Return JSON: {"predicted_state": dict, '
'"confidence": float, "side_effects": [str]}'
)
response = client.messages.create(
model='claude-opus-4-5', max_tokens=512,
messages=[{'role': 'user', 'content': prompt}]
)
return json.loads(response.content[0].text)Planejamento baseado em modelo versus sem modelo
Baseado em modelo: o agente tem um modelo explícito do mundo, simula estados futuros e planeja. É mais eficiente em termos de amostras e generaliza melhor. Sem modelo: o agente aprende pares ação-valor com base na experiência, sem um modelo. É mais simples, mas exige mais interações para aprender uma política.
# Comparison table
COMPARISON = {
'model_based': {
'pros': [
'Can plan before acting (lookahead)',
'Works well with limited data',
'Interpretable — you can inspect the world model',
'Can simulate counterfactuals'
],
'cons': [
'Model can be wrong (model mismatch)',
'Complex to build for arbitrary domains',
'Planning is computationally expensive'
],
'examples': 'AlphaGo, MCTS, agent with explicit WorldState'
},
'model_free': {
'pros': [
'No need to model the world explicitly',
'Learns from raw experience',
'Simpler architecture'
],
'cons': [
'Requires many interactions to learn',
'Poor generalisation to new scenarios',
'Cannot reason about unseen situations'
],
'examples': 'Q-learning, policy gradient, basic RLHF'
}
}
for approach, info in COMPARISON.items():
print(f'{approach}: {info["examples"]}')uncertainty em modelos do mundo
Os modelos do mundo são aproximações. Leve em conta a uncertainty mantendo uma distribuição de probabilidade sobre estados possíveis, em vez de uma única estimativa pontual. Quando a uncertainty é alta, tome ações conservadoras ou reúna mais informações antes de agir.
from statistics import mean, stdev
@dataclass
class UncertainState:
entity_id: str
attribute: str
samples: list # multiple estimates
def mean(self) -> float:
return mean(self.samples) if self.samples else 0.0
def uncertainty(self) -> float:
if len(self.samples) < 2:
return float('inf')
return stdev(self.samples)
def should_gather_more_data(self, threshold: float = 2.0) -> bool:
return self.uncertainty() > threshold
# Example: uncertain temperature estimate from multiple sensors
temp_state = UncertainState(
entity_id='server_room',
attribute='temp_c',
samples=[22.1, 22.8, 21.9, 34.5, 22.3] # one outlier
)
print(f'Mean temp: {temp_state.mean():.1f}C')
print(f'Uncertainty (stdev): {temp_state.uncertainty():.2f}')
print(f'Gather more data: {temp_state.should_gather_more_data()}')Atualização do modelo do mundo
Depois de cada ação, o agente observa o resultado real e atualiza seu modelo do mundo. Se a previsão estiver errada, o modelo será atualizado para ficar mais preciso. Esse é o ciclo de observar-atualizar-planejar que impulsiona o aprendizado de agentes baseados em modelos.
class WorldModelAgent:
def __init__(self):
self.world = WorldState()
self.prediction_errors = []
def act(self, action: dict) -> dict:
# 1. Predict next state
predicted = transition(self.world, action)
# 2. Take the action in the real world
actual_observation = self._execute_action(action)
# 3. Measure prediction error
for entity_id, attrs in actual_observation.items():
for attr, actual_val in attrs.items():
predicted_val = predicted.entities.get(entity_id, {}).get(attr)
if predicted_val is not None:
error = abs(actual_val - predicted_val)
self.prediction_errors.append(error)
# 4. Update world model with actual observation
for entity_id, attrs in actual_observation.items():
self.world.update_entity(entity_id, attrs)
return actual_observation
def _execute_action(self, action: dict) -> dict:
# Placeholder — in production this calls real APIs/sensors
return {'server_room': {'temp_c': 23.0}}
def model_accuracy(self) -> float:
if not self.prediction_errors:
return 1.0
return max(0.0, 1.0 - mean(self.prediction_errors) / 10)Planejamento com o LLM: simulação de 3 etapas
Em domínios de linguagem natural, peça ao LLM que simule 3 etapas de um plano proposto antes de executá-lo. O LLM avalia o resultado previsto de cada etapa e sinaliza possíveis problemas, impedindo que o agente execute ações com consequências previstas negativas.
import anthropic
import json
client = anthropic.Anthropic(api_key='YOUR_API_KEY')
def simulate_plan_steps(goal: str, proposed_steps: list) -> dict:
steps_str = json.dumps(proposed_steps, indent=2)
prompt = (
f'Goal: {goal}\n\n'
f'Proposed plan steps:\n{steps_str}\n\n'
'Simulate executing each step in order. For each step predict:\n'
'- What changes in the world?\n'
'- What could go wrong?\n'
'- Is this step reversible?\n\n'
'Return JSON: {"step_simulations": [{"step": int, '
'"predicted_outcome": str, "risks": [str], "reversible": bool}], '
'"plan_safe": bool, "recommendation": str}'
)
response = client.messages.create(
model='claude-opus-4-5', max_tokens=1024,
messages=[{'role': 'user', 'content': prompt}]
)
result = json.loads(response.content[0].text)
if not result['plan_safe']:
print(f'Plan safety concern: {result["recommendation"]}')
return resultQuando confiar no modelo do mundo
Um modelo do mundo só é tão bom quanto a precisão de sua função de transição e de seu estado inicial. Em ambientes que mudam rapidamente, o modelo fica desatualizado em pouco tempo. Implemente um limite de desatualização: se o modelo não tiver sido atualizado há N segundos e uma ação for de alto risco, observe o ambiente novamente antes de agir.
from datetime import datetime, timedelta
class StaleAwareWorldModel:
def __init__(self, max_age_seconds: int = 60):
self.state = WorldState()
self.max_age = timedelta(seconds=max_age_seconds)
self.last_observation_time = datetime.utcnow()
def is_stale(self) -> bool:
age = datetime.utcnow() - self.last_observation_time
return age > self.max_age
def refresh(self, observation_fn):
new_observations = observation_fn()
for entity_id, attrs in new_observations.items():
self.state.update_entity(entity_id, attrs)
self.last_observation_time = datetime.utcnow()
print(f'World model refreshed')
def plan_action(self, action: dict, observation_fn) -> dict:
if self.is_stale():
print('World model stale — refreshing before planning')
self.refresh(observation_fn)
return lookahead(self.state, [action], depth=3)Raciocínio contrafactual
Um modelo do mundo permite o raciocínio contrafactual: "O que teria acontecido se eu tivesse realizado a ação A em vez da ação B?" Isso é poderoso para aprender com os erros sem repeti-los — o agente pode simular o cenário contrafactual para entender por que sua escolha levou a um resultado abaixo do ideal.
import anthropic
import json
client = anthropic.Anthropic(api_key='YOUR_API_KEY')
def counterfactual_analysis(
actual_state_before: dict,
action_taken: dict,
actual_outcome: dict,
alternative_action: dict
) -> dict:
prompt = (
'Analyse a counterfactual scenario:\n\n'
f'Initial state: {json.dumps(actual_state_before, indent=2)}\n'
f'Action taken: {json.dumps(action_taken, indent=2)}\n'
f'Actual outcome: {json.dumps(actual_outcome, indent=2)}\n\n'
f'Alternative action considered: {json.dumps(alternative_action, indent=2)}\n\n'
'What would likely have happened with the alternative action?\n'
'Return JSON: {"counterfactual_outcome": str, '
'"better_choice": str, "lesson": str}'
)
response = client.messages.create(
model='claude-opus-4-5', max_tokens=512,
messages=[{'role': 'user', 'content': prompt}]
)
return json.loads(response.content[0].text)Verificação de conhecimento
Qual é a principal vantagem de um agente baseado em modelo em relação a um agente sem modelo?
Recapitulação: modelos do mundo e planejamento preditivo
Excelente trabalho! Principais aprendizados:
- Estado do mundo: retrato de todos os atributos relevantes das entidades em um determinado momento
- Modelo de transição:
next_state = transition(state, action)— prevê os efeitos - Antecipação: simule N etapas à frente, avalie os resultados e escolha a melhor ação
- LLM como modelo do mundo: funciona em domínios difíceis de formalizar
- Incerteza: mantenha distribuições, não estimativas pontuais; evite agir sob alta incerteza
- Desatualização: observe novamente antes de ações de alto risco se o modelo estiver antigo
A seguir: desafios de alinhamento — por que é difícil criar agentes autônomos verdadeiramente benéficos.
Aprenda AI Agents com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 60
- Aulas
- 239
Perguntas Frequentes
A aula “Modelos do mundo e planejamento preditivo” é grátis?
Sim — o texto completo de “Modelos do mundo e planejamento preditivo” é 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 planejamento preditivo”?
Agentes que simulam estados futuros antes de agir: simulação mental para IA. 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 2 de 4.
Quanto tempo leva a aula “Modelos do mundo e planejamento preditivo”?
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
- De assistente a agente autônomo
- Modelos do mundo e planejamento preditivo
- Desafios de alinhamento em agentes autônomos
- Fronteiras da pesquisa: AGI e além