LangChain Module 8: Middleware, Limits, and Human Approval

Step 1: Attach middleware to an agent

Pass a list to the middleware argument of create_agent. Middleware runs around the model and tool calls, and the order of the list matters when pieces interact, such as tool retries and tool error handling.

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model=model,
    tools=[...],
    middleware=[SummarizationMiddleware(model="anthropic:claude-haiku-5-5",
                                        trigger=("tokens", 4000),
                                        keep=("messages", 20))],
)

Step 2: Know what is built in

LangChain ships middleware for tool retries and tool errors, model retries and fallbacks, summarization, human approval, limits on model calls and tool calls, PII detection, to-do lists, tool selection, and context editing. Check the built-in middleware page for the exact class names and options in your version before using them.

Step 3: Require human approval for risky tools

HumanInTheLoopMiddleware pauses the agent before the tools you list and lets a person approve, edit, or reject the call. It needs a checkpointer, because the agent must save its state while it waits. Setting a tool to False lets it run without approval.

from langchain.agents.middleware import HumanInTheLoopMiddleware
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model=model,
    tools=[send_email, read_email],
    checkpointer=InMemorySaver(),
    middleware=[
        HumanInTheLoopMiddleware(
            interrupt_on={
                "send_email": {"allowed_decisions": ["approve", "edit", "reject"]},
                "read_email": False,
            }
        )
    ],
)

Step 4: Resume a paused run

When an approval is pending, the run stops and reports the interrupt. You resume it with the same thread_id by sending a decision back using LangGraph's Command(resume=...), which Module 6 of the LangGraph course explains in depth. The exact shape of the decision payload for this middleware is in the human-in-the-loop documentation, so follow it for your version.

Step 5: Write a simple custom hook

Decorators such as before_model create middleware from a function. The function receives the agent state and a runtime, and returns a dictionary of state changes, or None to change nothing. This one only logs, which is a safe way to start.

from typing import Any
from langchain.agents import AgentState
from langchain.agents.middleware import before_model
from langgraph.runtime import Runtime

@before_model
def log_message_count(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
    print("Messages going to the model:", len(state["messages"]))
    return None

agent = create_agent(model=model, tools=[...], middleware=[log_message_count])