Modelos del mundo y planificación predictiva
Agentes que simulan estados futuros antes de actuar: simulación mental para la IA.
Modelos del mundo y planificación predictiva es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.
¿Qué es un modelo del mundo?
Un modelo del mundo es la representación interna que tiene el agente del entorno: qué objetos existen, cuál es su estado, qué reglas rigen sus cambios y qué puede hacer el agente para afectarlos. Es la simulación mental que el agente hace del mundo.
Sin un modelo del mundo, el agente solo puede reaccionar ante las observaciones. Con uno, puede predecir y planificar.
Representación del estado del mundo
El estado del mundo es una instantánea de todos los hechos relevantes del entorno en un momento determinado. Para un agente de IoT, podrían ser las lecturas actuales de los sensores y los estados de los dispositivos. Para un agente de software, podría ser el estado de los archivos, las API y las bases de datos que administra.
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 transición
Un modelo de transición define cómo cambia el estado del mundo en respuesta a una acción: next_state = transition(current_state, action). Permite al agente predecir cómo será el mundo después de realizar una acción sin llevarla a cabo realmente.
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'))Planificación con anticipación
La planificación con anticipación simula N pasos hacia el futuro antes de comprometerse con una acción. El agente explora varias secuencias de acciones, evalúa cada estado resultante y elige la secuencia que conduce al mejor 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)}El LLM como modelo del mundo
En entornos complejos y difíciles de formalizar, el propio LLM puede servir como modelo del mundo. Pídale que prediga qué ocurrirá si el agente realiza una acción concreta. Esto sacrifica precisión a cambio de generalidad: el LLM puede razonar sobre dominios arbitrarios.
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)Planificación basada en modelos frente a planificación sin modelos
Basada en modelos: el agente tiene un modelo explícito del mundo, simula estados futuros y planifica. Es más eficiente en cuanto a muestras y generaliza mejor. Sin modelos: el agente aprende pares acción-valor a partir de la experiencia sin utilizar un modelo. Es más sencillo, pero requiere más interacciones para aprender una 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"]}')Incertidumbre en los modelos del mundo
Los modelos del mundo son aproximaciones. Tenga en cuenta la incertidumbre manteniendo una distribución de probabilidad sobre los estados posibles en lugar de una única estimación puntual. Cuando la incertidumbre sea alta, adopte acciones conservadoras o recopile más información antes de actuar.
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()}')Actualización del modelo del mundo
Después de cada acción, el agente observa el resultado real y actualiza su modelo del mundo. Si la predicción era incorrecta, el modelo se actualiza para ser más preciso. Este es el ciclo de observar-actualizar-planificar que impulsa el aprendizaje de agentes basados en 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)Planificación con el LLM: simular 3 pasos
En dominios de lenguaje natural, pida al LLM que simule 3 pasos de un plan propuesto antes de ejecutarlo. El LLM evalúa el resultado previsto de cada paso y señala posibles problemas, lo que evita que el agente realice acciones con consecuencias 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 resultCuándo confiar en el modelo del mundo
Un modelo del mundo solo es tan bueno como la precisión de su función de transición y su estado inicial. En entornos que cambian rápidamente, el modelo se desactualiza pronto. Implemente un umbral de obsolescencia: si el modelo no se ha actualizado durante N segundos y una acción implica mucho riesgo, vuelva a observar primero el entorno.
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)Razonamiento contrafactual
Un modelo del mundo permite el razonamiento contrafactual: «¿Qué habría ocurrido si hubiera realizado la acción A en lugar de la acción B?» Esto resulta muy útil para aprender de los errores sin repetirlos: el agente puede simular el contrafactual para comprender por qué su elección produjo un resultado subóptimo.
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)Comprobación de conocimientos
¿Cuál es la principal ventaja de un agente basado en modelos frente a un agente sin modelo?
Resumen: modelos del mundo y planificación predictiva
¡Excelente trabajo! Ideas clave:
- Estado del mundo: instantánea de todos los atributos relevantes de las entidades en un momento determinado
- Modelo de transición:
next_state = transition(state, action)— predice los efectos - Anticipación: simular N pasos por adelantado, evaluar los resultados y elegir la mejor acción
- LLM como modelo del mundo: resulta útil en dominios difíciles de formalizar
- Incertidumbre: mantener distribuciones, no estimaciones puntuales; evitar actuar cuando la incertidumbre sea alta
- Obsolescencia: volver a observar antes de realizar acciones de alto riesgo si el modelo está desactualizado
A continuación: desafíos de alineación: por qué es difícil crear agentes autónomos que sean realmente beneficiosos.
Aprende AI Agents con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 60
- Lecciones
- 239
Preguntas frecuentes
¿La lección «Modelos del mundo y planificación predictiva» es gratis?
Sí — el texto completo de «Modelos del mundo y planificación predictiva» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.
¿Qué aprenderé en «Modelos del mundo y planificación predictiva»?
Agentes que simulan estados futuros antes de actuar: simulación mental para la IA. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Agents?
No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Modelos del mundo y planificación predictiva»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Agents?
Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Del asistente al agente autónomo
- Modelos del mundo y planificación predictiva
- Retos de alineación en agentes autónomos
- Fronteras de la investigación: AGI y más allá