agentsop-langgraph

What it does

Activates a coder agent to decide when to apply LangGraph, a stateful orchestration framework, and to guide how to design, debug, and run LangGraph-based agent workflows. It focuses on when to use graph-based approaches, human-in-the-loop, multi-agent patterns, checkpoint backends, and migrating existing chains to a durable graph.

How it works

Follows a stepwise protocol:

• Step 1: Decide whether a graph is warranted using criteria like presence of cycles, crash survivability needs, human inspection, or multiple specialized agents.
• Step 2: Pick the API surface from options such as create_react_agent for standard tool-calling, @entrypoint/@task for imperative style, StateGraph for multi-agent topology, or MessageGraph for chat-only history.
• Step 3: Design the state schema before writing nodes, using TypedDict or Pydantic, with reducers for parallel writes, and ensuring serializable, pure-function node updates.
• Step 4: Choose multi-agent topology (Supervisor, Swarm, or Hierarchical) based on whether there is a user-facing persona and cross-agent coordination, with benchmarks referenced.
• Step 5: Add human-in-the-loop only on irreversible actions using interrupt(value) and resume via Command(resume=...).
• Step 6: Pick a checkpointer backend (InMemorySaver, SqliteSaver, PostgresSaver, RedisSaver) and run migrations via CI/CD rather than in-app runtime.
• Step 7: Add observability and bounded loops (LangSmith, recursion_limit adjustments) to ensure traceability and termination guarantees.

OPs (specific actions) describe concrete code patterns, such as:

• Bootstrap a ReAct agent in <10 lines by calling from langgraph.prebuilt import create_react_agent and passing model/tools.
• Promote to a manual StateGraph by re-implementing with StateGraph(MyTypedDict) and wiring nodes and edges.
• Add a reducer via Annotated[list[X], operator.add] or add_messages for parallel writes.
• Spawn dynamic workers with Send(...) in a conditional edge and reduce results with operator.add.
• Insert an interrupt gate for irreversible actions and resume with graph.invoke(Command(resume=...)).
• Encapsulate a subgraph as a child, wiring parent.add_node and handling schema differences.
• Switch checkpointer to PostgresSaver for production and run saver.setup() in a migration job.
• Stream tokens and state via graph.stream with modes including messages and updates.
• Bound a loop by counting retries in state and raising recursion_limit only as diagnostic.

When to use it

Activate when LangGraph, StateGraph, MessageGraph, or related activation keywords are involved, or when the user needs a stateful workflow, human-in-the-loop, a multi-agent pattern, a checkpoint backend, or migration to a durable graph. Do not activate for a single LLM call or stateless pipelines.

What it can touch

Actions reference exact tool names and code points, including:

• create_react_agent
• StateGraph(MyTypedDict)
• Annotated[list[X], operator.add]
• add_messages
• Send
• interrupt
• Command(resume=...)
• PostgresSaver / AsyncPostgresSaver
• graph.stream
• Endpoints like graph.invoke

Caveats

Mentions licenses and backends (MIT in top), and cautions that over-graphing simple flows is an anti-pattern. It emphasizes durability, explicit control flow, and observability, with potential verbosity in configuration and state schemas. No outcomes are promised beyond following the protocol steps and concrete OPs.