Imagine if your AI could collaborate with “colleagues” — specialized AI agents that brainstorm, research, and execute tasks together. This vision is now a practical reality, thanks to agentic frameworks. These frameworks let multiple AI agents collaborate, communicate, and make decisions on their own, collectively solving problems too tricky for a single model.
There are a number of agentic frameworks available today, and I will be going through some of the top ones in a series of posts: LangGraph, CrewAI, SmolAgents and Pydantic AI.
In this first post of the series, we’ll talk a bit about agentic frameworks, explore why they’re so powerful, and walk through building a multi-agent workflow using LangGraph to illustrate how it all comes together in code.
Why Multi-Agent AI? (And Why You Should Care)
Agentic frameworks aren’t just cool tech jargon — they’re practical tools for boosting productivity, efficiency, and resilience in AI systems. By distributing tasks across specialized agents, big problems become more manageable and solutions often turn out smarter and more nuanced. Here are some real-world benefits and examples:
Divide and Conquer: Complex tasks can be split among experts. Example: In software development, imagine a build system that reviews its own documentation. A Researcher agent gathers information and updates docs, a Writer agent drafts improvements, and a Reviewer agent checks for consistency. Together, they maintain up-to-date documentation continuously, something a single monolithic AI would struggle to manage alone.
Parallel Processing: Multi-agent setups can tackle subtasks in parallel, speeding up workflows. Example: In customer service, one agent could triage incoming tickets (e.g. sorting by topic or urgency) while others simultaneously draft responses or escalate issues based on sentiment. This way, no single bottleneck stalls the entire support queue.
Adaptability: With specialized agents, your AI system can pivot gracefully when unexpected challenges arise. If requirements change or an error occurs, agents can adjust their strategies or hand off tasks to different agents better suited for the new situation. This built-in adaptability means more robust systems that handle surprises without breaking a sweat.
Scalability: As your projects grow, scaling is as simple as adding or refining agents. Need to handle a new type of task? Just slot in a new specialist agent for it. You don’t have to refactor the whole system — the existing team can stay as-is while the new agent joins the workflow. This modular approach keeps things running smoothly even as demands evolve.
Enter LangGraph: Your AI Team’s Best Friend
LangGraph (from the LangChain family) is designed to make building multi-agent systems straightforward. If your AI agents are the team members, think of LangGraph as the team manager and project planner. It keeps everyone organized, handles the workflow logistics, and makes sure the team hits their goals without drama.
LangGraph’s Secret Sauce: Why It’s Awesome
What makes LangGraph particularly handy? Let’s break down a few of its key features that simplify agent orchestration:
Declarative Workflow Management: Instead of writing complex code to handle who-does-what-when, you describe what should happen and when, and LangGraph figures out how to make it happen. You can define workflows as a graph of interconnected nodes (agents or functions), each triggered by specific events or the completion of another task.
Automatic State Management: LangGraph maintains a shared global state that all agents can access and update. This is super helpful when one agent’s output becomes another agent’s input. For example, a “Researcher” agent can write its findings to the state, which a “Writer” agent then reads to generate a report.
Built-in Observability: Orchestrating multiple agents can get complex, so visibility is key. LangGraph provides full traceability into the system’s behavior. You can inspect state transitions, messages passed between agents, and the decision path taken at each step.
Plug-and-Play Integration: Already using LangChain or other AI frameworks? LangGraph plays nicely with them. It doesn’t require you to rewrite your existing tools or prompts. You can use all the LLM wrappers and tools provided by LangChain.
With the basics and benefits in mind, let’s roll up our sleeves and build something concrete to see LangGraph in action!
Building a Plan-and-Execute AI Team with LangGraph
We’ll walk through a specific “Plan-and-Execute” style agent. This pattern is an emerging design where one agent plans out a multi-step solution and another agent (or agents) execute those steps one by one. It’s inspired by recent research (like the Plan-and-Solve approach and the BabyAGI project) that suggests chaining an LLM’s reasoning this way can be more efficient and effective than a naive step-by-step approach.
Scenario: Picture this — you have a question that’s not trivial and likely needs multiple steps to answer. For example: “What is the hometown of the men’s 2024 Australian Open winner?” A single AI model might try to answer directly and stumble, or waste tokens figuring out what to do. Instead, using LangGraph, we’ll set up two specialized agents: one to plan the steps required, and one to execute each step (using a tool like web search). The planner agent will break the problem into manageable tasks (e.g., 1. Find who won the 2024 Australian Open (men’s), 2. Find that person’s hometown). The executor agent will then carry out each task and feed results back. If more steps are needed after a task, the planner can revise the plan, and so on, until we arrive at the final answer. Essentially, it’s like having a strategist and a researcher working together.
Meet the Team: Planner and Executor Agents
In a Plan-and-Execute agent, we essentially have two roles:
1. The Planner: This agent’s job is to take the user’s objective and generate a step-by-step plan.
2. The Executor (Single-Task Agent): This agent takes one task at a time from the plan and actually executes it. It might call external tools or APIs to get information. Eg:
tools = [TavilySearchResults(max_results=3)]
The tools list can include any number of tools (APIs, databases, calculators, etc.), but for simplicity we’re just using one search tool here.
LangGraph provides a convenient function to create a ReAct-style agent (an agent that can use tools in a loop of reasoning) which we can use as our single-task executor.
llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = "You are a helpful research assistant."
# Create an agent that uses the LLM and the tools
agent_executor = create_react_agent(llm, tools, prompt=prompt)
We set temperature=0 for the LLM to make its output more deterministic (useful for consistent plans).
The planner is essentially another LLM prompt that generates a list of steps. We can implement the planner using a prompt template that asks the LLM to break a big question into smaller steps. For example:
# Define a data model for the plan (a list of steps)
class Plan(BaseModel):
steps: list[str] = Field(description="Steps to follow, in order.")
# Create a prompt template for the planner
planner_prompt = ChatPromptTemplate.from_messages([
("system",
"For the given objective, come up with a simple step-by-step plan. "),
("placeholder", "{messages}")
])
# Initialize the planner agent with GPT-4o (or other LLM)
planner = planner_prompt | ChatOpenAI(model="gpt-4o", temperature=0) \
.with_structured_output(Plan)
Creating the Workflow Graph
The next part is orchestrating how they interact. We’ll use LangGraph’s StateGraph to lay out the flow: User question → Planner → Executor → (maybe Replan) → … → Final answer. Essentially, we’re building a mini state machine or flowchart for the agent team.
Using LangGraph, we can implement this flow as nodes and edges in a graph:
- Nodes: Each node will represent one of the steps above (Plan, Execute, Replan, etc. – plus a Start and End which are handily built into LangGraph).
- Edges: Arrows connecting nodes to define the order of execution (and conditions for looping or ending).
Let’s create a PlanExecute state type:
# Define a class for the state to keep track of plan, past steps, etc.
class PlanExecute(BaseModel):
input: str # the original question
plan: list[str] = [] # current plan steps
past_steps: list = [] # history of (step, result) pairs
response: str = None # final answer (if completed)`plan_step` uses the planner to set an initial plan.
and then create a LangGraph workflow:
# Initialize the state machine (graph) with our state class
workflow = StateGraph(PlanExecute)
# Add nodes to the graph
workflow.add_node("planner", plan_step)
workflow.add_node("agent", execute_step)
workflow.add_node("replan", replan_step)
# Define the edges (transitions)
workflow.add_edge(START, "planner") # start -> planner first
workflow.add_edge("planner", "agent") # once planned, go to execute
workflow.add_edge("agent", "replan") # after executing a task, go to replan
# Conditional transition: from replan, decide next step
workflow.add_conditional_edges(
"replan",
condition=lambda state: END if state.response else "agent",
targets=["agent", END]
)
The implementation of the actual methods plan_step, execute_step and replan_step were omitted for brevity but you can see the full source here as a handy notebook that you can run yourself).
We’ve effectively built a directed graph of our process. It starts at planner, then to agent, then replan, and either loops back or ends. We can now compile this workflow into a runnable application:
graph = workflow.compile() # compiles the graph into a LangChain runnable
Behind the scenes, app will manage the sequence of calls and state updates according to our graph. We can now run the workflow! The general pattern is:
result = graph.invoke(inputs, config)
See the linked notebook for the async version which provides feedback as the execution progresses and the LangGraph documentation for a lot more info and tutorials.
Beyond the Basics: Real-World Workflows and Integrations
Our example was a simple Q&A task, but the possibilities for multi-agent workflows are vast. LangGraph can integrate with many tools and services, meaning your agents can be equipped to handle a wide range of tasks. Some ideas and integrations to consider:
- Web Browsing and APIs: Agents can call web browsers, APIs, or databases. Imagine a travel planning agent: one sub-agent searches flights, another queries hotel APIs, another checks weather forecasts, all coordinated via LangGraph. Each agent’s results feed into a combined itinerary.
- Content Creation Pipelines: The earlier documentation example (Researcher, Writer, Reviewer) could be expanded with agents like a Fact-Checker (verifying claims via search), an SEO Optimizer (adjusting content for search engines), or a Content Strategist (deciding which topics to cover). LangGraph would manage the hand-offs between these roles. You can easily add such specialist agents to the workflow as new nodes – a bit like adding new members to your team – and define when they come into play.
- Enterprise Workflows: Think of multi-agent systems for customer support, as we touched on, or internal analytics. A Report Generator agent might pull data via SQL, a Charting agent turns it into visuals, and a Narrative agent writes an explanation. The orchestrator (LangGraph) ensures the SQL agent runs first, then passes data to the Charting agent, and so on, finally compiling the report for a human manager.
- Integrating Custom ML Models: LangGraph is not limited to language models. If you have a custom ML model (say, a vision model or a specialized classifier), you can wrap it as a tool or agent and include it in the graph. For example, an agent could use an OCR tool to read a document, then hand text to an LLM for analysis.
The good news is you don’t have to start from scratch for common patterns. LangGraph comes with prebuilt agents and templates (as we used create_react_agent for a generic tool-using agent). It’s also integrated with LangChain’s ecosystem, meaning you have access to a wide range of tools, memory modules, and chains that you can slot into your agent workflow.
LangGraph Caveats
Despite LangGraph’s many strengths, it exhibits some noticeable limitations when compared to other popular agentic frameworks we will be going through in upcoming articles.
One key weakness is its reliance on explicit workflow definitions, which, while powerful, can lead to rigid systems that require substantial upfront design and are less adaptable to dynamic, unpredictable environments.
Additionally, LangGraph’s extensive state management, while beneficial for observability, can introduce overhead and complexity that smaller, lightweight frameworks like SmolAgents easily avoid.
Moreover, LangGraph does not inherently leverage type validation and schema enforcement very robustly, potentially making it less suitable for strictly typed or validation-intensive applications where precise data contracts are crucial.
Another weakness is LangGraph’s dependency on the LangChain ecosystem. LangChain itself has a reputation of being overly complex, brittle with respect to rapid breaking changes between version and outdated documentation, making initial adoption and production-readiness potentially quite cumbersome.
Lastly, performance overhead can become significant in LangGraph for large-scale systems with numerous agents, particularly due to the increased communication and state synchronization demands compared to leaner, decentralized frameworks.
These comparative weaknesses suggest scenarios where alternative frameworks might offer simpler, more agile, or more robust solutions depending on project requirements.
