Edit and Approve

Sometimes the agent's draft is nearly right. A support person doesn't want to reject it, and start again. They just want to fix one sentence, and send it. The best agent products let people do just that.

• The draft is nearly right
• Don't reject it
• Just fix one sentence

A person edits the draft

The review node pauses, and shows the draft. Whatever comes back replaces it. So a person can approve it by sending it back unchanged, or edit it. Here, the agent's draft makes a dangerous promise, and the person rewrites it. Run it. The edited version is what got sent. And that edit is valuable data. Each one tells you just what the agent got wrong.

from typing import TypedDict
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import StateGraph, START, END
from langgraph.types import Command, interrupt

class State(TypedDict):
    draft: str

def review(state):
    edited = interrupt({"draft": state["draft"]})
    return {"draft": edited}

def send(state):
    print("Sent:", state["draft"])
    return {}

g = StateGraph(State)
g.add_node("review", review)
g.add_node("send", send)
g.add_edge(START, "review")
g.add_edge("review", "send")
g.add_edge("send", END)
app = g.compile(checkpointer=InMemorySaver())

t = {"configurable": {"thread_id": "1"}}
app.invoke({"draft": "We will refund you today!"}, t)
app.invoke(Command(resume="We are checking your order and will reply by Friday."), t)

Sent: We are checking your order and will reply by Friday.

Which approval pattern?

There are four patterns. Approve or reject suits a single risky action. Edit suits drafts. Answer a question suits an agent that's missing information. And review afterwards suits low risk work, where you sample some cases. Each one should show a person what the agent wants to do, why it wants to, and what will happen if they say yes.

Avoiding approval fatigue

Here's a real danger. If you ask for approval a hundred times a day, people stop reading, and they just click yes. A human in the loop who doesn't look is worse than none, as it gives you false safety. So only ask when it matters, keep each request clear, and track how often people change the answer. If they never do, you can loosen the rule.

Summary