Pausieren und Wiederaufnehmen von LangGraph-Agenten mit interrupt() und Befehl
Wie LangGraphs interrupt() und Command auf Checkpoints sowie Threads zurückgreifen, um einen Agenten zum Anhalten für menschliche Genehmigung, Änderungen oder Eingaben zu bringen und ihn anschließend sicher wieder in Betrieb zu nehmen.
Ein Agent, der Geld verschieben, Ressourcen löschen oder in die Produktion einsetzen kann, sollte nicht immer die Möglichkeit haben, das zu beenden, was er begonnen hat. Manchmal muss der Graph absichtlich stoppen, stundenlang auf eine Person warten und anschließend genau da weitermachen, wo er aufgehört hat. Dieser Artikel erklärt, wie LangGraph dies mit interrupt() und Command erreicht, warum er auf Checkpoints und Threads angewiesen ist sowie welche Entscheidungen Sie vor dem Einsatz von HITL-Agenten in der Produktion noch selbst treffen müssen.
Die zugrundeliegenden Bausteine
HITL basiert auf drei Schichten. Erstens die Graphausführung: Der Zustand gelangt in einen Knoten, und eine Kante wählt den nächsten Knoten aus.
STATE
↓
NODE
↓
EDGE
↓
NEXT NODE
Zweitens die Zustandsverwaltung: Knoten liefern Aktualisierungen, und Reducer fügen diese zum neuen Zustand zusammen.
NODE
↓
STATE UPDATE
↓
REDUCER
↓
NEW STATE
Drittens die Persistenz: Ein Checkpointer speichert den Zustand als unter einem Thread gruppierte Checkpoints.
STATE
↓
CHECKPOINT
↓
CHECKPOINTER
↓
THREAD
↓
PERSISTENCE
Zusammen ermöglichen sie es einem Agenten, zu laufen, sich Dinge zu merken und nach Neustarts weiterzuarbeiten. Was fehlt, ist eine Möglichkeit, zu entscheiden, ob er überhaupt fortfahren soll.
Wann ein Agent nicht einfach weitermachen sollte
Ein Benutzer sagt zu einem Zahlungshilfsprogramm: „Überweisen Sie 50.000 ₹ auf dieses Konto.“ Der Agent bereitet die Transaktion vor, und technisch gesehen gibt es nichts, was ihre Ausführung verhindert.
User
↓
Agent
↓
Prepare Transfer
↓
Transfer ₹50,000
↓
Execute
Bei einer so bedeutenden Aktion sollte eine Person zunächst den Vorschlag prüfen, damit der Ablauf anhand einer menschlichen Entscheidung weitergeleitet wird.
User
↓
Agent
↓
Prepare Transfer
↓
┌─────────────────────┐
│ HUMAN APPROVAL │
└──────────┬──────────┘
│
┌───┴───┐
↓ ↓
Approve Reject
│ │
↓ ↓
Execute Cancel
Der Prozess muss nun absichtlich gestoppt werden – nicht aufgrund eines Fehlers oder Absturzes, sondern weil hier menschliche Eingabe erforderlich ist.
Was „Human-in-the-Loop“ bedeutet
HITL integriert menschliche Entscheidungen in einen automatisierten Ablauf. Anstatt direkt von einer Entscheidung zu einer Aktion überzugehen,
Agent
↓
Decision
↓
Action
schlägt der Agent vor, pausiert und wartet auf eine Überprüfung.
Agent
↓
Proposed Action
↓
PAUSE
↓
Human Review
↓
Decision
↓
Continue
Der Prüfer kann den Vorschlag genehmigen, ablehnen, bearbeiten, fehlende Daten liefern, den Agenten korrigieren oder zwischen Alternativen wählen. Das eignet sich für jeden Schritt mit tatsächlichen Konsequenzen.
Financial transactions
Sending emails
Deleting resources
Production deployments
Database modifications
Legal workflows
Publishing content
Access approvals
Sensitive tool calls
Was das Anhalten eines Graphen wirklich erfordert
Nehmen Sie eine Kette mit einem Genehmigungs-Schritt vor dem letzten Knoten.
Node A
↓
Node B
↓
Human Approval
↓
Node C
Falls der Prüfer sechs Stunden später antwortet, ist das Blockieren des Prozesses die falsche Lösung: Es verschwendet einen Worker und scheitert beim ersten Neustart.
sleep(21600)
Stattdessen sollte der Zustand gespeichert und dann gestoppt werden,
Node B
↓
SAVE STATE
↓
PAUSE EXECUTION
↓
um ihn später, möglicherweise in einem anderen Prozess, wiederherzustellen und am nächsten Knoten fortzufahren.
Application can stop──────── 6 HOURS LATER ────────Human responds
↓
RESTORE STATE
↓
CONTINUE EXECUTION
↓
Node C
Die Persistenz löst bereits die Hälfte des Problems. Checkpoints, der Checkpointer, Threads sowie thread_id sind genau das, was ein langes Anhalten benötigt.
Checkpoint
Checkpointer
Thread
thread_id
Persistence
Wie interrupt() die Ausführung stoppt
interrupt() pausiert ein Diagramm und bittet die Außenwelt um einen Wert. Man ruft diese Funktion innerhalb eines Nodes auf, wobei ein JSON-serialisierbarer Datensatz übergeben wird, der beschreibt, was der Benutzer sehen soll. Der Codeausschnitt ist in Python geschrieben, trotz seiner ursprünglichen Bezeichnung.
from langgraph.types import interrupt
def approval_node(state):
decision = interrupt({
"question": "Do you approve this transaction?",
"amount": state["amount"]
})
return {
"decision": decision
}
Wenn die Ausführung auf den Aufruf stößt,
interrupt(...)
erreicht der Node seine Rückgabesyntax nicht. Die Ausführung wird unterbrochen und der Datensatz wird an den Aufrufer zurückgesendet, damit dieser ihn anzeigen kann.
approval_node
│
↓
interrupt()
│
↓
┌─────────────────┐
│ EXECUTION PAUSED│
└─────────────────┘
Zwei Aspekte sind wichtig. interrupt() erfordert ein mit einem Checkpointer kompiliertes Diagramm, da der pausierte Zustand irgendwo gespeichert werden muss. Beim Wiederaufnehmen führt LangGraph den unterbrochenen Node erneut von vorne aus – dabei gibt interrupt() nun den vom Benutzer eingegebenen Wert zurück – wodurch der Code vor dem Aufruf zweimal ausgeführt wird. Halten Sie Nebeneffekte aus diesem Teil des Nodes heraus und überprüfen Sie das Verhalten für Ihre Version in den LangGraph-Dokumentationen.
Was wird während eines Unterbruchs gespeichert?
Betrachten Sie dieses Diagramm.
START
↓
Prepare Transfer
↓
Human Approval
↓
Execute Transfer
↓
END
Der Vorbereitungsnode aktualisiert den Zustand, ein Checkpoint wird geschrieben, und der Freigabennode ruft interrupt() auf.
START
↓
Prepare Transfer
↓
State Updated
↓
Checkpoint
↓
Approval Node
↓
interrupt()
Der aktuelle Zustand wird erfasst und in der Speicherung abgelegt.
Current State
│
↓
Checkpoint
│
↓
Persistent Storage
Der Thread enthält nun die Übertragungsdaten, den Ausstelldienststatus sowie den Grund für das Anhalten.
THREAD: transaction-123
Checkpoint
────────────────────
amount ₹50,000
recipient Account X
status pending
────────────────────
Execution:
PAUSED
Reason:
Human approval required
Das ist alles, was später zur Fortsetzung benötigt wird. Ohne Persistenz würde der Prozess nach dem Unterbruch einfach verschwinden.
Agent
↓
interrupt
↓
process disappears
↓
???
Wenn der Prüfer am nächsten Tag „Freigegeben“ sagt, kann niemand erkennen, was freigegeben wurde, wo das Diagramm aufgehört hat oder welcher Node als Nächstes kommt. Mit Checkpoints wird der Zustand vom Thread geladen und vor der Wiederaufnahme wiederhergestellt.
INTERRUPT
│
↓
CHECKPOINT
│
↓
THREAD
│
↓
PERSISTENT STORAGE
...time passes...
HUMAN INPUT
│
↓
THREAD
│
↓
LOAD CHECKPOINT
│
↓
RESTORE STATE
│
↓
RESUME
Fortsetzung mit Befehl
Die Anwendung stellt die Interrupt-Last als Frage dar
Approve transfer of ₹50,000?
mit zwei Schaltern,
[ APPROVE ] [ REJECT ]
und der Prüfer wählt einen aus.
APPROVE
Die Antwort wird über Command zurückgesendet, welches dem Graph mitteilt, wie weiter vorgegangen werden soll. Um fortzusetzen, muss der Graph mit Command(resume=...) aufgerufen werden anstelle einer normalen Eingabe.
from langgraph.types import Command
graph.invoke(
Command(resume="approved"),
config=config
)
Die config muss denselben Thread wie die pausierte Ausführung enthalten,
thread_id = transaction-123
denn über die Thread-ID weiß LangGraph, welche unterbrochene Ausführung gemeint ist.
Der Lebenszyklus Schritt für Schritt
Eine Ausführung beginnt mit einer normalen Aufrufung,
graph.invoke()
liest ihren Thread aus der config ein,
thread_id = transaction-123
tritt in den Vorbereitungspunkt ein,
START
↓
Prepare Transfer
und schreibt den Übertragungszustand fest.
amount = ₹50,000
recipient = Account X
status = pending
Der Genehmigungsnode ruft interrupt() auf,
Approval Node
↓
interrupt()
und die Ausführung wird unterbrochen.
EXECUTION PAUSED
Der neueste Checkpoint bleibt im Thread gesichert.
Thread
↓
Checkpoint
↓
Persistent Storage
Jemand sieht die Anfrage
Approve ₹50,000 transfer?
und antwortet darauf.
YES
Die Anwendung sendet einen Fortsetzungs-Befehl
Command(resume="approved")
an denselben Thread.
transaction-123
LangGraph setzt die Ausführung fort, übergibt die Entscheidung an den Genehmigungsnode und geht bis zum Ende weiter.
Restore Execution
↓
Human Decision = approved
↓
Continue Graph
↓
Execute Transfer
↓
END
Jedes der folgenden Muster ist eine Variation dieses Lebenszyklus.
Menschliche Entscheidungen jenseits von Ja oder Nein
Die Antwort eines Prüfers muss nicht binär sein.
YES / NO
Die Genehmigung führt den Vorschlag aus.
Agent Proposal
↓
Human
↓
APPROVE
↓
Execute
Die Ablehnung storniert ihn.
Agent Proposal
↓
Human
↓
REJECT
↓
Cancel
Durch Bearbeitung werden Teile davon geändert, wie zum Beispiel der Betrag, bevor das Diagramm weiterläuft.
Agent:
Send ₹50,000
↓
Human:
Change to ₹40,000
↓
Graph continues with
updated information
Die Bereitstellung fehlender Informationen verwandelt die Unterbrechung in eine Frage.
Agent
↓
Missing Account Number
↓
INTERRUPT
↓
Human provides account
↓
RESUME
Durch Auswahl kann der Agent Alternativen anbieten und die Entscheidung einer Person überlassen.
Agent generates:
Option A
Option B
Option C
↓
Human chooses B
↓
Graph continues
HITL ist eine allgemeine Methode, um menschliche Eingaben in einen laufenden Graphen einzubringen – nicht nur ein Bestätigungsdialog.
Befehl als Datenfluss und Steuerfluss
Befehl kann außerdem den Zustand aktualisieren und das nächste Ziel auswählen.
Resume Execution
Update State
Choose Next Destination
Ein einziger Befehl kann einen Status setzen und die Ausführung an ein bestimmtes Knoten senden; in LangGraph wird diese Form typischerweise von einem Knoten zurückgegeben.
Command(
update={
"status": "approved"
},
goto="execute"
)
Das verbindet zwei Aspekte miteinander,
DATA FLOW
+
CONTROL FLOW
da die Routenbildung früher nur den Kanten vorbehalten war.
Edges control where we go.
Nun kann ein Objekt sowohl die Zustandsänderung als auch den nächsten Schritt enthalten.
Command can participate in
state updates + control decisions.
Zustand korrigieren, bevor weitergemacht wird
Nehmen wir an, der Zustand enthält diesen Betrag,
amount = 50000
und der Prüfer genehmigt ihn mit einer Korrektur.
Approve, but change amount to 40000.
Der Ablauf verläuft vom ursprünglichen Wert über die Prüfung zu einem aktualisierten Wert, und erst danach setzt er fort (der zweite Auszug erscheint auf einer Zeile).
BEFORE
amount = 50000 ↓Human Review ↓UPDATEamount = 40000 ↓RESUME
Die Frage ändert sich von „Darf ich fortfahren?“ zu „Überprüfen, bei Bedarf korrigieren und dann fortfahren.“
Kontrolle sensibler Toolaufrufe
HITL ist vor risikoreichen Tools am praktischsten.
search_web()
read_database()
send_email()
delete_resource()
transfer_money()
Eine Websuche kann automatisch ausgeführt werden,
search_web()
↓
Execute Automatically
während das Löschen einer Ressource auf Genehmigung warten sollte.
delete_resource()
↓
INTERRUPT
↓
Human Approval
Jeder Toolaufruf durchläuft eine Sensitivitätsprüfung: sichere Aufrufe werden ausgeführt, sensible unterbrechen den Ablauf zur Genehmigung oder Stornierung.
Agent
│
↓
Tool Call
│
↓
Sensitive Tool?
/ \
NO YES
│ │
↓ ↓
Execute INTERRUPT
│ │
│ ↓
│ Human
│ / \
│ Approve Reject
│ │ │
└─────────┘ ↓
Cancel
Für eine vollständigere Implementierung, die durch einen Speicher unterstützt wird, siehe approval-gated agents in LangGraph.
Überprüfung als bewusste Kontrollgrenze
Menschliche Überprüfung ist kein Ersatz für einen nicht intelligent genug agierenden Agenten. Es handelt sich dabei um eine absichtlich gesetzte Grenze. Arbeiten mit geringem Risiko laufen automatisch ab,
LOW RISK
Search
Read
Summarize
↓
Automatic
und Arbeiten mit hohem Risiko müssen von einem Menschen geprüft werden.
HIGH RISKSend
Delete
Purchase
Transfer
Deploy
↓
Human Approval
Das Ziel ist es, zu entscheiden, wo Autonomie angemessen ist – nicht, sie überall einzuschränken.
Bearbeitung von Ablehnungen und Schweigen
Ablehnungen erfordern ein echtes Design.
Agent
↓
Prepare Action
↓
Interrupt
↓
Human
↓
REJECT
Erhalten Sie das Ergebnis im Zustand,
status = "rejected"
und leiten Sie anschließend basierend darauf mit einer bedingten Kante weiter.
Decision
/ \
approved rejected
│ │
↓ ↓
Execute Cancel
│ │
↓ ↓
END END
Jedes frühere Konzept ist beteiligt, und menschliche Eingaben sind lediglich weitere Informationen, die die Ausführung beeinflussen.
State
Reducers
Conditional Routing
Checkpoints
Threads
Commands
Die Prüfer könnten ebenfalls niemals antworten.
Interrupt
↓
Waiting for approval
↓
1 hour
↓
1 day
↓
7 days
Ein pausierter Thread kann unbegrenzt warten, daher benötigt Ihre Anwendung Richtlinien.
Expiration
Timeout
Cancellation
Reminder
Escalation
Eine gängige Lösung ist ein zeitbegrenztes Warten, das in der Regel durch einen Scheduler umgesetzt wird, der veraltete Threads mit einem Timeout-Wert wieder fortsetzt.
Approval Requested
│
↓
Wait up to 24 hours
│
┌───┴────┐
↓ ↓
Response Timeout
│ │
↓ ↓
Resume Cancel
LangGraph stellt Primitive bereit; die Geschäftsregeln liegen bei Ihnen.
Mehrere Kontrollpunkte und Streaming
Ein Deployment-Agent kann um Genehmigung für seinen Plan sowie erneut vor der Produktion bitten.
START
↓
Analyze Code
↓
Generate Deployment Plan
↓
Human Approval #1
↓
Deploy to Staging
↓
Run Tests
↓
Human Approval #2
↓
Deploy Production
↓
END
Jeder Kontrollpunkt pausiert und setzt denselben Thread wieder fort, wodurch ein Verlauf von Kontrollpunkten und Unterbrechungen entsteht.
Thread
│
├── CP1
│
├── CP2
│
├── INTERRUPT
│
├── RESUME
│
├── CP3
│
├── INTERRUPT
│
├── RESUME
│
└── END
Das ist ein dauerhafter Workflow, der von Menschen und einem Agenten gemeinsam genutzt wird. Bisher verwendete jedes Beispiel einen blockierenden Aufruf,
graph.invoke(...)
der erst endet, wenn die Ausführung beendet ist oder pausiert wird.
START → A → B → C → END
↓
RESULT
Interaktive Anwendungen benötigen einen Echtzeit-Überblick über den Fortschritt, bis hin zum Freigabeantrag.
START
↓
Planner Update ─────────→ UI
↓
Tool Call ──────────────→ UI
↓
Tool Result ────────────→ UI
↓
Approval Required ──────→ UI
Durch Streaming werden diese Ereignisse übertragen, sodass die Benutzeroberfläche abgeschlossene Schritte sowie die ausstehende Entscheidung anzeigen kann.
┌──────────────────────────────────┐
│ Deployment Agent │
├──────────────────────────────────┤
│ │
│ ✓ Analyzed repository │
│ │
│ ✓ Generated deployment plan │
│ │
│ ✓ Staging tests passed │
│ │
│ ⚠ Production deployment ready │
│ │
│ Human approval required │
│ │
│ [ APPROVE ] [ REJECT ] │
│ │
└──────────────────────────────────┘
Hinter dieser Benutzeroberfläche fließen die Ereignisse zum Frontend, und die Entscheidung wird über Command(resume=...) zurückgesendet.
LangGraph
│
↓
Streaming
│
↓
Frontend
│
↓
Human Decision
│
↓
Command(resume=...)
│
↓
LangGraph
Das vollständige Ausführungsmodell
In einem Diagramm: Der Benutzer ruft den Graphen auf einer Thread aus, der Zustand bewegt sich durch Knoten und Reduzierer, Kontrollpunkte werden gespeichert, die Routing-Logik wählt den nächsten Schritt aus, und sensible Aktionen leiten zu einer Unterbrechung um, die von einem Menschen gelöst wird.
USER
│
↓
graph.invoke()
│
↓
THREAD
│
↓
CHECKPOINTER
│
↓
STATE
│
↓
NODE
│
↓
STATE UPDATE
│
↓
REDUCER
│
↓
NEW STATE
│
↓
CHECKPOINT
│
↓
EDGE / ROUTING
│
↓
SENSITIVE ACTION?
/ \
NO YES
│ │
↓ ↓
NEXT NODE interrupt()
│
↓
PAUSED
│
↓
HUMAN
/ | \
/ | \
Approve Edit Reject
│ │ │
└────────┼────────┘
↓
Command(resume)
│
↓
SAME thread_id
│
↓
RESTORE CHECKPOINT
│
↓
CONTINUE GRAPH
│
↓
END
Im Überblick: Ein Antrag kommt an.
User Input
und die Ausführung beginnt.
START
Die Knoten lesen den Zustand und geben Aktualisierungen zurück, die Reduzierer fügen sie zusammen, die Checkpoints speichern sie unter einem Thread, und die Kanten entscheiden, was als Nächstes ausgeführt wird. Das Graph kann sich verzweigen, Schleifen bilden oder Tools aufrufen.
BRANCH
LOOP
CALL TOOLS
Wenn eine menschliche Intervention erforderlich ist, unterbricht ein Interrupt den Ablauf.
interrupt()
Die Person reagiert darauf,
APPROVE
REJECT
EDIT
PROVIDE INPUT
eine Wiederaufnahmecommando setzt den Ablauf vom gespeicherten Thread fort,
Command(resume=...)
und das Graph wird abgeschlossen.
END
Die meisten Projekte beginnen mit einem einzigen Modellaufruf,
LLM
↓
Response
und enden mit einem Graphen, der LLM- und Tool-Knoten, Reduzierer, Checkpoints, Routing, Interrupts sowie Befehle kombiniert.
USER
│
↓
START
│
↓
STATE
│
↓
NODE
│
┌──────┴──────┐
│ │
LLM TOOL
│ │
└──────┬──────┘
↓
STATE UPDATE
│
↓
REDUCER
│
↓
NEW STATE
│
↓
CHECKPOINT
│
↓
THREAD
│
↓
ROUTING
/ | \
/ | \
NODE LOOP INTERRUPT
│
↓
HUMAN
/ | \
Approve Edit Reject
\ | /
\ | /
↓
COMMAND
│
↓
RESUME
│
↓
NEXT NODE
│
↓
END
Produktions-Checkliste
Achten Sie auf fokussierte Knoten
Kleine, einzigartig bestimmte Knoten lassen sich leichter testen, erneut ausführen und sicher unterbrechen,
Plan Node
Search Node
Validate Node
Execute Node
im Gegensatz zu einem Knoten, der alles erledigt.
do_everything_agent()
Design des Zustands und Reduzierer absichtlich gestalten
Behalten Sie nur das, was die Knoten benötigen, da alles gespeichert wird und den Prüfern gezeigt werden kann. Wählen Sie Reduzierer sorgfältig für Felder aus, die Daten ansammeln.
messages
events
results
observations
Sekundäre Effekte idempotent machen
Unerückgängliche Operationen erfordern besondere Vorsicht.
Send Email
Charge Card
Delete Resource
Deploy
Transfer Money
Wiederholungen und Fortsetzungen dürfen sie niemals ausführen. Da ein unterbrochener Knoten bei der Fortsetzung neu gestartet wird, platzieren Sie unerückgängige Aufrufe nach dem Freigabepunkt oder in einem separaten Knoten und verwenden Sie Idempotenzschlüssel, sofern die APIs dies unterstützen.
Belastbare Persistenz nutzen
In-Memory-Speicherlösungen eignen sich zum Lernen; in der Produktion sind belastbare Speicherlösungen erforderlich, die den Anforderungen an Zuverlässigkeit entsprechen.
Grenzen und Limits festlegen
Legen Sie diese explizit für jeden Workflow fest,
What can AI do automatically?
What requires approval?
What can humans modify?
When does approval expire?
und geben Sie Bedingungen für das Beenden von Schleifen an.
Maximum attempts
Timeouts
Validation
Failure paths
Escalation
Wann HITL sinnvoll ist
Menschliche Überprüfung lohnt sich in bestimmten Situationen.
Cost of wrong action is high
Action is irreversible
Policy requires approval
Agent confidence is insufficient
Sensitive information is involved
Human judgment adds value
Überall verstreut, untergräbt sie die Automatisierung und bringt die Überprüfer dazu, ohne Lesen weiterzuklicken.
Agent
↓
Ask Human
↓
Agent
↓
Ask Human
↓
Agent
↓
Ask Human
Ein besseres Design bietet dem Agenten eine autonome Zone für Planung und Schlussfolgerungen, mit einer Grenze vor der daraus resultierenden Aktion.
AUTONOMOUS ZONE
┌───────────────────────┐
│ │
│ Plan → Search → Think │
│ │
└───────────┬───────────┘
│
↓
CONTROL BOUNDARY
│
↓
HUMAN
│
↓
APPROVED ACTION
Wie die Schichten zusammenpassen
Die Graphausführung umfasst Knoten, Kanten und Routing;
Graph
Nodes
Edges
START
END
Loops
Conditional Routing
Die Zustandsverwaltung umfasst Aktualisierungen und Reduzierer;
State
State Updates
Reducers
Messages
State Evolution
Die Persistenz umfasst Checkpoints, Threads und Wiederherstellung;
Checkpoints
Checkpointer
Threads
thread_id
State History
Recovery
Und HITL fügt Unterbrechungen, Befehle und Überprüfungsmuster hinzu.
interrupt()
Command
Pause
Resume
Approve
Reject
Edit
Human Control
Übereinander geschichtet bilden sie ein einziges Pipeline-System.
GRAPH
↓
STATE
↓
NODE
↓
UPDATE
↓
REDUCER
↓
CHECKPOINT
↓
THREAD
↓
ROUTING
↓
INTERRUPT
↓
HUMAN
↓
COMMAND
↓
RESUME
↓
END
Wichtige Erkenntnisse
Das Vokabular kann überwältigend erscheinen,
StateGraph
MessagesState
Reducers
Checkpointers
Threads
Commands
Interrupts
Aber jedes Element löst nur einen Teil eines einzigen Ziels: ein Agent, der weiß, handelt, aktualisiert, entscheidet, Fortschritte speichert, zum richtigen Zeitpunkt aufhört, eine Person um Hilfe bittet und sicher fortsetzt.
Remember what it knows
↓
Perform some work
↓
Update what it knows
↓
Decide what to do next
↓
Persist its progress
↓
Pause when necessary
↓
Ask a human
↓
Resume safely
↓
Continue until complete
- Der Zustand ist das, was der Agent weiß, Knoten sind die Handlungen des Agents, Kanten zeigen, wohin er geht, Reduzierer bestimmen, wie sich der Zustand ändert.
- Checkpointe speichern den Stand zum Zeitpunkt der Erstellung; Threads geben an, zu welchem History-Teil sie gehören.
interrupt()markiert den Punkt, an dem man aufhören und um Hilfe bitten soll;Commandlegt fest, wie weitergemacht werden soll, stets im selben Thread.- Unterbrochene Knoten starten bei der Wiederaufnahme neu, daher sollten irreversible Nebeneffekte nach dem Freigabepunkt berücksichtigt werden.
- Führen Sie Überprüfungen an echten Steuerungsgrenzen durch, mit expliziten Zeitlimits und Eskalationsregeln.