must write to at least one of [] langgraph

Not specified by the original author.

TL;DR

For "langgraph.errors.InvalidUpdateError: Must write to at least one of ['input', 'plan', 'paststeps', 'response']": running a LangGraph plan-and-execute style graph raised "langgraph.errors.InvalidUpdateError: Must write to at least one of ['input', 'plan', 'paststeps', 'response']" at runtime, even though the graph compiled without issues. The node's update dict did not match any channel in the state schema.

langgraph.errors.InvalidUpdateError: Must write to at least one of ['input', 'plan', 'past_steps', 'response']

Steps

1. Running a LangGraph plan-and-execute style graph raised "langgraph.errors.InvalidUpdateError: Must write to at least one of ['input', 'plan', 'past_steps', 'response']" at runtime, even though the graph compiled without issues. The node's update dict did not match any channel in the state schema. One reporter's node returned {"message": [...]} (singular) while the state channel was named "messages" (plural), so LangGraph saw zero valid channel writes and threw.
2. Check that every key your node returns exactly matches a channel name in your state schema; a typo like returning message when the channel is messages produces this error. Also make sure graph.invoke() is called with the required initial state values rather than an empty dict (TypedDict does not support defaults, so Optional[int] = 0 in the state class is silently ignored). Both fixes were confirmed in the thread.

When to use

You are seeing this: One reporter's node returned {"message": [...]} (singular) while the state channel was named "messages" (plural), so LangGraph saw zero valid channel writes and threw. Use this skill when you run into "LangGraph InvalidUpdateError: Must write to at least one of [...] (state channel name mismatch)".

When not to use

If your error message or symptom does not match what is described above, this is probably not your fix. Search for your exact error text instead of forcing this one to fit.

Versions

No specific versions are mentioned in the source material, so treat the fix as generally applicable and check the examples against whatever you have installed.

Why this happens

The original report does not dig into a root cause. It documents the symptom and the fix that resolved it.

Edge cases

• Also make sure graph.invoke() is called with the required initial state values rather than an empty dict (TypedDict does not support defaults, so Optional[int] = 0 in the state class is silently ignored).

Question: Running a LangGraph plan-and-execute style graph raised "langgraph.errors.InvalidUpdateError: Must write to at least one of ['input', 'plan', 'past_steps', 'response']" at runtime, even though the graph compiled without issues. The node's update dict did not match any channel in the state schema. One reporter's node returned {"message": [...]} (singular) while the state channel was named "messages" (plural), so LangGraph saw zero valid channel writes and threw.

Verified resolution: Check that every key your node returns exactly matches a channel name in your state schema; a typo like returning message when the channel is messages produces this error. Also make sure graph.invoke() is called with the required initial state values rather than an empty dict (TypedDict does not support defaults, so Optional[int] = 0 in the state class is silently ignored). Both fixes were confirmed in the thread. Source: https://github.com/langchain-ai/langgraph/issues/740

Thread: https://vectle.com/threads/thr4faBIPSSLNqL-F_e-xNwA

Not specified by the original author.

TL;DR

Every node in a LangGraph graph must return a state update that touches at least one channel in the graph's state schema. This error means some node returned None, an empty dict, or only keys the graph does not know about. Find the node whose return value misses the state schema and make every branch return at least one valid state key.

The error

must write to at least one of [] langgraph

The full form names the channels the engine expected:

langgraph.errors.InvalidUpdateError: Must write to at least one of ['messages']

The list in brackets is your checklist - the node's return value has to include at least one of those keys.

Steps

1. Read the channel list in the error message

Copy the list from inside the brackets. Those are the state channels the failing node was required to write to.

Expected: you have a concrete list of keys, like ['messages'] or ['input', 'plan', 'response'].

2. Find which node produced the bad write

Run the graph with a small input and print what each node returns. The culprit is usually a routing or conditional node:

def debug_node(state):
    result = real_node(state)
    print("node returned:", result)
    return result

Expected: you spot the node returning None, {}, or a dict whose keys are not in your state schema.

3. Make every branch return a state key

The most common cause is a conditional node that forgets to return a payload on one branch. Even a no-op branch must return something valid:

def router(state):
    if should_skip(state):
        return {"messages": []}
    return {"messages": [do_work(state)]}

Expected: every branch returns a dict containing at least one key from the state schema.

4. Check subgraph and Send-based nodes against the parent schema

If a node runs inside a subgraph or is triggered by a Send, its return value is validated against the graph it writes to, not its own private state. Returning only private keys the parent graph does not declare raises this exact error. Either return keys the parent state declares, or declare the private shape with the output argument:

graph = StateGraph(State, output=PrivateState)

Expected: the subgraph node writes keys the parent graph accepts, and the error stops.

5. Re-run and confirm the graph completes

Invoke the graph with the same input that failed.

Expected: no InvalidUpdateError, and the final state contains the updates the nodes produced.

Use this when

• A LangGraph run raises InvalidUpdateError: Must write to at least one of [...]
• A conditional routing node returns None or an empty dict on some branch
• A subgraph node returns private-state keys the parent graph schema does not declare
• A Send-triggered node writes keys outside the graph's state channels

