The Gate Before the Write

Section 1Notebook Summary

Telegraphic revision notes — fully derivable from the detailed notes below. Copy by hand; box the marked lines.

Section 2Detailed Study Notes

A support agent reads a ticket, diagnoses the fault, and files a GitHub issue for engineering. One night it misreads a customer’s ID, calls the delete-account tool with the wrong one, and a real customer’s order history, payment methods, and ticket record are gone. The model did what models sometimes do — it hallucinated a parameter. The question this lesson answers is not “how do we stop the model from ever being wrong” (we can’t), but “why was there nothing standing between that wrong output and the irreversible action it triggered?”

2.1The mandate: blast radius

Blast radius is the largest amount of irreversible damage a single autonomous action can do if it runs on bad input. The term is borrowed from nuclear engineering, where it meant the physical radius a detonation could destroy. For an agent, it is a number you calculate for every tool before you ever decide how much freedom to give it.

Two things set it. The first is irreversibility — how hard or impossible it is to undo the action once done. The second is scale — how many entities (users, records, emails, transactions) one execution touches. High irreversibility combined with high scale is maximum blast radius; low-and-low is minimum.

The engineering implication is blunt: the blast radius of an action sets the minimum level of human oversight required before it runs. Before an agent gets write access to production, the blast radius of every write must be documented. If it can’t be, the agent is not ready.

2.2HITL is a feature, not a failure

Human-in-the-loop is a deliberate split of work between agent and reviewer, not a patch for a weak model. The common misread is that a human gate means the AI “isn’t good enough.” An airbag doesn’t mean the car is badly built; a fire exit doesn’t mean the building is prone to fire. All three are controls calibrated to how bad the worst case is, installed regardless of baseline quality.

The agent does the expensive cognitive work — reading the ticket, querying data sources, cross-referencing the knowledge base, diagnosing root cause, and drafting a well-structured escalation with the right severity, title, and body. That would take a human operator ~15 minutes; the agent does it in seconds. The human’s job shrinks to ~10 seconds: read the pre-computed draft and click approve or deny.

Two more reasons it earns its place. Every approve/deny is a labeled training signal with ground-truth annotation you get for free. And in regulated industries — MiFID (financial), HIPAA (health), GDPR (data) — documented human oversight of automated decisions is often a legal requirement, not a nicety.

2.3Where the gate goes: the decision boundary

The decision boundary is the exact point in the workflow where human review is required. It is not an arbitrary design choice — blast radius sets it, and it belongs at the last possible moment before the irreversible action runs. Put it at either extreme and the review becomes worthless.

Correct placement is precise: after the tech-analysis agent has searched the knowledge base, diagnosed root cause, and prepared the complete draft (title, body, idempotency key), and before the GitHub tool node calls PyGithub’s create_issue. The reviewer sees a finished artifact with full context, and their approve/deny still changes the outcome.

2.4compile() is a control surface

The compile() call does more than lock in nodes and edges — it configures how the graph behaves at runtime. Read it as three dials, not a finalization step.

from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string("support.db")

app = workflow.compile(
    checkpointer=checkpointer,               # 1. persistence: survive restarts
    interrupt_before=["github_tool_node"],   # 2. static gate: halt before the write
    debug=True,                              # 3. observability while developing
)

Without a checkpointer, state lives only in the process’s RAM and vanishes when the terminal closes — which is why the checkpointer is what makes HITL possible at all. It is inseparable from suspend-and-resume (section 2.7).

2.5interrupt_before vs interrupt_after

Both take a list of node names and both halt the graph — they differ only on which side of the named node the cut falls.

Complex pipelines combine them — e.g. review the classification (after), then the draft (after), then gate the send (before).

2.6Static vs dynamic breakpoints

A static breakpoint is fixed at compile time; a dynamic one is decided at runtime inside a node. Static gates fire every single time execution reaches the named node, unconditionally, regardless of state values. That unconditional quality is the point.

A dynamic breakpoint is raised from inside a node’s logic with a NodeInterrupt, so it can fire conditionally on a runtime value. The fraud agent computes a risk score and only pauses for a human when the score crosses a threshold; low-risk tickets proceed automatically.

from langgraph.errors import NodeInterrupt

def fraud_analysis_agent(state: AgentState) -> dict:
    score = assess_fraud_risk(state)
    if score > 0.85:                       # conditional on runtime state
        raise NodeInterrupt(
            f"Fraud score {score:.2f} exceeds threshold; human review required."
        )
    return {"internal_notes": [f"fraud: clear ({score:.2f})"]}

2.7The interrupt lifecycle

When the graph hits a breakpoint it doesn’t “wait” — it stops completely, saves everything to disk, and releases the thread. The execution model is deterministic, so the sequence is worth knowing exactly.

At the boundary, LangGraph calls the checkpointer’s put one final time — the saved checkpoint holds every state field, the full message list, all findings so far, the GitHub draft, and metadata marking the GitHub tool node as next. Then app.invoke returns to the caller and the Python thread is freed. The graph is not blocked in any technical sense; it has stopped, and its state sits in SQLite.

2.8The checkpointer: what is preserved

After every node the checkpointer’s put is called with three things: the thread_id (which conversation), a checkpoint metadata object (node name, step number, timestamp), and the serialized state as a JSON-compatible structure. SQLite writes these as a row in a checkpoints table indexed by thread_id and step, so the checkpoint history is the full ordered sequence of snapshots.

