Part 9 of 12 · 4 min read
Where the vocabulary lands
Think of having learned the words "collateral," "principal" and "amortisation" from a textbook, then opening an actual mortgage contract for the first time. The words do not change. What changes is that you can now read the contract instead of just the textbook.
In plain words: parts 1 and 2 built checkpointing and idempotency from scratch to show what the words mean. Real frameworks implement the same two ideas under their own names, and knowing the mapping is what turns "I understand checkpointing" into "I can read this framework's docs." LangGraph's checkpointer is part 1's checkpoint store, made concrete: it persists graph state keyed by a thread ID, and its interrupt() function is a pause point that this module's loop-and-graph comparison calls a graph resuming from a checkpoint. The OpenAI Agents SDK's Handoffs primitive is part 3's handoff, by the same name on purpose; its Sessions abstraction is what part 3 modelled as "the full history" when estimating handoff's token cost.
A worked example. LangGraph's own documentation describes its runtime interrupt() function as pausing graph execution inside a node and persisting agent state to a configurable checkpointer -- a single interrupt without a durable checkpointer loses all state on a process restart, which is part 1's whole point made concrete. Resuming calls the graph again with the same thread ID and a Command(resume=value) object, which is this module's graph.stream(Command(resume=...), config) pattern, not a simplification of it. On the handoff side, the OpenAI Agents SDK's own documentation names its primitives Agents, Handoffs, Guardrails, Sessions and Tracing, built around production-grade single-agent-loops-with-handoffs: Handoffs let one agent delegate a task to another, and a Session is the SDK's abstraction for the conversation history that handoff carries forward -- the exact "full history" part 3 priced in its token model.
About this example About this part
Neither framework's code runs in this module's code/mini-paradigms; part 8 already says so plainly. The API shapes and dates below come from each framework's own published documentation (links in Sources). Framework details drift fast -- this part was checked on 15 November 2026, and the module's own !!! deeper box in part 8 already warns that its one prior date check (31 October 2026) will age. Treat the names as current, the version numbers as likely stale by the time you read this.
# illustrative only -- the real shape of each API, simplified for length
# LangGraph: part 1's checkpoint store, by its real name
checkpointer = PostgresSaver.from_conn_string(DATABASE_URL) # part 1's "checkpoint store"
graph = builder.compile(checkpointer=checkpointer)
config = {"configurable": {"thread_id": "run-42"}} # part 1's "which run this checkpoint belongs to"
graph.invoke(initial_state, config) # pauses at interrupt(), state is now durable
graph.invoke(Command(resume=human_decision), config) # part 1's "resume from the checkpoint"
# OpenAI Agents SDK: part 3's handoff, by its real name
triage_agent = Agent(name="triage", handoffs=[billing_agent, tech_agent]) # part 3's "pass control onward"
result = Runner.run(triage_agent, user_message, session=Session(...)) # Session carries part 3's "full history"
Checkpointer (LangGraph), Handoffs and Sessions (OpenAI Agents SDK)
A checkpointer is LangGraph's name for the checkpoint store part 1 built from scratch: a pluggable backend (in-memory for development, Postgres or similar for production) that saves graph state keyed by a thread ID, so interrupt() can pause a run and Command(resume=...) can continue it later without replaying finished work. Handoffs are the OpenAI Agents SDK's name for part 3's handoff pattern: one agent passing a task to another, which then owns the conversation. A Session is that SDK's abstraction for the conversation history a handoff carries forward -- part 3's "full history" cost, under its real name.
Example: a team that has only read this module's own code can still open LangGraph's or the OpenAI Agents SDK's documentation and recognise checkpointer, interrupt(), Handoffs and Session as the exact ideas in parts 1 and 3, not new concepts to relearn.
For the curious This does not undo the module's own argument
The module's "why this matters" section calls naming a brand the weak interview answer and naming a capability the strong one. Knowing that LangGraph's checkpointer is part 1's checkpoint store does not reverse that -- it is what lets a strong, capability-first answer ("I'd want durable state with resumable pauses") turn into a concrete one ("here, that's LangGraph's checkpointer plus interrupt()") without the two ever being confused for the same step.