0Pricing
AI Agents · Lektion

Weltmodelle und prädiktive Planung

Agenten, die zukünftige Zustände vor einer Aktion simulieren: mentale Simulation für KI.

Weltmodelle und prädiktive Planung ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Weltmodell?

Ein Weltmodell ist die interne Repräsentation der Umgebung durch den Agenten: welche Objekte existieren, welche Zustände sie haben, welche Regeln ihre Veränderungen bestimmen und wie der Agent auf sie einwirken kann. Es ist die mentale Simulation der Welt durch den Agenten.

Ohne Weltmodell kann der Agent nur auf Beobachtungen reagieren. Mit einem Weltmodell kann er vorhersagen und planen.

Darstellung des Weltzustands

Ein Weltzustand ist eine Momentaufnahme aller relevanten Fakten über die Umgebung zu einem bestimmten Zeitpunkt. Bei einem IoT-Agenten können dies aktuelle Sensormesswerte und Gerätezustände sein. Bei einem Software-Agenten kann es sich um den Zustand der von ihm verwalteten Dateien, APIs und Datenbanken handeln.

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())

Übergangsmodell

Ein Übergangsmodell definiert, wie sich der Weltzustand als Reaktion auf eine Aktion verändert: next_state = transition(current_state, action). Es ermöglicht dem Agenten vorherzusagen, wie die Welt nach einer Aktion aussehen wird, ohne diese tatsächlich auszuführen.

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'))

Vorausplanung

Bei der Vorausplanung werden N Schritte in die Zukunft simuliert, bevor eine Aktion ausgeführt wird. Der Agent untersucht mehrere Aktionsfolgen, bewertet jeden daraus resultierenden Zustand und wählt die Folge aus, die voraussichtlich zum besten Ergebnis führt.

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 Weltmodell

In komplexen, schwer zu formalisierenden Umgebungen kann das LLM selbst als Weltmodell dienen. Bitten Sie es vorherzusagen, was geschieht, wenn der Agent eine bestimmte Aktion ausführt. Das tauscht Präzision gegen Allgemeingültigkeit ein – das LLM kann über beliebige Fachgebiete hinweg schlussfolgern.

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)

Modellbasierte und modellfreie Planung

Modellbasiert: Der Agent verfügt über ein explizites Weltmodell, simuliert zukünftige Zustände und plant. Das ist stichprobeneffizienter und generalisiert besser. Modellfrei: Der Agent lernt Aktions-Wert-Paare aus Erfahrungen, ohne ein Modell zu verwenden. Das ist einfacher, erfordert aber mehr Interaktionen, um eine Strategie zu erlernen.

# 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"]}')

Unsicherheit in Weltmodellen

Weltmodelle sind Näherungen. Berücksichtigen Sie Unsicherheit, indem Sie eine Wahrscheinlichkeitsverteilung über mögliche Zustände statt einer einzelnen Punktschätzung verwalten. Bei hoher Unsicherheit sollten Sie konservative Aktionen ausführen oder vor dem Handeln weitere Informationen sammeln.

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()}')

Das Weltmodell aktualisieren

Nach jeder Aktion beobachtet der Agent das tatsächliche Ergebnis und aktualisiert sein Weltmodell. War die Vorhersage falsch, wird das Modell angepasst, damit es genauer wird. Dieser Zyklus des Beobachtens, Aktualisierens und Planens treibt das modellbasierte Lernen des Agents voran.

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)

Planung mit dem LLM: 3 Schritte simulieren

Bitten Sie das LLM in Anwendungsbereichen mit natürlicher Sprache, vor der Ausführung drei Schritte eines vorgeschlagenen Plans zu simulieren. Das LLM bewertet das vorhergesagte Ergebnis jedes Schritts und weist auf mögliche Probleme hin – so wird verhindert, dass der Agent Aktionen mit voraussichtlich negativen Folgen ausführt.

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 result

Wann Sie dem Weltmodell vertrauen können

Ein Weltmodell ist nur so gut wie die Genauigkeit seiner Übergangsfunktion und seines Anfangszustands. In sich schnell verändernden Umgebungen veraltet das Modell rasch. Implementieren Sie einen Schwellenwert für Veraltung: Wenn das Modell seit N Sekunden nicht aktualisiert wurde und eine Aktion risikoreich ist, beobachten Sie die Umgebung zunächst erneut.

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)

Kontrafaktisches Denken

Ein Weltmodell ermöglicht kontrafaktisches Denken: „Was wäre passiert, wenn ich statt Handlung B Handlung A ausgeführt hätte?“ Das ist hilfreich, um aus Fehlern zu lernen, ohne sie zu wiederholen – der Agent kann das kontrafaktische Szenario simulieren, um zu verstehen, warum seine Entscheidung zu einem suboptimalen Ergebnis geführt hat.

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)

Wissensüberprüfung

Was ist der Hauptvorteil eines modellbasierten Agenten gegenüber einem modellfreien Agenten?

Zusammenfassung: Weltmodelle und vorausschauende Planung

Sehr gute Arbeit! Die wichtigsten Erkenntnisse:

  • Weltzustand: Momentaufnahme aller relevanten Attribute von Entitäten zu einem bestimmten Zeitpunkt
  • Übergangsmodell: next_state = transition(state, action) – sagt Auswirkungen voraus
  • Vorausschau: N Schritte im Voraus simulieren, Ergebnisse bewerten und die beste Aktion auswählen
  • LLM als Weltmodell: eignet sich für schwer zu formalisierende Bereiche
  • Unsicherheit: Verteilungen statt Punktschätzungen verwalten; bei hoher Unsicherheit keine Aktion ausführen
  • Veraltung: Vor risikoreichen Aktionen die Umgebung erneut beobachten, wenn das Modell veraltet ist

Als Nächstes: Alignment-Herausforderungen – warum es schwierig ist, wirklich nützliche autonome Agenten zu entwickeln.

Häufig gestellte Fragen

Ist die Lektion „Weltmodelle und prädiktive Planung“ kostenlos?

Ja — der vollständige Text von „Weltmodelle und prädiktive Planung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Weltmodelle und prädiktive Planung“?

Agenten, die zukünftige Zustände vor einer Aktion simulieren: mentale Simulation für KI. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Weltmodelle und prädiktive Planung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Vom Assistenten zum autonomen Agenten
  2. Weltmodelle und prädiktive Planung
  3. Alignment-Herausforderungen bei autonomen Agenten
  4. Forschungsgrenzen: AGI und darüber hinaus
← Zurück zu AI Agents