Agent: ReAct architecture and infinite tool loop
act → observe → reason → loop

1Limitation of the previous lecture: Router can only step

Router is already powerful - it lets LLM decide whether to call a tool, and then actually execute that tool. But Router has a fundamental limitation:After the tool is executed, go directly to END。

This limit comes from an edge:

# Router 中的这一行：
builder.add_edge("tools", END)  # ← 工具执行完 → 结束，LLM 永远看不到工具结果

What's the solution?replace this line. Send tool results back to LLM, allowing LLM to continue inference. This is Agent.

2What is ReAct: Reasoning + Acting cycle

ReAct is the Agent paradigm proposed by Google in 2022. The name comes from the combination of two words:Reasoning (reasoning) +Acting (action).

It describes how an LLM Agent should work:

The key insights from this cycle are:Tool results themselves are information. LLM sees what the tool returns so it can decide what to do next. Append tool results tomessagesList, equivalent to "let LLM observe the execution results".

3That line of code that changed everything

From Router to Agent, the code changes are minimal. Find the difference in this line and you understand the essence of Agent:

# tools 执行完 → 结束
builder.add_edge(
  "tools",
  END  ← 这里
)

# tools 执行完 → 回到 assistant
builder.add_edge(
  "tools",
  "assistant"  ← 这里！
)

4Complete Agent diagram: full code analysis

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import tools_condition, ToolNode

# ─── 1. 定义工具 ───────────────────────────────────────
def add(a: int, b: int) -> int:
    """Adds a and b."""
    return a + b

def multiply(a: int, b: int) -> int:
    """Multiplies a and b."""
    return a * b

def divide(a: int, b: int) -> float:
    """Divides a by b."""
    return a / b

tools = [add, multiply, divide]

# ─── 2. LLM 绑定工具 ───────────────────────────────────
llm = ChatOpenAI(model="gpt-4o")
llm_with_tools = llm.bind_tools(tools)

# ─── 3. 系统提示（在每次 LLM 调用时注入）─────────────
sys_msg = SystemMessage(content="You are a helpful assistant tasked with performing arithmetic.")

# ─── 4. assistant 节点：把 sys_msg 前置注入 ────────────
def assistant(state: MessagesState):
    return {"messages": [llm_with_tools.invoke([sys_msg] + state["messages"])]}

# ─── 5. 构建图 ────────────────────────────────────────
builder = StateGraph(MessagesState)

builder.add_node("assistant", assistant)         # LLM 节点
builder.add_node("tools", ToolNode(tools))       # 工具执行节点

builder.add_edge(START, "assistant")             # 入口
builder.add_conditional_edges("assistant", tools_condition)  # 条件分支
builder.add_edge("tools", "assistant")           # ← 关键！循环回去

react_graph = builder.compile()

# ─── 6. 运行 ─────────────────────────────────────────
messages = [HumanMessage(content="Add 3 and 4. Multiply the output by 2. Divide the output by 5")]
result = react_graph.invoke({"messages": messages})

Code key points analysis

• three tools: add, multiply, divide, covering the complete operation chain
• Change the node name to "assistant": Compared with Router's "tool_calling_llm", the name is more semantic and represents the role of "intelligent assistant"
• [sys_msg] + state["messages"]: Add SystemMessage in front of the dialog every time LLM is called, no matter how many times it is looped
• Highlight that line：add_edge("tools", "assistant"), which is the physical implementation of the Agent loop

5Agent Loop Illustration: The Secret of the Two-Way Arrow

6Execution step tracking: (3+4)×2÷5 complete process

User input: "Add 3 and 4. Multiply the output by 2. Divide the output by 5"

This question requires three steps of calculation: 3+4=7, 7×2=14, 14÷5=2.8. Let's track every step of the Agent, andmessagesThe evolution of lists.

The complete evolution of the messages list

Every time the assistant node is called, it seesmessagesWhat is:

7The role of SystemMessage

This is another small difference between Agent and Router:assistantWhen the node calls LLM, it will add a message to the front of the message list.SystemMessage：

sys_msg = SystemMessage(content="You are a helpful assistant tasked with performing arithmetic.")

def assistant(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(
        [sys_msg] + state["messages"]   # ← sys_msg 注入在最前面
    )]}

• Does not occupy State: SystemMessage is not writtenmessagesThe list does not accumulate as the loop repeats. Only the real conversation history is kept in State
• Effective every time: No matter how many rounds are cycled, LLM can see the system prompt every time and the character will not be "forgotten"

8When does the loop terminate?

Is the Agent loop infinite? no. The termination condition is very clear, given bytools_conditioncontrol:

LLM decides when to stop. When it determines that all subtasks are completed, its reply no longer containstool_calls, only plain text answers.tools_conditionUpon detecting this, route toEND, the graph is executed.

# 限制最大递归深度（每个节点执行一次算一步）
result = react_graph.invoke(
    {"messages": messages},
    config={"recursion_limit": 10}  # 超过则抛出 GraphRecursionError
)

9Router vs Agent: The only difference

Let’s compare the two graphs side by side. Everything is exactly the same except for that row of edges:

# 节点
builder.add_node("tool_calling_llm", tool_calling_llm)
builder.add_node("tools", ToolNode([multiply]))

# 边
builder.add_edge(START, "tool_calling_llm")
builder.add_conditional_edges(
    "tool_calling_llm", tools_condition
)
# ↓ 工具结果 → 结束
builder.add_edge("tools", END)

# 节点
builder.add_node("assistant", assistant)
builder.add_node("tools", ToolNode(tools))

# 边
builder.add_edge(START, "assistant")
builder.add_conditional_edges(
    "assistant", tools_condition
)
# ↓ 工具结果 → 回到 LLM（关键！）
builder.add_edge("tools", "assistant")

10This is the general Agent architecture

We demonstrated Agent using three mathematical functions, but the architecture is completely general. Replace the tool with anything and the Agent works the same way:

Next step for expansion

• Module 2 — Memory and Persistence: Add cross-conversation memory to Agent, no longer starting from scratch every time
• Module 3 — Human-in-the-Loop: Pause before calling key tools and allow human approval before continuing.
• Module 4 — Parallelism and Subgraphs: Multiple Agents work in parallel to handle more complex tasks
• Module 5 — Long Term Memory: Use vector database to store Agent’s long-term knowledge and user preferences