Mehrschrittige Konversationsdesigns: komplexe Workflows mit Claude strukturieren

1. Warum eine Anfrage fuer komplexe Aufgaben nicht reicht

Ein einzelner Prompt funktioniert gut fuer klar umrissene Aufgaben mit einer eindeutigen Antwort. Sobald ein Prozess jedoch mehrere Entscheidungen, Zwischenergebnisse oder externe Datenabfragen erfordert, stoesst eine einzelne Anfrage an ihre Grenzen. Ein mehrschrittiges Konversationsdesign zerlegt die Gesamtaufgabe in kleinere, klar definierte Etappen, die jeweils auf dem Ergebnis der vorherigen Etappe aufbauen.

Der Vorteil eines mehrschrittigen Konversationsdesigns liegt nicht nur in der besseren Antwortqualitaet pro Schritt, sondern vor allem in der Nachvollziehbarkeit: jeder Zwischenschritt kann geloggt, validiert und bei Bedarf isoliert wiederholt werden, ohne den gesamten Prozess neu zu starten. Bei einem monolithischen Prompt, der alles auf einmal erledigen soll, ist ein Fehler mitten im Prozess dagegen schwer zu lokalisieren und noch schwerer gezielt zu korrigieren.

Dieser Artikel zeigt, wie Zustandsverwaltung, Nachrichtenverlauf und Kontrollfluss in einem mehrschrittigen Konversationsdesign konkret aufgebaut werden, welche Muster sich fuer typische Workflows bewaehrt haben, und wo Human-in-the-Loop Pruefungen sinnvoll eingebaut werden.

2. Zustandsverwaltung: was zwischen den Schritten erhalten bleibt

Die Claude API selbst ist zustandslos: jede Anfrage enthaelt den kompletten bisherigen Verlauf, den die Anwendung selbst verwalten muss. Ein mehrschrittiges Konversationsdesign braucht deshalb eine klare Trennung zwischen dem Gespraechsverlauf, der an Claude geschickt wird, und dem Anwendungszustand, der ausserhalb der Konversation gepflegt wird, etwa in welcher Etappe des Prozesses sich der Ablauf gerade befindet.

Ein bewaehrtes Muster ist ein explizites Zustandsobjekt, das neben dem Nachrichtenverlauf auch strukturierte Zwischenergebnisse haelt: den aktuellen Schritt, bereits gesammelte Daten, und offene Entscheidungen. Dieses Zustandsobjekt wird bei jedem Schritt aktualisiert und kann bei einem Absturz oder einer Unterbrechung persistiert und spaeter fortgesetzt werden, ohne dass die Konversation von vorne beginnen muss.

from dataclasses import dataclass, field
from enum import Enum

class WorkflowStep(Enum):
    GATHER_REQUIREMENTS = "gather_requirements"
    DRAFT_SOLUTION = "draft_solution"
    REVIEW = "review"
    FINALIZE = "finalize"

@dataclass
class ConversationState:
    """Explicit application state, separate from the raw message history."""
    current_step: WorkflowStep = WorkflowStep.GATHER_REQUIREMENTS
    collected_data: dict = field(default_factory=dict)
    messages: list = field(default_factory=list)
    open_questions: list[str] = field(default_factory=list)

    def advance(self, next_step: WorkflowStep) -> None:
        """Move the workflow forward and log the transition."""
        print(f"Transitioning: {self.current_step.value} -> {next_step.value}")
        self.current_step = next_step

    def to_dict(self) -> dict:
        """Serialize state for persistence between sessions."""
        return {
            "current_step": self.current_step.value,
            "collected_data": self.collected_data,
            "messages": self.messages,
            "open_questions": self.open_questions,
        }

3. Nachrichtenverlauf als Gedaechtnis der Konversation

