Wereldmodellen en voorspellende planning
Agents die toekomstige toestanden simuleren voordat ze handelen: mentale simulatie voor AI.
Wereldmodellen en voorspellende planning is een gratis AI-agenten-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-agenten. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-agenten bevat in totaal 4 lessen.
Wat is een wereldmodel?
Een wereldmodel is de interne representatie van de omgeving door de agent: welke objecten bestaan, wat hun status is, welke regels bepalen hoe ze veranderen en wat de agent kan doen om ze te beïnvloeden. Het is de mentale simulatie van de wereld door de agent.
Zonder wereldmodel kan de agent alleen op waarnemingen reageren. Met een wereldmodel kan de agent voorspellen en plannen.
Representatie van de wereldtoestand
Een wereldtoestand is een momentopname van alle relevante feiten over de omgeving op een bepaald moment. Voor een IoT-agent kunnen dat actuele sensormetingen en apparaatstatussen zijn. Voor een softwareagent kan het gaan om de toestand van bestanden, API's en databases die de agent beheert.
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())Overgangsmodel
Een overgangsmodel definieert hoe de wereldtoestand verandert als reactie op een actie: next_state = transition(current_state, action). Hiermee kan de agent voorspellen hoe de wereld eruitziet nadat hij een actie heeft uitgevoerd, zonder die actie daadwerkelijk uit te voeren.
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'))Vooruitkijkplanning
Bij vooruitkijkplanning worden N stappen in de toekomst gesimuleerd voordat een actie wordt uitgevoerd. De agent onderzoekt meerdere actiereeksen, beoordeelt elke daaruit voortvloeiende toestand en kiest de reeks die naar verwachting tot het beste resultaat leidt.
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 als wereldmodel
Voor complexe omgevingen die moeilijk te formaliseren zijn, kan de LLM zelf als wereldmodel dienen. Vraag de LLM om te voorspellen wat er gebeurt als de agent een specifieke actie uitvoert. Dit ruilt precisie in voor algemene toepasbaarheid: de LLM kan over willekeurige domeinen redeneren.
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)Modelgebaseerde versus modelvrije planning
Modelgebaseerd: de agent heeft een expliciet wereldmodel, simuleert toekomstige toestanden en maakt een plan. Dit vereist minder voorbeelden en generaliseert beter. Modelvrij: de agent leert actie-waardekoppelingen uit ervaring zonder model. Dit is eenvoudiger, maar vereist meer interacties om een beleid te leren.
# 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"]}')Onzekerheid in wereldmodellen
Wereldmodellen zijn benaderingen. Houd rekening met onzekerheid door een kansverdeling over mogelijke toestanden bij te houden in plaats van één puntschatting. Neem bij grote onzekerheid voorzichtige acties of verzamel eerst meer informatie.
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()}')Het wereldmodel bijwerken
Na elke actie observeert de agent het werkelijke resultaat en werkt hij zijn wereldmodel bij. Als de voorspelling onjuist was, wordt het model aangepast om nauwkeuriger te worden. Dit is de cyclus observeren-bijwerken-plannen die het leren van modelgebaseerde agents aanstuurt.
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)Plannen met de LLM: 3 stappen simuleren
Vraag de LLM voor domeinen in natuurlijke taal om 3 stappen van een voorgesteld plan te simuleren voordat je het uitvoert. De LLM beoordeelt het voorspelde resultaat van elke stap en signaleert mogelijke problemen. Zo voorkom je dat de agent acties uitvoert met naar verwachting nadelige gevolgen.
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 resultWanneer je het wereldmodel kunt vertrouwen
Een wereldmodel is slechts zo goed als de nauwkeurigheid van zijn overgangsfunctie en begintoestand. In snel veranderende omgevingen raakt het model snel verouderd. Bouw een verouderingsdrempel in: als het model gedurende N seconden niet is bijgewerkt en een actie grote gevolgen heeft, observeer je de omgeving eerst opnieuw.
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)Contrafeitelijk redeneren
Een wereldmodel maakt contrafeitelijk redeneren mogelijk: 'Wat zou er zijn gebeurd als ik actie A had ondernomen in plaats van actie B?' Dit is krachtig om van fouten te leren zonder ze opnieuw te maken — de agent kan de contrafeitelijke situatie simuleren om te begrijpen waarom zijn keuze tot een niet-optimale uitkomst leidde.
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)Kennischeck
Wat is het belangrijkste voordeel van een modelgebaseerde agent ten opzichte van een modelvrije agent?
Samenvatting: wereldmodellen en voorspellende planning
Goed gedaan! De belangrijkste punten:
- Wereldtoestand: momentopname van alle relevante kenmerken van entiteiten op een bepaald moment
- Overgangsmodel:
next_state = transition(state, action)— voorspelt gevolgen - Vooruitkijken: simuleer N stappen vooruit, beoordeel de uitkomsten en kies de beste actie
- LLM als wereldmodel: werkt voor domeinen die moeilijk te formaliseren zijn
- Onzekerheid: houd verdelingen bij in plaats van puntschattingen; onderneem geen actie bij grote onzekerheid
- Veroudering: observeer opnieuw vóór acties met grote gevolgen als het model verouderd is
Hierna: uitdagingen rond afstemming — waarom het moeilijk is om echt voordelige autonome agenten te bouwen.
Leer AI-agenten met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 60
- Lessen
- 239
Veelgestelde vragen
Is de les “Wereldmodellen en voorspellende planning” gratis?
Ja — de volledige tekst van “Wereldmodellen en voorspellende planning” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus AI-agenten wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus AI-agenten bevat in totaal 4 lessen.
Wat leer ik in “Wereldmodellen en voorspellende planning”?
Agents die toekomstige toestanden simuleren voordat ze handelen: mentale simulatie voor AI. Je oefent met AI-agenten door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met AI-agenten te beginnen?
Ervaring vooraf is niet nodig. AI-agenten op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Wereldmodellen en voorspellende planning”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over AI-agenten?
Ja. Elke les over AI-agenten bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Van assistent naar autonome agent
- Wereldmodellen en voorspellende planning
- Uitdagingen rond alignment bij autonome agents
- Onderzoeksfrontier: AGI en verder