Agentic AI — Control Flow

How agents decide what to do next. Learn the ReAct framework, agent state management, complex conditional control flow, and building stateful agents with LangGraph.

19.1 The ReAct Framework

• Think — analyse the situation and decide what action to take.
• Act — execute the chosen action (search, calculate, call an API).
• Observe — review the result and determine the next step.

19.2 State Management of AI Agents

State management lets the agent: prevent forgetting previous context, support multi-turn conversations, track progress through complex workflows, and validate inputs.

Types of state (recap from Lecture 15)

• Ephemeral — temporary, single-computation values; deleted after use.
• Persistent — survives across steps/sessions (conversation history, preferences); stored via databases/checkpointers.
• Shared — a unified object multiple nodes/agents read and write — crucial for multi-agent collaboration.

19.3 Complex Control Flow

Simple chatbots are linear — one straight path. Real agents need complex control flow:

• Branching — choose different paths based on conditions (if price > budget, ask the user; else book).
• Loops / cycles — repeat steps (the ReAct loop; retry a failed tool call).
• Conditional routing — dynamically decide the next node from the current state.
• Human-in-the-loop (HITL) — pause the workflow for human approval before a critical action.

19.4 LangGraph: Graphs, Nodes, Edges, State

LangGraph has four core components:

1. State — the shared diary

A typed Python dictionary (TypedDict) passed between every step. Each node reads from it and writes to it, carrying context forward. TypedDict gives type safety and prevents key errors. The add_messages reducer appends new messages instead of overwriting the history.

2. Nodes — the workers

Python functions that perform work. Each node receives the current state, performs an operation (call an LLM, run a tool, compute), and returns updates to the state. Keep each node to a single responsibility.

3. Edges — the logic gates

• Standard edge — a fixed path: Node A → Node B.
• Conditional edge — a dynamic path; a routing function inspects the state and decides which node runs next. Like a GPS that reroutes based on traffic.

4. The StateGraph — the builder

The StateGraph assembles nodes and edges into an executable workflow. Three essential methods: add_node() (register a worker), add_edge() / add_conditional_edges() (connect them), and set_entry_point() (define where execution starts). Finally .compile() turns it into a runnable app.

19.5 Building an Agent Graph

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

# State = a typed dictionary shared across all nodes
class AgentState(TypedDict):
    messages: Annotated[list, add_messages]  # add_messages APPENDS
    flight_price: int                        # other fields OVERWRITE
    decision: str

# Node: receives state, returns state updates
def check_price(state: AgentState):
    if state["flight_price"] > 500:
        return {"decision": "ask_user"}
    return {"decision": "book"}

# Routing function for the conditional edge
def route(state: AgentState):
    return "ask" if state["decision"] == "ask_user" else "book"

from langgraph.graph import StateGraph, START, END

builder = StateGraph(AgentState)

# 1. Register nodes (workers)
builder.add_node("find_flight", find_flight)
builder.add_node("check_price", check_price)
builder.add_node("book_flight", book_flight)
builder.add_node("ask_user", ask_user)

# 2. Connect with edges
builder.add_edge(START, "find_flight")
builder.add_edge("find_flight", "check_price")
builder.add_conditional_edges("check_price", route,
                              {"book": "book_flight", "ask": "ask_user"})
builder.add_edge("book_flight", END)

# 3. Compile into a runnable app
app = builder.compile()
result = app.invoke({"flight_price": 0, "decision": "", "messages": []})

from langgraph.prebuilt import ToolNode
from langgraph.graph import StateGraph, START, END

def assistant_node(state):                      # the "Think" node
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

tool_node = ToolNode([multiply])                # the "Act" node

def should_continue(state):                     # router: loop or stop?
    last = state["messages"][-1]
    return "tools" if last.tool_calls else END

builder = StateGraph(State)
builder.add_node("assistant", assistant_node)
builder.add_node("tools", tool_node)
builder.add_edge(START, "assistant")
builder.add_conditional_edges("assistant", should_continue)
builder.add_edge("tools", "assistant")          # loop back -> ReAct cycle
graph = builder.compile()

The edge tools → assistant creates the loop — the agent keeps reasoning and acting until should_continue returns END. That loop is the ReAct cycle implemented as a graph.

ReAct and LangGraph components are heavily tested.

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]   # appended each step
    task_status: str                          # overwritten each step

from langgraph.graph import StateGraph, START, END
from langchain_core.messages import AIMessage

def chat_node(state):
    text = state["messages"][-1].content
    return {"messages": [AIMessage(content=f"I heard: {text}")]}

graph = StateGraph(AgentState)
graph.add_node("chat", chat_node)
graph.add_edge(START, "chat")
graph.add_edge("chat", END)

app = graph.compile()

def route(state):
    if state["amount"] > 1000:
        return "approve"      # needs human approval
    return "auto"             # auto-process

builder.add_conditional_edges(
    "check", route,
    {"approve": "approve_node", "auto": "auto_node"}
)