Der Nachrichtenverlauf ist das eigentliche Gedaechtnis eines mehrschrittigen Konversationsdesigns: jede Nutzernachricht und jede Claude Antwort wird an die Liste angehaengt und bei der naechsten Anfrage vollstaendig mitgeschickt. Ohne diesen Verlauf haette Claude bei jedem Schritt keinerlei Erinnerung an vorherige Entscheidungen, gesammelte Informationen oder bereits abgelehnte Alternativen.

Ein haeufiger Fehler ist, den Nachrichtenverlauf unreflektiert wachsen zu lassen, ohne zu pruefen, welche Teile fuer den aktuellen Schritt tatsaechlich relevant sind. Bei einem mehrschrittigen Konversationsdesign mit vielen Etappen lohnt sich eine gezielte Kuratierung: Zwischenschritte, die fuer die aktuelle Entscheidung nicht mehr relevant sind, koennen komprimiert oder durch eine kurze Zusammenfassung ersetzt werden, um den Kontext schlank und fokussiert zu halten, ohne wichtige Informationen zu verlieren.

4. Kontrollfluss zwischen den Etappen steuern

Der Kontrollfluss bestimmt, welcher Schritt als naechstes ausgefuehrt wird, basierend auf dem Ergebnis des vorherigen Schritts. Ein einfaches, aber wirksames Muster nutzt Tool Use, damit Claude selbst signalisiert, welcher naechste Schritt sinnvoll ist, statt dass die Anwendung diese Entscheidung anhand von Textmustern rekonstruieren muss. Ein Tool advance_workflow mit einem Enum Feld fuer den naechsten Schritt macht diese Entscheidung explizit und maschinenlesbar.

Fuer Prozesse mit klaren, vorhersehbaren Etappen eignet sich ein linearer Kontrollfluss, bei dem die Anwendung selbst die Reihenfolge der Schritte vorgibt und Claude lediglich innerhalb jeder Etappe die inhaltliche Arbeit erledigt. Fuer Prozesse mit variabler Reihenfolge, etwa eine Diagnose, bei der abhaengig vom Ergebnis unterschiedliche naechste Schritte sinnvoll sind, eignet sich ein verzweigter Kontrollfluss, bei dem Claude selbst ueber Tool Use den naechsten Schritt bestimmt.

import anthropic

client = anthropic.Anthropic()

advance_tool = {
    "name": "advance_workflow",
    "description": "Signal which workflow step should run next",
    "input_schema": {
        "type": "object",
        "properties": {
            "next_step": {
                "type": "string",
                "enum": ["gather_requirements", "draft_solution", "review", "finalize"]
            },
            "reasoning": {"type": "string", "description": "Why this step is next"}
        },
        "required": ["next_step", "reasoning"]
    }
}

def run_step(state: ConversationState) -> ConversationState:
    """Execute one workflow step and let Claude decide the next transition."""
    state.messages.append({"role": "user", "content": build_step_prompt(state)})

    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        tools=[advance_tool],
        tool_choice={"type": "tool", "name": "advance_workflow"},
        messages=state.messages,
    )

    decision = next(b.input for b in response.content if b.type == "tool_use")
    state.messages.append({"role": "assistant", "content": response.content})
    state.advance(WorkflowStep(decision["next_step"]))
    return state

5. Zwischenpruefung und Human-in-the-Loop

Nicht jede Etappe eines mehrschrittigen Konversationsdesigns sollte vollautomatisch ablaufen. Bei Prozessen mit finanziellen, rechtlichen oder sicherheitsrelevanten Konsequenzen ist eine explizite Freigabe durch einen Menschen vor dem naechsten Schritt sinnvoll. Das Design sollte solche Pruefpunkte als eigene Etappe modellieren, in der der Prozess pausiert und auf eine externe Bestaetigung wartet, statt die Pruefung als Nebeneffekt in eine bestehende Etappe zu quetschen.

