Chapter 69 — Agent frameworks: LangGraph, CrewAI, and the SDKs

The landscape

LangGraph, in depth: the graph is the point

LangGraph is worth understanding in more depth than the others because its abstraction — a graph over explicit state — is the most structurally different from Chapter 51's loop, and the difference is instructive.

Three concepts:

• State — a typed structure (e.g. a TypedDict) holding everything the graph needs: the message history, a scratchpad, a step counter. Every node reads from it and returns updates to it — this is the same messages list from Chapter 51, just given a schema.
• Nodes — plain functions: (state) -> partial_state_update. A node that calls the LLM, a node that executes a tool, a node that checks a guardrail (Chapter 60) are all just functions with this same shape.
• Edges — how the graph decides what runs next. A conditional edge is a function that inspects the current state and returns the name of the next node — this is where "if the model asked for a tool, go to the tool node; otherwise, end" lives.

The Chapter 51 loop, expressed as a two-node graph:

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]   # new messages get appended

def call_model(state: AgentState):
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def call_tool(state: AgentState):
    last = state["messages"][-1]
    tool_call = last.tool_calls[0]
    result = TOOLS[tool_call["name"]](**tool_call["args"])
    return {"messages": [ToolMessage(content=str(result), tool_call_id=tool_call["id"])]}

def should_continue(state: AgentState):
    last = state["messages"][-1]
    return "call_tool" if getattr(last, "tool_calls", None) else END

graph = StateGraph(AgentState)
graph.add_node("call_model", call_model)
graph.add_node("call_tool", call_tool)
graph.set_entry_point("call_model")
graph.add_conditional_edges("call_model", should_continue, {"call_tool": "call_tool", END: END})
graph.add_edge("call_tool", "call_model")   # <-- the loop: tool result goes back to the model

app = graph.compile(checkpointer=MemorySaver())   # <-- state persists between runs

Line up should_continue against Chapter 51's loop condition ("if the model returned tool calls, execute them and go around again; otherwise, return the final answer") — it's the identical decision, just made explicit as a named, inspectable function instead of an if buried inside a while.

What the framework actually bought you here, concretely:

• checkpointer=MemorySaver() — the entire state (message list, step count) is now persisted after every node. Kill the process mid-run and resume exactly where it left off. Building this yourself means serialising state to a database after every step — the framework did it in one line.
• The graph can be rendered as an actual picture (app.get_graph().draw()), which is a real debugging aid once a graph has more than three nodes.
• interrupt() (LangGraph's human-in-the-loop primitive) can pause execution before a node runs and wait for external approval — a built-in version of Chapter 60's "human approval for consequential actions" gate.

What it cost you: the control flow now lives partly in your code (call_model, call_tool) and partly in the framework's graph-wiring API (add_conditional_edges, the Annotated[list, operator.add] reducer syntax). Debugging a wrong answer means understanding both layers, not just reading a while loop top to bottom.

CrewAI: role-based orchestration

CrewAI's abstraction is closer to organisational structure than to a state machine:

from crewai import Agent, Task, Crew

researcher = Agent(role="Researcher", goal="Find accurate facts about X",
                    backstory="A meticulous fact-checker.", tools=[search_tool])
writer = Agent(role="Writer", goal="Write a clear summary from research",
               backstory="A concise technical writer.")

research_task = Task(description="Research X thoroughly", agent=researcher)
writing_task = Task(description="Write a summary using the research",
                     agent=writer, context=[research_task])

crew = Crew(agents=[researcher, writer], tasks=[research_task, writing_task])
result = crew.kickoff()

This is faster to stand up than a LangGraph graph for a fixed pipeline of distinct roles (Chapter 54's "genuinely parallel subtasks, different tool sets" case), but the execution is more of a black box — you don't get the same explicit, inspectable control-flow graph, so debugging why the writer produced a bad summary means reading prompt logs rather than following named edges.

Deciding: raw loop vs. a framework