How Kibana pauses a LangGraph agent without a checkpointer
Elastic's human-in-the-loop tutorial compiles the graph with a MemorySaver and resumes with a Command that carries the user's choice (Rengifo (2026)). Elastic's shipped Agent Builder agent uses neither a checkpointer nor a resume Command.
On 2026-11-21 I measured 60 big-company public repos and found 18 that use LangGraph deeply. Kibana is the only one of them that pauses for a human without a checkpointer. The 16 others that pause all use interrupt and a resume Command.
I also collected 1,187 AI-engineering postings on 2026-11-22. The 94 that mention LangGraph ask for human-in-the-loop or durable execution 28% of the time, against 9.8% of the other postings. Those counts lean low, for two reasons: a mention is often one item in a "LangGraph, CrewAI or similar" list, and I truncated long postings.
My thesis is one the LangGraph docs contradict. You do not need a checkpointer to pause and resume an agent. You need two things instead: pauses only at a node boundary, and an app that already stores the conversation. This post describes Kibana's main branch as of 2026-11-22, which pins LangGraph.js 1.5.2 (manifest).
Kibana pauses its agent by ending the graph run and resumes it from the conversation record
Everything in this section comes from reading Kibana's source. I did not run a Kibana instance.
The Agent Builder graph ends in a bare compile call with no saver, and the run's configuration holds no thread id. Even a fresh round enters through a Command whose goto targets the init step (run_chat_agent.ts L700-L710).
When a tool needs the user, executeTool marks the outcome interrupted. Then executeToolEdge routes it to a dedicated node:
const executeToolEdge = async (state: StateType) => {
if (state.toolOutcome?.type === 'interrupted') {
return steps.handleToolInterrupt;
}
return steps.checkBackgroundWork;
};
Excerpt © Elasticsearch B.V., Elastic License 2.0; graph.ts L387-L392.
handleToolInterrupt writes the interrupted flag and the prompts, then edges to END. Nothing on this path calls interrupt, so the run completes normally.
Kibana reads the final state from the values stream, not from a checkpoint. It saves the round's steps plus a small RoundState record. That record holds a version of 2, the current cycle, an error count, and one entry per pending tool call. Each entry carries the call's id, its tool id, its params and the tool's own tool_state.
A single Elasticsearch index call writes all of this into the conversation document with an awaiting-prompt status. The call is guarded by an optimistic-concurrency check (client.ts L2146-L2155).
On the next request, Kibana reads that document, merges in the user's answer, and restores tool state, cycle and error count. Then it re-enters the graph:
// A pending tool call must be (re-)executed; an ask-only pause goes back to the agent loop
// through the background check, so a sub-agent that finished during the pause is reported.
const goto = init.pendingToolCallIds.length > 0 ? steps.executeTool : steps.checkBackgroundWork;
return new Command({ update, goto });
Excerpt © Elasticsearch B.V., Elastic License 2.0; run_chat_agent.ts L748-L751.
The update restores the steps through Overwrite, which bypasses the reducer. It also restores pendingToolCallIds, the compaction summary and the paused round id.
The model is not called again for the pending tool. A rejected confirmation returns "The user chose not to proceed with this action." An accepted one runs the tool's handler.
Elastic's docs describe the same behaviour from the outside. The chat page says an agent "pauses and hands control back to you before it continues" (Elastic (n.d.)). The known-issues page says a paused A2A round "stays in the awaiting_prompt state" (Elastic (n.d.)).
It works because Kibana pauses only where the graph ends. There is no half-finished run to save.
The pattern runs in 40 lines of Python, but Kibana's exact entry works in LangGraph.js 1.5.2, not Python 1.2.17
My probe graph had no checkpointer. Node a follows START, and node b is reachable only by goto.
I gave LangGraph.js 1.5.2 a Command with goto b and a seed update. It returned { log: [ 'seed', 'b' ] }, so the update was applied once and only b ran. With no checkpoint, the loop treats an update-or-goto Command as a fresh entry (loop.ts L1770, L1792).
Python 1.2.17 returned {'log': ['seed', 'seed', 'a', 'b']} for the same graph and input. On a fresh run it also passes the Command to START (pregel/_loop.py L1108, pregel/_io.py L89), so START's edge fires alongside the goto.
A verbatim port therefore does one of two things. It applies the resume update twice to reducer keys and also runs node a. Or it fails on a non-reducer key with InvalidUpdateError: "Can receive only one value per step."
The portable form is an ordinary conditional edge from START that reads a state key. The script below is a reduction of Kibana's pattern, not Kibana's code. Its exact output follows it:
# Reduced from Kibana's Agent Builder graph, not its code: no checkpointer.
import operator
from importlib.metadata import version
from typing import Annotated, TypedDict
from langgraph.graph import StateGraph, START, END
store = {} # stands in for Kibana's conversation store: owned by the app, not by LangGraph
class State(TypedDict, total=False):
msgs: Annotated[list, operator.add]
tool_call: str
resume_at: str # Python stand-in for the goto of Kibana's resume Command
answer: str
def agent(s): # stub model: asks to delete an index, answers once a tool result is in
done = [m for m in s["msgs"] if m.startswith("tool:")]
return {"answer": f"Finished. {done[-1]}", "tool_call": ""} if done else {"tool_call": "delete_index('logs-2024')"}
def route(s): # this tool needs the user's confirmation, so a tool call means pause
return "pause" if s.get("tool_call") else END
def pause(s): # Kibana's handleToolInterrupt: record the question, then the graph runs to END
store["conv-1"] = {"msgs": s["msgs"], "tool_call": s["tool_call"], "ask": f"OK to run {s['tool_call']}?"}
return {}
def tool(s): # runs only on a resume, after the user answered
ok = s["msgs"][-1] == "user: yes"
return {"msgs": [f"tool: {s['tool_call']} -> {'deleted' if ok else 'cancelled'}"], "tool_call": ""}
g = StateGraph(State)
for node in (agent, pause, tool): g.add_node(node)
g.add_conditional_edges(START, lambda s: s.get("resume_at") or "agent", ["agent", "tool"])
g.add_conditional_edges("agent", route, ["pause", END]); g.add_edge("pause", END); g.add_edge("tool", "agent")
app = g.compile() # no checkpointer, as in Kibana's graph.ts
if __name__ == "__main__":
print("langgraph", version("langgraph"))
print("run 1:", app.invoke({"msgs": ["user: clean up old logs"]}), "| store asks:", store["conv-1"]["ask"])
saved = store.pop("conv-1") # resume: state rebuilt from the store plus the user's answer
print("run 2:", app.invoke({"msgs": saved["msgs"] + ["user: yes"], "tool_call": saved["tool_call"], "resume_at": "tool"}))
langgraph 1.2.17
run 1: {'msgs': ['user: clean up old logs'], 'tool_call': "delete_index('logs-2024')"} | store asks: OK to run delete_index('logs-2024')?
run 2: {'msgs': ['user: clean up old logs', 'user: yes', "tool: delete_index('logs-2024') -> deleted"], 'tool_call': '', 'resume_at': 'tool', 'answer': "Finished. tool: delete_index('logs-2024') -> deleted"}
Kibana's shortcut is tied to one LangGraph version. The pattern itself is not.
Without a checkpointer you lose in-node pauses, replay and crash recovery, and you own the resume format
LangGraph's own docs make the strongest case against my thesis:
- "To use interrupt, you need: 1. A checkpointer to persist the graph state" (LangChain (n.d.)).
- Checkpointers are "required for" human-in-the-loop, memory, time travel and fault tolerance (LangChain (n.d.)).
- "Command(resume=...) is the only Command pattern meant as input… Any Command as input resumes from the latest checkpoint" (LangChain (n.d.)).
Kibana's goto entry is therefore undocumented, version-specific JS behaviour.
I tested the first quote. In LangGraph.js, calling interrupt() without a checkpointer throws "No checkpointer set". In Python the run stops, and the resume then fails with "Cannot use Command(resume=...) without checkpointer". That is why Kibana ends the run instead of interrupting it.
The remaining costs I read from Kibana's code and the LangGraph docs:
- No in-node pauses. Sub-agents cannot pause, so the user approves before a sub-agent starts.
- No replay. There is no time travel (LangChain (n.d.)) and none of the
durabilitymodes. - A crash mid-round loses that round. Kibana writes the round once, at its terminal event. I have no answer to this.
- Frozen node names. The code says they "should not be changed" (graph.ts L496).
- Partial state. Several things do not cross the pause: part of the tool render state for earlier calls, retry notices, the compaction cooldown and retry counters, and runtime-only tool steps. The cycle limit is not saved; it is passed in again from a fixed limit of 30.
That last item matters because restoring from a partial record loses whatever never reached it. A GPU-serving paper makes the same point in another domain, by analogy only: "A KV-only ablation diverges, showing that recurrent state is load-bearing" (Su (2026)).
One cost does not separate the two routes. On resume, the pending tool re-runs from its first line, and interrupt() also restarts its node from the top.
Kibana's confirmation prompts run before the handler, so they are safe. A prompt issued from inside a handler could repeat earlier side effects, unless the tool saves its progress in tool_state. I checked no shipped tool for this.
Kibana does contain ElasticSearchSaver, behind a feature flag that is off by default. The route that wires it in mints a new thread id on every request, so its checkpoints are never resumed. Kibana built a checkpointer; the agent that actually pauses for a user does not use it.
Choose Kibana's route only when the conversation store already exists and pauses fall at tool boundaries
- A checkpointer on your own store.
- Gives you: pauses anywhere, replay and crash recovery.
- Costs: a second state store, with its own retention and migrations, plus a thread id per run.
- Choose it for long or crash-prone runs.
- interrupt() with a resume Command.
- Gives you: the documented route, with pauses inside nodes.
- Costs: the same checkpointer, and the interrupted node still re-runs on resume.
- Choose it to stay on documented contracts.
- A Temporal-class engine.
- Gives you: retries and crash recovery outside the graph.
- Costs: a second runtime, and the work of mapping graph steps to workflow activities.
- Choose it when recovery must span more than the agent.
- Kibana's route.
- Gives you: one source of truth.
- Costs: pauses at node boundaries only, a resume protocol you own, no time travel, and reliance on version-specific LangGraph.js behaviour.
- Choose it when you already store the conversation.
If you copy Kibana's entry, pin LangGraph.js and keep the goto probe as a test that runs on every upgrade. In Python, route from START on a state key instead.
"Do I need a checkpointer?" is the wrong question. Ask whether you already own a durable record of the conversation. If you do, and your pauses fall at node boundaries, a second store buys you replay and crash recovery, not the pause itself.
The version risk is a two-node probe away from detection. The crash-mid-round risk is not, and it is yours to own.