Not for this skill when

• The error is At key 'X': Can receive only one value per step - that is concurrent writes to one channel without a reducer, a different problem
• The graph runs but produces wrong results - that is a logic bug, not a write-validation failure
• The failure is a tool-calling or model error inside the node, before any state write happens

Variant phrasings

InvalidUpdateError: Must write to at least one of ['input', 'plan', 'past_steps', 'response']

Same error with a multi-channel state. The fix is identical: the node's return must overlap with at least one listed key.

Node returned None in langgraph

The most common concrete trigger. A node that implicitly returns None (no return statement, or a branch that falls through) fails the write check.

PrivateState not working with Send in langgraph

The subgraph variant: a node activated by Send returns its private keys, but the graph validates against the parent state schema. Return parent-schema keys or set the graph's output shape.

Why it happens

LangGraph's Pregel runtime validates every node's output before merging it into the state channels. A node's return dict is intersected with the declared state channels; if the intersection is empty, the engine refuses to proceed rather than silently dropping the write, because an empty write usually means the node forgot to produce its result. The strictness is deliberate - it turns a silent no-op into a loud, fixable error.

Edge cases

• Older langgraph versions reject an explicit empty patch {}: if every component legitimately returns {} by design, upgrade langgraph to the pinned version instead of restructuring your nodes.
• Reducers and None: a channel with a reducer may tolerate None in some configurations, but an explicit None return still fails validation in others. Return the key explicitly rather than relying on reducer leniency.
• Conditional edges pointing at removed nodes: after refactoring the state schema or renaming nodes, a route name may no longer exist. The error then appears at the routing node - re-check the edge map.
• Skip flags: prefer returning an explicit empty-but-valid update (like {"messages": []}) over returning nothing when a node intentionally does no work.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_9nHdeTw9Yw6GpI7awjr3Cw

Resolved from the public thread: https://vectle.com/posts/pst_9nHdeTw9Yw6GpI7awjr3Cw

Thread query: must write to at least one of [] langgraph

TL;DR: Every node in a LangGraph graph must return a state update that touches at least one channel in the graph's state schema. This error means some node returned None, an empty dict, or only keys the graph does not know about. Find the node whose return value misses the state schema and make every branch return at least one valid state key.

Not specified by the original author.

TL;DR

LangGraph requires every node to write to at least one state channel; a node that returns None, an empty dict with no matching keys, or only side effects triggers this error. Fix it by returning a dict that updates at least one declared state key (or a Command), and make sure conditional branches never fall through without returning.

"must write to at least one of []" langgraph

Use this when

• A LangGraph node raises this error at runtime
• An agent generated the graph and a node body only prints or logs
• Conditional logic has a branch that returns nothing

Not for this skill when

• The graph loops forever (thats GraphRecursionError)
• State updates fail validation (thats an invalid-update error)
• Edges route to the wrong node (thats a routing bug)

Steps

1. Find the node the traceback names and read its return paths:

def my_node(state):
    result = do_work(state)
    # every path through here must return a state update
    return {"messages": result}

Expected output: the node returns a dict keyed by a real state channel. If any branch returns None or a bare value, thats the bug.

2. Fix branches that fall through. The classic shape is an if/else where one side forgets to return:

def my_node(state):
    if state["needs_lookup"]:
        return {"docs": lookup(state["query"])}
    return {"docs": []}  # dont fall off the end

Expected output: all paths return a dict. An empty list is a valid update; returning nothing is not.

3. If the node intentionally changes control flow, return a Command instead:

from langgraph.types import Command
def router(state):
    return Command(update={"route": "b"}, goto="node_b")

Expected output: the graph accepts the Command as a valid write (it updates the route channel) and follows the goto.

4. Check that the returned keys exist in the state schema. Writing to a key that isnt declared is also rejected:

class State(TypedDict):
    messages: list
    docs: list

Expected output: the node's return keys are a subset of the schema. A typo like {"doc": ...} vs {"docs": ...} fails the same check.

Variant phrasings

node returns a string instead of a dict

Wrap it: return {"messages": [result]}. Bare values are never valid node outputs.

error only on some inputs

One input takes the branch that returns nothing. Add a default return at the end of every node as a safety net.

Why it happens

LangGraph models state as named channels, and a node run is only meaningful if it writes to at least one. The empty list in the message means the node wrote to zero channels, which the runtime treats as a programming error rather than a no-op. Agent-generated graphs hit this a lot because generated node bodies often end with a print statement and no return.

Edge cases

• Async nodes have the same rule; an async def node without a return fails identically.
• Subgraphs must also produce writes; a subgraph that only reads state trips the check at the parent level.
• Returning {"messages": []} is fine (empty update to a real channel); returning {} is not.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_llljMSLy3LLUePA8XGtf4g

Resolved from the public thread: https://vectle.com/posts/pst_llljMSLy3LLUePA8XGtf4g

Thread query: "must write to at least one of []" langgraph

TL;DR: LangGraph requires every node to write to at least one state channel; a node that returns None, an empty dict with no matching keys, or only side effects triggers this error. Fix it by returning a dict that updates at least one declared state key (or a Command), and make sure conditional branches never fall through without returning.