"What is LangGraph's defining architectural feature?"	The loop is an EXPLICIT GRAPH — nodes (functions) and edges (transitions) in code. Not an implicit while-true. Every transition visible, testable, editable. The most architecturally distinct framework studied.	harness-engineering::dd10::recall
"What are super-step checkpoints?"	State serialized at EVERY node boundary. A crash resumes from the last completed node. Module 8: 5/5. The finest-grained checkpointing in the roster.	harness-engineering::dd10::recall
"What does interrupt() do, and which two modules does it connect?"	Pauses at any graph node, serializes state, waits INDEFINITELY for human. Connects Module 6 (HITL) and Module 8 (checkpointing) — interrupt IS checkpointing, from the pause/resume view.	harness-engineering::dd10::analysis
"LangGraph scores 37/60 — highest on which two modules?"	Module 1 (Loop): 5/5 — the graph IS the loop, explicitly. Module 8 (State): 5/5 — super-step checkpoints. Both are the reference.	harness-engineering::dd10::recall
"What's the 'graph fights the model' anti-pattern (Module 1) applied to LangGraph?"	If the model could handle a transition naturally but the rigid graph forces it through a suboptimal path, the harness CONSTRAINS capability. The future-proof test partially fails — rigid graphs don't co-evolve with model upgrades.	harness-engineering::dd10::analysis
"When is LangGraph the RIGHT choice?"	When the PROCESS is the product: regulated workflows, compliance-governed agents, multi-approval pipelines. When you want explicit, auditable, testable control flow. Wrong when you want the model to figure out the process.	harness-engineering::dd10::application
"LangGraph is used INSIDE Claude Code. What does that tell you?"	Even the thickest production harness (Claude Code) uses LangGraph for specific subsystems requiring explicit control flow. LangGraph is a tool for PARTS of a harness, not necessarily the whole thing. Hybrid: dumb loop + graph for regulated subsystems.	harness-engineering::dd10::analysis
"Contrast LangGraph's HITL with a system-prompt instruction ('ask before writing')."	System-prompt HITL is BEHAVIORAL — the model can forget, defer, or be injected into skipping it. interrupt() is STRUCTURAL — the edge goes through an interrupt NODE; the model cannot route around it because the model does not control the edges. Same principle as NemoClaw (DD-09).	harness-engineering::dd10::application
"Why is interrupt() the cleanest HITL primitive in the roster?"	It is structural, not behavioral. The approval is a node in the graph topology, not a request in the prompt. A prompt-injected model cannot skip it because the injection controls the model's reasoning but the graph controls the edges. Enforcement outside the agent's reach.	harness-engineering::dd10::analysis
"What is a node in LangGraph, and why is it also the unit of checkpointing?"	A node is a FUNCTION: takes graph state, does work (call model, run tool, run check), returns a state update. It is the unit of checkpointing because every node boundary is a super-step — state is serialized when execution crosses it. Computation and checkpointing share the same boundary.	harness-engineering::dd10::recall
"What is a conditional edge, and how does it differ from emergent model-driven branching?"	A conditional edge routes based on state, declared in code BEFORE the run (verify→pass? done. verify→fail? back to execute). Emergent branching lets the model decide at runtime. Conditional edges are auditable and testable; emergent branching is flexible but opaque.	harness-engineering::dd10::application
"Why does LangGraph score only 2/5 on Module 5 (Sandbox) and which deep-dive would you pair it with?"	LangGraph is a framework, not a finished harness — it leaves isolation to the user. Pair with DD-11 (OpenAI Agents SDK) which provides the 7-provider sandbox abstraction. LangGraph gives you the graph; OpenAI Agents SDK can give you the sandbox.	harness-engineering::dd10::application
"What is a subgraph, and how does it enable multi-agent orchestration?"	A subgraph is a reusable graph embedded as a single node inside a larger graph. A multi-agent system is a GRAPH OF SUBGRAPHS — each subagent is a node, edges between subagents are declared transitions. Module 10 contribution.	harness-engineering::dd10::recall
"How does LangGraph connect to Course 4 Module E09 (Multi-Agent Orchestration)?"	E09 studies the axis between DECLARED coordination (LangGraph: explicit edges between subagents) and EMERGENT coordination (CrewAI: model-driven handoffs). LangGraph is the declared-coordination pole. The LangGraph/CrewAI contrast defines the multi-agent axis the way NemoClaw/Tau defines the governance axis.	harness-engineering::dd10::analysis
"Why is super-step checkpointing the Module 8 reference, not session-level checkpointing?"	Granularity is the STEP, not the session. A crash resumes from the last completed NODE, not from the start of the session. For multi-day, multi-human workflows this is the difference between 'resume from where you were' and 'resume from approximately where you were.' Every checkpoint is serializable, replayable, forkable.	harness-engineering::dd10::analysis
"State the decision rule for when to use a graph vs a loop."	If you can draw the workflow as a flowchart BEFORE you run it, use a graph (LangGraph). If the workflow is 'the model figures it out,' use a loop (Pi, DD-01) or an implicit-graph harness. The graph is right when the process is the product; wrong when the process is emergent.	harness-engineering::dd10::application
"Name the three anti-patterns from the LangGraph deep-dive."	(1) Using a graph for work the model could figure out (graph fights the model). (2) Implementing HITL as a system-prompt instruction instead of an interrupt() node (behavioral, not structural). (3) Treating the graph as immutable (it must evolve with requirements — version it, refactor it).	harness-engineering::dd10::recall
"LangGraph scores 37/60. Why is this a 'profile, not a ranking'?"	It maxes on the two orchestration axes (Module 1 Loop 5/5, Module 8 State 5/5) and is below median on substrate axes (Tools 3/5, Sandbox 2/5). LangGraph is an orchestration SUBSTRATE, not a finished harness — you build the harness around the graph. The score reflects what it IS.	harness-engineering::dd10::analysis
"Why does interrupt() connect Modules 6 and 8?"	interrupt() IS checkpointing viewed from the HITL angle: it pauses at a node and serializes state (Module 8), then waits for a human decision and resumes (Module 6). The pause/resume is a checkpoint operation; the human decision is a Module 6.2 pattern. One primitive, two modules.	harness-engineering::dd10::analysis
"A colleague says 'LangGraph is too rigid, we should just let the model decide the workflow.' When are they right and when wrong?"	Right when the process is emergent (open-ended coding, exploratory research, creative tasks) — a rigid graph would fight the model. Wrong when the process is the product (regulated, auditable, multi-approval) — the graph IS the deliverable, and letting the model decide would destroy the auditability that is the whole point. Match the framework to the use case.	harness-engineering::dd10::application
"LangGraph is described as the 'orchestration baseline.' What does that mean for the rest of the roster?"	Every other harness has a loop, but LangGraph makes the loop EXPLICIT. It is the reference for what a declared, auditable, checkpointable loop looks like. Other harnesses trade auditability for flexibility (implicit loops). LangGraph is the baseline against which 'how visible is your control flow?' is measured — the most architecturally distinct framework studied.	harness-engineering::dd10::analysis