Ein bewaehrtes Muster: Claude generiert am Ende einer Etappe eine kompakte Zusammenfassung der bisherigen Entscheidungen und der vorgeschlagenen naechsten Schritte, die einem Menschen zur Freigabe vorgelegt wird. Erst nach expliziter Bestaetigung wird der Prozessschritt fortgesetzt, mit der Bestaetigung als zusaetzlicher Kontext fuer den naechsten Claude Aufruf. Diese Zwischenpruefung verhindert, dass Fehler aus einer fruehen Etappe unbemerkt in nachfolgende Etappen des mehrschrittigen Konversationsdesigns propagieren.

CRITICAL_STEPS = {WorkflowStep.FINALIZE}

def request_human_approval(state: ConversationState, proposed_summary: str) -> bool:
    """Pause the workflow and wait for an explicit external confirmation."""
    print(f"--- Approval required before step: {state.current_step.value} ---")
    print(proposed_summary)
    decision = input("Approve and continue? [y/N]: ").strip().lower()
    return decision == "y"

def run_step_with_gate(state: ConversationState) -> ConversationState:
    """Run a step, and if it is critical, gate it on human approval."""
    state = run_step(state)  # from the control flow example above

    if state.current_step in CRITICAL_STEPS:
        summary = summarize_state_for_human(state)  # application specific
        if not request_human_approval(state, summary):
            raise RuntimeError("Workflow halted: human approval declined")

    return state

6. Fehlerbehandlung ueber mehrere Schritte hinweg

Fehler in einem mehrschrittigen Konversationsdesign koennen an jeder Etappe auftreten: ein Tool Aufruf schlaegt fehl, eine externe API antwortet nicht, oder Claude liefert eine Antwort, die nicht dem erwarteten Format entspricht. Ohne explizite Fehlerbehandlung propagiert ein Fehler aus einer fruehen Etappe unbemerkt in alle nachfolgenden Schritte und fuehrt zu einem Endergebnis, das auf einer fehlerhaften Grundlage basiert.

Jede Etappe sollte deshalb ihre eigene Validierung vor der Weitergabe an die naechste Etappe durchfuehren, und im Fehlerfall eine definierte Ruecksprungmoeglichkeit anbieten: entweder ein Retry der aktuellen Etappe mit angereichertem Kontext, oder ein kontrollierter Ruecksprung zu einer fruehen, bekannt guten Etappe. Ein Zustandsobjekt, das nach jeder erfolgreichen Etappe persistiert wird, macht diesen Ruecksprung technisch einfach, weil der letzte valide Zustand jederzeit verfuegbar ist.

import copy

checkpoint_history: list[ConversationState] = []

def persist_checkpoint(state: ConversationState) -> None:
    """Save a deep copy after every successful step, for rollback on failure."""
    checkpoint_history.append(copy.deepcopy(state))

def run_step_with_recovery(state: ConversationState, max_retries: int = 1) -> ConversationState:
    """Retry the current step once, then roll back to the last good checkpoint."""
    for attempt in range(max_retries + 1):
        try:
            new_state = run_step(state)
            persist_checkpoint(new_state)
            return new_state
        except Exception as error:
            print(f"Step failed on attempt {attempt}: {error}")
            if attempt == max_retries:
                if not checkpoint_history:
                    raise
                print("Rolling back to last known good checkpoint.")
                return checkpoint_history[-1]
    return state

7. Kontextlaenge und Zusammenfassungsstrategien

Mit wachsender Anzahl von Etappen waechst auch der Nachrichtenverlauf, und irgendwann naehert sich ein mehrschrittiges Konversationsdesign den Grenzen des Context Windows. Statt den gesamten Verlauf unveraendert mitzuschleppen, lohnt sich eine gezielte Zusammenfassungsstrategie: abgeschlossene, fuer den weiteren Verlauf nicht mehr entscheidende Etappen werden durch eine kompakte, von Claude selbst erzeugte Zusammenfassung ersetzt.

