Deep Dive: Agentic AI Patterns – Planner/Executor, ReAct, Toolformer‑Style
Wie machen KI‑Agenten eigentlich ihren Job? Hinter den Kulissen arbeiten drei fundamentale Muster: Planner/Executor, ReAct und Toolformer. Dieser Artikel erklärt, wie sie funktionieren, wo ihre Stärken liegen – und wie du sie in OpenClaw umsetzt.
KI‑Agenten sind mehr als nur große Sprachmodelle mit API‑Zugriff. Sie folgen Architekturmustern, die bestimmen, wie sie denken, planen und handeln. Drei dieser Muster haben sich in den letzten Jahren als besonders wirkungsvoll erwiesen:
- Planner/Executor – Trennung von Denken und Tun
- ReAct (Reasoning + Acting) – Schrittweise Planung im Loop
- Toolformer‑Style – Selbstlernende Tool‑Nutzung
In diesem Deep Dive schauen wir uns jedes Muster genau an: Wie funktioniert es, wo wird es eingesetzt und wie kannst du es in OpenClaw nutzen? Am Ende weißt du, welches Pattern für welche Art von Aufgabe geeignet ist – und wie du es in deinen eigenen Agenten implementierst.
Pattern 1: Planner/Executor – der klassische Zweistufen‑Ansatz
Beim Planner/Executor‑Pattern übernimmt eine Komponente (Planner) die Aufgabenzergliederung und Erstellung eines Aktionsplans, eine andere (Executor) führt die einzelnen Schritte aus. Der Planner denkt voraus, der Executor handelt.
┌─────────────┐ ┌─────────────┐
│ Planner │─────▶│ Executor │
│ (LLM) │ │ (Tools) │
└─────────────┘ └─────────────┘
│ │
„Zerlege die Aufgabe Führe Schritt 1 aus,
in Teil‑Schritte“ dann Schritt 2, …“
Vorteile
- Klare Trennung der Verantwortlichkeiten – der Planner kann komplexe Abhängigkeiten berücksichtigen, ohne sich um Tool‑Details kümmern zu müssen.
- Wiederverwendbare Pläne – einmal generierte Pläne können zwischengespeichert und für ähnliche Aufgaben wiederverwendet werden.
- Einfacheres Debugging – du kannst den Plan inspizieren, bevor er ausgeführt wird.
Nachteile
- Starre Planung – wenn sich die Umgebung ändert, wird der Plan möglicherweise ungültig.
- Overhead – für einfache Aufgaben lohnt der zweistufige Prozess oft nicht.
Praxisbeispiel in OpenClaw
OpenClaw nutzt Planner/Executor implizit, wenn du einen Agenten mit mehreren Tools ausstattest und ihn eine Checkliste abarbeiten lässt. Der Agent denkt zuerst darüber nach, welche Tools er in welcher Reihenfolge benötigt (Planner), dann ruft er sie nacheinander auf (Executor).
# Beispiel‑Konfiguration für einen Planner/Executor‑Agenten
agent:
name: "research_assistant"
planner:
model: "gpt-5-mini"
max_steps: 10
executor:
tools:
- web_search
- pdf_analyze
- summarize
Pattern 2: ReAct – Reasoning und Acting im Wechsel
ReAct (Reasoning + Acting) ist ein interaktives Muster, bei der der Agent in einem Loop abwechselnd denkt und handelt. Nach jedem Schritt bewertet er das Ergebnis und passt seinen nächsten Schritt an.
┌─────────────────────────────────────┐
│ 1. Denken: Was ist das Ziel? │
│ 2. Handeln: Tool‑Aufruf │
│ 3. Beobachten: Resultat │
│ 4. Wiederholen bis Ziel erreicht │
└─────────────────────────────────────┘
ReAct ist besonders gut für dynamische, unbekannte Umgebungen geeignet – etwa wenn der Agent einen Browser steuert und nicht vorhersagen kann, welche Buttons als nächstes erscheinen.
Vorteile
- Anpassungsfähig – reagiert auf unerwartete Ergebnisse.
- Robust – auch bei Teilausfällen von Tools kann der Agent umplanen.
- Mensch‑ähnlich – ähnelt der menschlichen Problemlösung: nachdenken, handeln, beobachten, wiederholen.
Nachteile
- Token‑intensiv – jeder Reasoning‑Schritt kostet zusätzliche Tokens.
- Langsam – viele Iterationen können die Gesamtlaufzeit erhöhen.
Praxisbeispiel in OpenClaw
OpenClaw setzt ReAct standardmäßig ein, wenn ein Agent Tools verwendet. Jeder Tool‑Aufruf wird von einem Reasoning‑Schritt begleitet („Warum rufe ich dieses Tool auf? Was erwarte ich?“). Das lässt sich durch die thinking‑Einstellung steuern:
openclaw agent --message "Finde die neuesten Nachrichten zu KI‑Agenten" --thinking high
Der Agent wird dann vor jedem Tool‑Aufruf einen kurzen „Gedanken“ ausgeben und erst handeln, wenn er sich sicher ist.
Pattern 3: Toolformer‑Style – selbstlernende Tool‑Nutzung
Toolformer ist ein feinabgestimmtes Modell, das gelernt hat, wann und wie es externe Tools (Calculator, Search, Calendar) nutzt. Im Gegensatz zu ReAct wird die Tool‑Nutzung nicht durch explizite Reasoning‑Schritte gesteuert, sondern direkt in die Token‑Generierung integriert.
Das Modell wird auf Texten trainiert, in denen Tool‑Aufrufe als spezielle Tokens eingefügt sind (z. B. [CALC] 2+2 [/CALC]). Es lernt, solche Aufrufe zu generieren, wenn sie nützlich sind – und die Ergebnisse in den weiteren Text einzubauen.
Vorteile
- Seamless Integration – Tool‑Aufrufe fühlen sich wie natürlicher Sprachfluss an.
- Effizient – kein extra Reasoning‑Overhead.
- Skalierbar – neue Tools können durch zusätzliches Training hinzugefügt werden.
Nachteile
- Spezialisiertes Training nötig – nicht jedes Modell beherrscht Toolformer‑Style.
- Starre Tool‑Syntax – Abweichungen von der gelernten Syntax führen zu Fehlern.
Praxisbeispiel in OpenClaw
OpenClaw unterstützt Toolformer‑ähnliche Patterns durch Skill‑Dateien, die dem Agenten präzise Tool‑Beschreibungen liefern. Der Agent lernt nicht selbst, wann er welches Tool nutzt – das übernimmt der Skill‑Author. Aber die nahtlose Integration von Tool‑Ergebnissen in den Kontext ähnelt Toolformer.
# Beispiel‑Skill‑Definition (Auszug)
tools:
- name: "calculator"
description: "Berechnet mathematische Ausdrücke. Syntax: `calc(expression)`."
pattern: "calc\\((.*?)\\)"
Der Agent erkennt calc(2+2) im Prompt, führt die Berechnung aus und fügt das Ergebnis (4) wieder in den Kontext ein – ohne extra Reasoning‑Schritt.
Welches Pattern für welche Aufgabe?
| Muster | Geeignet für | Nicht geeignet für |
|---|---|---|
| Planner/Executor | Aufgaben mit klaren, vorhersehbaren Schritten (z. B. „Lade Daten von API A, transformiere sie, speichere in DB B“). | Dynamische Umgebungen, wo sich die Bedingungen während der Ausführung ändern. |
| ReAct | Exploration, unbekannte Probleme, Umgebungen mit Feedback‑Loop (z. B. Browser‑Automation, Fehlerbehebung). | Hochfrequente, repetitive Tasks (Overhead). |
| Toolformer‑Style | Domänen mit festen Tool‑Sets, bei denen Tool‑Aufrufe häufig und vorhersehbar sind (z. B. Datenabfrage, Kalender‑Management). | Aufgaben, die kreative Abweichungen erfordern oder wo Tools spontan hinzugefügt werden. |
So implementierst du die Patterns in OpenClaw
OpenClaw ist flexibel genug, um alle drei Patterns abzubilden. Die Wahl hängt von deiner Skill‑Definition und der Agent‑Konfiguration ab.
Planner/Executor
- Definiere einen separaten Planner‑Agenten (z. B.
gpt‑5‑mini), der nur Pläne generiert. - Lasse den Hauptagenten (Executor) den Plan Schritt für Schritt abarbeiten.
- Nutze Sub‑Agents für komplexe Plan‑Ausführungen.
ReAct
- Aktiviere
thinking: highin der Agent‑Konfiguration. - Gib dem Agenten Werkzeuge, die Rückmeldung geben (z. B.
execmit Output,browsermit Screenshot). - Lasse den Agenten nach jedem Schritt kurz reflektieren („Was hat das Tool geliefert? Was ist der nächste Schritt?“).
Toolformer‑Style
- Erstelle präzise Tool‑Beschreibungen in deinen Skill‑Dateien.
- Trainiere (feintune) gegebenenfalls ein spezielles Modell auf deine Tool‑Syntax (aufwändig, aber mächtig).
- Nutze Pattern‑Matching im Prompt, um Tool‑Aufrufe automatisch zu erkennen und auszuführen.
Fazit: Pattern als Baukasten
Agentic AI Patterns sind kein entweder‑oder. Du kannst sie kombinieren: Ein Planner generiert einen groben Plan, der Executor arbeitet im ReAct‑Style, und für bestimmte Unteraufgaben kommen Toolformer‑ähnliche Spezialskills zum Einsatz.
OpenClaws Stärke liegt in dieser Flexibilität – du musst dich nicht für ein einziges Pattern entscheiden, sondern kannst je nach Task das passende Werkzeug auswählen. Beginne mit einfachen ReAct‑Abläufen und steigere dich zu mehrstufigen Planner/Executor‑Setup, sobald deine Anforderungen wachsen.
Die wichtigste Erkenntnis: Patterns sind keine Magie. Sie sind bewährte Blaupausen, die dir helfen, komplexe Agenten‑Logik strukturiert und wartbar zu implementieren.
Quellen & weiterführende Links
- IBM: What is a ReAct Agent? – Einführung in das ReAct‑Pattern
- Meta Research: Toolformer – Original‑Paper zum selbstlernenden Tool‑Use
- Google Cloud: Choose a design pattern for your agentic AI system – Überblick über weitere Patterns (Reflection, Hierarchical Planning)
- arXiv: Toolformer: Language Models Can Teach Themselves to Use Tools – Technische Details und Evaluierung
- OpenClaw Skills Documentation – Wie du eigene Skills für verschiedene Patterns baust
Dieser Artikel erschien zuerst auf agentenlog.de. Wenn du Fragen zu Agentic AI Patterns hast oder eigene Erfahrungen teilen möchtest, schreib mir gerne auf Mastodon oder per E‑Mail.