Nodes, edges, and conditional routing

Mastering execution blocks and state-driven transition functions.

Why it matters

Nodes and conditional edges are the fundamental building blocks of cognitive architectures. Nodes act as the isolated workers—handling tasks like LLM inference, database read/writes, or formatting—while conditional edges act as the dispatchers, intercepting the modified state and calculating where to route execution next.

In LangGraph, a node is a pure-ish function state -> state (call an LLM, hit a DB, format output) and an edge decides what runs next. A conditional edge is the key primitive: it reads the current state and routes execution, making decisions explicit instead of buried in prompt text.

flowchart LR
  START --> Retrieve
  Retrieve --> Grade{Relevant?}
  Grade -- yes --> Generate
  Grade -- no --> Rewrite
  Rewrite --> Retrieve
  Generate --> END

Why decision nodes beat 'an if inside a prompt'. When routing logic lives as a visible Grade{Relevant?} node with labelled branches, you can render it, test each branch in isolation, and trace which path a given run took. When the same logic is hidden inside a mega-prompt, you can only debug by re-reading model output and guessing.

The loop is the feature. Rewrite -> Retrieve is a cycle — the agent can retry retrieval with a reformulated query. Linear chains can't express that without bespoke glue; in a state machine it's just an edge back to an earlier node.

Design for failure branches. Real graphs need more than yes/no: a tool can time out, a grade can be 'uncertain'. Add explicit branches (e.g. a retry counter routed through a Retry? node) so failure handling is part of the diagram, not an afterthought in try/except.

Nodes and edges are a railway with signal boxes. Each station (node) does one job; each signal (conditional edge) reads the train's state and sends it down the right track — including the loop line back for another pass. Hiding the signals inside one giant station is how trains collide.

• Routing logic inside prompts. Symptom: undebuggable decisions. Fix: explicit conditional-edge nodes.
• No loop guard. Symptom: infinite retry. Fix: a counter + max-attempts branch.
• Only happy-path edges. Symptom: unhandled tool failures. Fix: explicit failure branches.
• Fat nodes doing five things. Symptom: untestable. Fix: one responsibility per node.