This is why graph-construction code must be stable, deterministic, and version-controlled: if the process dies mid-review, the state is safe, but resuming means running the same script to rebuild the same topology before reconnecting.

2.9Resuming, and the denial path

The human’s decision comes back into the graph as a Command. Imported from langgraph.types, Command(resume=value) is the formal carrier for the reviewer’s answer, passed to app.invoke in place of a fresh initial state.

from langgraph.types import Command

config = {"configurable": {"thread_id": "ticket-8842"}}   # byte-for-byte identical

approval = Command(resume={
    "approved": True,
    "reviewer_note": "Confirmed outage; matches the PagerDuty alert.",
})
final_state = app.invoke(approval, config=config)          # resumes from the gate

Two requirements are strict: the thread_id must match the original invocation exactly, and the graph used to resume must be the same compiled graph (same nodes, edges, and interrupt config). Get either wrong and resumption silently misbehaves.

The denial path deserves as much design attention as approval — a gate that only handles “yes” works half the time. On denial it must route the agent to a graceful alternative rather than crash, return empty, or loop.

The five-step denial sequence: (1) the node reads approved == False; (2) it writes an escalation_denied finding (with the reviewer note) to internal_notes; (3) it returns without calling create_github_issue, so no write runs; (4) the graph routes to the synthesizer; (5) the synthesizer reads all findings and produces a final response — including any manual escalation instructions — so the user gets a complete answer regardless of outcome.

def github_tool_node(state: AgentState) -> dict:
    draft = state["github_draft"]
    decision = state.get("human_decision", {})

    if decision.get("approved"):
        result = create_github_issue(
            title=draft["title"],
            body=draft["body"],
            idempotency_key=draft["idempotency_key"],
        )
        finding = {"type": "escalation_created",
                   "issue_url": result["url"],
                   "reviewer_note": decision.get("reviewer_note", "")}
    else:
        finding = {"type": "escalation_denied",         # no write happens
                   "reviewer_note": decision.get("reviewer_note", "")}

    return {"internal_notes": [finding]}                # synthesizer reads this

2.10Interview & practice Q&A

2.11Key takeaways

• Damage comes from a missing decision boundary, not from the model being wrong — mistakes are expected.
• Blast radius = irreversibility × scale; autonomy is inversely proportional to it.
• HITL is a control sized to consequence, not proof of weakness — the 99/1 split makes automation safe.
• Place the gate at the last moment before the irreversible write; not before the work, not after it.
• Static breakpoints are non-bypassable at compile time — the right posture for writes; dynamic ones gate on runtime risk.
• The checkpointer makes HITL possible: persist, release the thread, resume by thread_id.
• Resume with a dict via Command, and always build a graceful denial path.

Section 3Microexercises

Reading proves you recognize the pattern; these prove you can build it. Attempt each before opening the walkthrough.

3.1Build the static HITL gate

from langgraph.checkpoint.sqlite import SqliteSaver

app = workflow.compile(
    checkpointer=SqliteSaver.from_conn_string("support.db"),
    interrupt_before=["github_tool_node"],   # static, non-bypassable
)

def github_tool_node(state: AgentState) -> dict:
    draft = state["github_draft"]
    decision = state.get("human_decision", {})

    if decision.get("approved"):
        result = create_github_issue(
            title=draft["title"],
            body=draft["body"],
            idempotency_key=draft["idempotency_key"],
        )
        finding = {"type": "escalation_created", "issue_url": result["url"]}
    else:
        finding = {"type": "escalation_denied",
                   "reviewer_note": decision.get("reviewer_note", "")}

    return {"internal_notes": [finding]}

3.2Diagnose: the resume that vanishes

config_a = {"configurable": {"thread_id": "ticket-8842"}}
app.invoke(initial_state, config=config_a)     # pauses at github_tool_node

# ...later, in the approval handler:
config_b = {"configurable": {"thread_id": "ticket_8842"}}   # note the change
app.update_state(config_b, {"human_decision": {"approved": True}})
app.invoke(None, config=config_b)

config = {"configurable": {"thread_id": "ticket-8842"}}
app.invoke(initial_state, config=config)       # pauses

# ...later, same config object, byte-for-byte identical id:
app.update_state(config, {"human_decision": {"approved": True}})
app.invoke(None, config=config)                # resumes the real run

3.3Diagnose: the gate that only approves

def github_tool_node(state: AgentState) -> dict:
    draft = state["github_draft"]
    decision = state.get("human_decision", {})

    if decision.get("approved"):
        result = create_github_issue(title=draft["title"], body=draft["body"])
        return {"internal_notes": [
            {"type": "escalation_created", "issue_url": result["url"]}
        ]}
    # (no else branch)

def github_tool_node(state: AgentState) -> dict:
    draft = state["github_draft"]
    decision = state.get("human_decision", {})

    if decision.get("approved"):
        result = create_github_issue(title=draft["title"], body=draft["body"])
        finding = {"type": "escalation_created", "issue_url": result["url"]}
    else:
        finding = {"type": "escalation_denied",
                   "reviewer_note": decision.get("reviewer_note", "")}

    return {"internal_notes": [finding]}   # always return a finding

End of note · Human in the Loop for Agentic Write Operations