Diese Zusammenfassung sollte die wesentlichen Entscheidungen und Daten enthalten, aber nicht den vollstaendigen Wortlaut der urspruenglichen Interaktion. Ein praktischer Ansatz laesst Claude am Ende jeder Etappe selbst eine strukturierte Zusammenfassung im JSON Format erzeugen, die dann anstelle der ausfuehrlichen Nachrichten dieser Etappe im weiteren Verlauf verwendet wird. So bleibt der Kontext auch bei langen mehrschrittigen Konversationsdesigns handhabbar.

def compress_completed_stage(state: ConversationState, stage_messages: list) -> None:
    """Replace verbose messages of a finished stage with a compact summary."""
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=300,
        messages=stage_messages + [{
            "role": "user",
            "content": "Summarize the key decisions and data from this stage as compact JSON."
        }]
    )
    summary_text = response.content[0].text

    # Drop the verbose exchange, keep only the compact summary in history
    state.messages = [m for m in state.messages if m not in stage_messages]
    state.messages.append({"role": "user", "content": f"Prior stage summary: {summary_text}"})

8. Bewaehrte Konversationsmuster fuer typische Workflows

Fuer wiederkehrende Anwendungsfaelle haben sich einige Muster fuer mehrschrittige Konversationsdesigns etabliert. Das "Sammeln, Entwerfen, Pruefen" Muster eignet sich fuer Erstellungsprozesse: zuerst werden Anforderungen gesammelt, dann ein Entwurf erstellt, dann gegen die Anforderungen geprueft, mit optionaler Rueckkopplung zur Sammelphase bei Luecken. Das "Plan dann Ausfuehrung" Muster trennt eine Planungsphase, in der Claude die Schritte vorab skizziert, strikt von der Ausfuehrungsphase, in der jeder geplante Schritt einzeln abgearbeitet wird.

Ein drittes Muster, das "iterative Verfeinerung" Design, eignet sich fuer kreative oder analytische Aufgaben, bei denen ein erster Entwurf schrittweise verbessert wird: jede Etappe erhaelt gezieltes Feedback zur vorherigen Version und produziert eine verbesserte Fassung, bis ein Abbruchkriterium erreicht ist. Alle drei Muster teilen die Grundidee eines mehrschrittigen Konversationsdesigns: klar abgegrenzte Etappen mit explizitem Zustand statt einer einzigen, ueberladenen Anfrage.

9. Designs im Vergleich: linear, verzweigt, iterativ

Die Wahl des passenden Konversationsdesigns haengt von der Struktur des zugrunde liegenden Prozesses ab. Die folgende Tabelle stellt die drei gaengigen Grunddesigns gegenueber.

In der Praxis kombinieren viele reale Anwendungen Elemente aller drei Designs: ein grober linearer Rahmen mit einzelnen verzweigten Entscheidungspunkten und einer iterativen Verfeinerungsschleife innerhalb einer einzelnen Etappe. Wichtig ist, das Design bewusst zu waehlen, statt es implizit aus einer wachsenden Anzahl von Sonderfaellen im Prompt entstehen zu lassen.

10. Zusammenfassung

Mehrschrittige Konversationsdesigns zerlegen komplexe Aufgaben in nachvollziehbare Etappen mit explizitem Zustand statt einer einzigen ueberladenen Anfrage. Ein separates Zustandsobjekt haelt Prozessfortschritt, gesammelte Daten und offene Fragen unabhaengig vom rohen Nachrichtenverlauf. Kontrollfluss kann linear von der Anwendung vorgegeben oder von Claude selbst ueber Tool Use bestimmt werden, je nach Vorhersehbarkeit des Prozesses.

Human-in-the-Loop Pruefpunkte vor kritischen Entscheidungen, robuste Fehlerbehandlung mit definierten Ruecksprungpunkten, und Zusammenfassungsstrategien gegen wachsende Kontextlaenge sind die drei wichtigsten Bausteine fuer produktionsreife mehrschrittige Konversationsdesigns. Wer diese Bausteine von Anfang an einplant, baut Workflows, die auch bei laengeren, komplexeren Prozessen nachvollziehbar und wartbar bleiben.

11. FAQ: Mehrschrittige Konversationsdesigns