Autonomous Multi-Agent Architecture: LangGraph, CrewAI & Tool Loops

2. Step by step: wire the StateGraph with conditional routing

Section 1 defined the state and the two nodes. A graph becomes an agent when you wire them with edges — including the edge that loops back, which is the entire reason to choose LangGraph over a chain. Here is the complete assembly, reusing the exact coder_node and reviewer_node from section 1:

from typing import TypedDict, List

from langgraph.graph import StateGraph, START, END


class AgentState(TypedDict):
    task: str
    code: str
    review_notes: List[str]
    approved: bool


def coder_node(state: AgentState):
    # Generates or modifies implementation code
    return {"code": "def solve(): pass", "review_notes": []}


def reviewer_node(state: AgentState):
    # Inspects code against the quality checklist
    is_valid = "def solve" in state["code"]
    return {
        "approved": is_valid,
        "review_notes": ["Looks good"] if is_valid else ["Missing function"],
    }


def route_after_review(state: AgentState) -> str:
    # The conditional edge: approve -> finish, reject -> loop back to coder
    return END if state["approved"] else "coder"


graph = StateGraph(AgentState)
graph.add_node("coder", coder_node)
graph.add_node("reviewer", reviewer_node)
graph.add_edge(START, "coder")
graph.add_edge("coder", "reviewer")
graph.add_conditional_edges(
    "reviewer",
    route_after_review,
    {"coder": "coder", END: END},
)

app = graph.compile()

result = app.invoke({
    "task": "Write solve()",
    "code": "",
    "review_notes": [],
    "approved": False,
})
print(result["approved"], result["review_notes"])

Read the wiring, not the nodes: nodes return partial state updates, edges define the possible paths, and the router function is the only place control flow lives. Swap the deterministic reviewer for an LLM call and the topology does not change — which is why the human-in-the-loop gate from this tutorial’s objectives drops in cleanly as one more node between reviewer and END, pausing the graph before anything irreversible runs.

Add the human gate the objectives promised

A reviewer node that is itself an LLM still lets the graph run unattended end to end. For anything irreversible, insert a human node that pauses the graph with LangGraph’s interrupt: execution stops, the state is checkpointed, and a person resumes it with a decision. It needs a checkpointer so the paused state survives:

from langgraph.checkpoint.memory import MemorySaver
from langgraph.types import Command, interrupt


def human_gate(state: AgentState):
    decision = interrupt({
        "question": "Approve this code for the next step?",
        "code": state["code"],
    })
    return {"approved": decision == "approve"}


# graph.add_node("human", human_gate) and route reviewer -> human -> END/coder
app = graph.compile(checkpointer=MemorySaver())

config = {"configurable": {"thread_id": "review-1"}}
app.invoke(
    {"task": "Write solve()", "code": "", "review_notes": [],
     "approved": False},
    config=config,
)  # runs until the gate, then pauses with state saved

# A human reviews the code and resumes the same thread:
app.invoke(Command(resume="approve"), config=config)

The thread_id is the resumption key: the same graph, the same state, continued hours later by a different process if necessary. That pause-and-resume property is the concrete difference between a demo agent and one you may leave running near production systems.

3. A complete worked example

The same pipeline in CrewAI trades the graph for roles. Where LangGraph made you declare state and edges, CrewAI asks for agents with goals and tasks in sequence — the coder/reviewer pair from section 1, expressed as a crew:

from crewai import Agent, Crew, Process, Task

coder = Agent(
    role="Python Developer",
    goal="Write correct, minimal Python for the assigned task",
    backstory="Senior Python engineer who favors small, testable functions.",
    verbose=True,
)

reviewer = Agent(
    role="Code Reviewer",
    goal="Reject any code that fails the quality checklist",
    backstory="Staff engineer known for strict, specific review notes.",
    verbose=True,
)

write_task = Task(
    description="Implement the function described here: {task}",
    expected_output="A single Python code block with the implementation.",
    agent=coder,
)

review_task = Task(
    description=(
        "Review the implementation produced by the previous task. "
        "Check: correct signature, edge cases handled, no placeholder code."
    ),
    expected_output="Either APPROVED, or a numbered list of required fixes.",
    agent=reviewer,
)

crew = Crew(
    agents=[coder, reviewer],
    tasks=[write_task, review_task],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff(
    inputs={"task": "Write solve() returning the sum of even numbers in a list"}
)
print(result.raw)

Run both versions on the same task and the trade-off from the FAQ becomes tangible. The LangGraph version gives you the loop for free — a rejection routes back to the coder until approval or the recursion limit — plus a state object you can inspect, persist, and resume. The CrewAI version is a third of the code and reads like an org chart, but the retry discipline lives in the reviewer’s instructions rather than in enforceable control flow. Prototype in CrewAI; harden in LangGraph.

4. Troubleshooting

• The graph never terminates. The reviewer never approves, so the conditional edge loops forever. Two guards, both cheap: a max-attempts counter carried in state that the router checks, and a hard ceiling on the invoke call — app.invoke(state, config={"recursion_limit": 10}). A loop without a counter is a bug waiting for a token bill.
• State fields come back empty or reset between nodes. Nodes must return partial updates — only the keys they changed — and list fields that should accumulate need a reducer, declared as Annotated[List[str], operator.add] in the TypedDict. Returning a whole fresh state dict from a node silently discards every other node’s work.
• The CrewAI reviewer approves everything. Role-playing agents are agreeable by default. Sharpen the goal ("reject any code that fails the checklist"), spell the checklist out in the task description, and set expected_output to force a verdict format — APPROVED or a numbered fix list — so approval is a decision, not a compliment.
• ImportError or version chaos after installing both frameworks. LangGraph and CrewAI pull overlapping LangChain dependencies. Install them into one fresh virtual environment together, let the resolver pick compatible versions in a single pass, and pin the result (pip freeze) before the project grows around a working set.