Agent Frameworks Comparison

🌿 Budding note — evaluating agent development frameworks.

Overview

Choosing the right agent framework depends on your use case, team expertise, and requirements. This guide compares the major options to help you decide.

Related: AI Agents Fundamentals for core concepts

Framework Landscape

Complexity
    ↑
    │  LangGraph ──┐
    │  AutoGPT    │ Full agent systems
    │  CrewAI     ┘
    │
    │  LangChain ──┐
    │  LlamaIndex │ Agent toolkits
    │  Haystack   ┘
    │
    │  OpenAI SDK ──┐
    │  Anthropic   │ Direct API
    │  Custom      ┘
    └────────────────────→ Control
       Less                More

LangChain

Best for: Rapid prototyping, standard agent patterns

Overview

The most popular agent framework with extensive tooling and integrations.

from langchain.agents import AgentExecutor, create_react_agent
from langchain_anthropic import ChatAnthropic
from langchain.tools import Tool
from langchain.prompts import PromptTemplate

# Define tools
tools = [
    Tool(
        name="Calculator",
        func=lambda x: eval(x),
        description="Useful for math calculations"
    ),
    Tool(
        name="WebSearch",
        func=search_web,
        description="Search the web for current information"
    )
]

# Create agent
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")
agent = create_react_agent(llm, tools, prompt_template)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Run
result = agent_executor.invoke({"input": "What's 25 * 4 and when was Python created?"})

Pros

✅ Rich ecosystem: 700+ integrations (databases, APIs, tools) ✅ Well-documented: Extensive tutorials and examples ✅ Multiple agent types: ReAct, OpenAI Functions, Structured Chat ✅ Production-ready: Used by thousands of companies ✅ Active development: Regular updates, large community

Cons

❌ Abstraction overhead: Complex class hierarchies ❌ Version instability: Breaking changes between versions ❌ Performance: Slower than direct API calls ❌ Debugging difficulty: Many layers to trace through

When to Use

• Rapid prototyping
• Standard ReAct agents
• Need many integrations (databases, APIs)
• Team familiar with LangChain ecosystem

Example: Research Agent

from langchain.agents import initialize_agent, AgentType
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_anthropic import ChatAnthropic

# Setup
search = DuckDuckGoSearchRun()
llm = ChatAnthropic(temperature=0)

# Create agent
agent = initialize_agent(
    tools=[search],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    max_iterations=5
)

# Execute
result = agent.run("What are the latest developments in quantum computing in 2026?")

Related: Building Agents with LangChain

LangGraph

Best for: Complex workflows, stateful agents, multi-agent systems

Overview

Built on top of LangChain but adds graph-based orchestration for complex agent workflows.

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

# Define state
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_agent: str

# Define nodes
def researcher(state: AgentState):
    research = research_tool(state["messages"][-1])
    return {
        "messages": [research],
        "next_agent": "writer"
    }

def writer(state: AgentState):
    article = write_article(state["messages"])
    return {
        "messages": [article],
        "next_agent": "critic"
    }

def critic(state: AgentState):
    feedback = critique(state["messages"][-1])
    if feedback.is_acceptable():
        return {"messages": [feedback], "next_agent": "end"}
    else:
        return {"messages": [feedback], "next_agent": "writer"}

# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("researcher", researcher)
workflow.add_node("writer", writer)
workflow.add_node("critic", critic)

workflow.set_entry_point("researcher")
workflow.add_conditional_edges(
    "critic",
    lambda x: x["next_agent"],
    {"end": END, "writer": "writer"}
)

app = workflow.compile()

# Execute
result = app.invoke({
    "messages": ["Write an article about AI agents"],
    "next_agent": "researcher"
})

Pros

✅ Visual workflows: Clear graph structure ✅ State management: Built-in state persistence ✅ Cyclical flows: Support for loops and conditionals ✅ Multi-agent: Easy agent coordination ✅ Debugging: GraphViz visualization

Cons

❌ Steep learning curve: More complex than LangChain ❌ Newer: Less mature, smaller community ❌ Overkill for simple tasks: Too much structure for basic agents

When to Use

• Complex multi-step workflows
• Multi-agent collaboration
• Need cyclical/branching logic
• State persistence across steps

Related: Multi-Agent Systems

AutoGPT

Best for: Autonomous task completion, experimental agents

Overview

Pioneering autonomous agent that breaks down goals and executes iteratively.

# AutoGPT configuration (simplified example)
from autogpt.agent import Agent
from autogpt.config import Config

config = Config()
agent = Agent(
    ai_name="ResearchBot",
    ai_role="Research assistant",
    ai_goals=[
        "Find information about quantum computing",
        "Summarize key developments",
        "Write a report"
    ]
)

# Agent runs autonomously
agent.run_continuous()

Architecture

┌─────────────────────────────┐
│      Goal Management        │
│  "Write report on topic X"  │
└──────────┬──────────────────┘
           │
           ▼
┌─────────────────────────────┐
│    Task Decomposition       │
│  1. Research                │
│  2. Analyze                 │
│  3. Write                   │
└──────────┬──────────────────┘
           │
           ▼
┌─────────────────────────────┐
│   Tool Execution Loop       │
│  - Web search               │
│  - File operations          │
│  - Code execution           │
└──────────┬──────────────────┘
           │
           ▼
┌─────────────────────────────┐
│      Self-Reflection        │
│  "Did I accomplish goal?"   │
└─────────────────────────────┘

Pros

✅ Autonomous: Minimal human intervention ✅ Goal-oriented: Focuses on objectives, not steps ✅ Self-improving: Learns from mistakes ✅ Popular: Large community, many forks

Cons

❌ Expensive: Many LLM calls ❌ Unpredictable: Can go off-track ❌ Safety concerns: Broad tool access ❌ Maintenance: Original project less active

When to Use

• Experimental projects
• Long-running autonomous tasks
• Research into agent behavior
• Learning about agent architectures

Note: Consider newer alternatives like AutoGen or BabyAGI for production use.

CrewAI

Best for: Role-based multi-agent systems, team simulation

Overview

Framework for building teams of specialized agents that collaborate.

from crewai import Agent, Task, Crew, Process

# Define agents with roles
researcher = Agent(
    role='Research Analyst',
    goal='Find accurate information about {topic}',
    backstory='You are an expert researcher with attention to detail',
    tools=[web_search, scraper],
    verbose=True
)

writer = Agent(
    role='Content Writer',
    goal='Create engaging content from research',
    backstory='You are a skilled writer who makes complex topics accessible',
    tools=[grammar_check],
    verbose=True
)

editor = Agent(
    role='Editor',
    goal='Polish and perfect the content',
    backstory='You have high standards for quality',
    tools=[style_checker],
    verbose=True
)

# Define tasks
research_task = Task(
    description='Research recent developments in {topic}',
    agent=researcher,
    expected_output='Detailed research notes'
)

write_task = Task(
    description='Write article based on research',
    agent=writer,
    expected_output='Draft article'
)

edit_task = Task(
    description='Edit and polish the article',
    agent=editor,
    expected_output='Final article'
)

# Create crew
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, write_task, edit_task],
    process=Process.sequential,
    verbose=True
)

# Execute
result = crew.kickoff(inputs={'topic': 'AI agents'})

Pros

✅ Intuitive: Role-based mental model ✅ Collaboration: Built-in agent communication ✅ Process types: Sequential, hierarchical, or custom ✅ Delegation: Agents can delegate to each other ✅ Memory: Shared memory across agents

Cons

❌ Young framework: Less mature than LangChain ❌ Limited tools: Smaller ecosystem ❌ Documentation: Still developing ❌ Cost: Multiple agents = more API calls

When to Use

• Simulate teams or organizations
• Role-based task decomposition
• Need agent collaboration patterns
• Content creation workflows

Related: Multi-Agent Systems

OpenAI Assistants API

Best for: OpenAI-exclusive setups, simple agents

Overview

Native agent functionality from OpenAI.

from openai import OpenAI

client = OpenAI()

# Create assistant
assistant = client.beta.assistants.create(
    name="Math Tutor",
    instructions="You are a helpful math tutor. Use tools to solve problems.",
    tools=[{"type": "code_interpreter"}],
    model="gpt-4-turbo"
)

# Create thread
thread = client.beta.threads.create()

# Add message
client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Solve: ∫(x^2 + 2x + 1)dx"
)

# Run assistant
run = client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id
)

# Wait for completion and get response
# ... polling logic ...

Pros

✅ Managed: OpenAI handles execution ✅ Built-in tools: Code interpreter, retrieval ✅ Stateful: Automatic thread management ✅ Simple API: Easy to use

Cons

❌ OpenAI-only: Locked into their ecosystem ❌ Limited control: Can't customize much ❌ Black box: Hard to debug ❌ Cost: Charged per run + storage

When to Use

• Already using OpenAI exclusively
• Need code interpreter
• Want managed solution
• Simple assistant use cases

Claude SDK (Direct API)

Best for: Maximum control, Claude-specific features

Overview

Build agents directly with Claude's API for full control.

from anthropic import Anthropic

client = Anthropic()

def agent_loop(task: str, max_iterations: int = 10):
    messages = [{"role": "user", "content": task}]
    tools = get_tool_definitions()

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-4-5-20250929",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        # Check if tool use
        if response.stop_reason == "tool_use":
            tool_use = next(
                block for block in response.content
                if block.type == "tool_use"
            )

            # Execute tool
            tool_result = execute_tool(tool_use.name, tool_use.input)

            # Add to conversation
            messages.append({"role": "assistant", "content": response.content})
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tool_use.id,
                    "content": tool_result
                }]
            })
        else:
            # Task complete
            text = next(
                block.text for block in response.content
                if hasattr(block, "text")
            )
            return text

    return "Max iterations reached"

Pros

✅ Full control: No abstraction layers ✅ Claude-optimized: Use extended thinking, citations ✅ Performance: Direct API = fastest ✅ Debugging: Clear request/response flow ✅ Cost-effective: No framework overhead

Cons

❌ More code: Build everything yourself ❌ Maintenance: Handle edge cases manually ❌ No ecosystem: Integrate tools yourself

When to Use

• Need maximum performance
• Want full control over behavior
• Using Claude-specific features
• Simple agent that doesn't need framework

Related: Claude Agent Patterns

LlamaIndex

Best for: RAG + agents, document-heavy workflows

Overview

Originally focused on RAG, now includes agent capabilities.

from llama_index.core.agent import ReActAgent
from llama_index.llms.anthropic import Anthropic
from llama_index.core.tools import FunctionTool

# Define tools
def multiply(a: int, b: int) -> int:
    """Multiply two integers"""
    return a * b

multiply_tool = FunctionTool.from_defaults(fn=multiply)

# Create agent
llm = Anthropic(model="claude-sonnet-4-5-20250929")
agent = ReActAgent.from_tools(
    tools=[multiply_tool],
    llm=llm,
    verbose=True
)

# Run
response = agent.chat("What is 121 * 3?")

Pros

✅ RAG integration: Best for document-based agents ✅ Data loaders: 100+ data source connectors ✅ Query engines: Sophisticated retrieval ✅ Multi-modal: Handle images, audio, video

Cons

❌ RAG-centric: Not optimized for pure agents ❌ Learning curve: Complex abstractions ❌ Overlap: Some features duplicate LangChain

When to Use

• Agent needs document retrieval
• Building knowledge base agent
• Already using LlamaIndex for RAG
• Multi-modal data processing

Comparison Table

| Framework | Best For | Complexity | Maturity | Community | |-----------|----------|------------|----------|-----------| | LangChain | Standard agents, prototyping | Medium | High | Large | | LangGraph | Complex workflows, multi-agent | High | Medium | Growing | | AutoGPT | Autonomous agents, research | High | Medium | Large | | CrewAI | Role-based teams | Medium | Low | Small | | OpenAI API | OpenAI-only, simple agents | Low | High | Large | | Claude SDK | Maximum control, performance | Low | High | Medium | | LlamaIndex | RAG + agents | Medium | High | Large |

Decision Tree

Start
  │
  ├─ Need RAG/documents? ──Yes──> LlamaIndex
  │
  ├─ OpenAI only? ──Yes──> OpenAI Assistants API
  │
  ├─ Need multi-agent team? ──Yes──> CrewAI or LangGraph
  │
  ├─ Complex workflow/loops? ──Yes──> LangGraph
  │
  ├─ Need max control? ──Yes──> Claude SDK (direct)
  │
  ├─ Standard ReAct agent? ──Yes──> LangChain
  │
  └─ Experimental/autonomous? ──Yes──> AutoGPT

Cost Considerations

API Calls per Task

Typical calls for "Research and summarize a topic":

LangChain (ReAct):     5-8 calls
LangGraph (workflow):  10-15 calls
CrewAI (3 agents):     15-25 calls
AutoGPT (autonomous):  20-50+ calls
Direct SDK:            3-5 calls

Cost Optimization

class CostOptimizedAgent:
    def __init__(self, budget_per_task: float):
        self.budget = budget_per_task
        self.spent = 0
        self.cost_per_call = 0.03  # Example: $0.03 per Claude call

    def can_make_call(self) -> bool:
        return (self.spent + self.cost_per_call) <= self.budget

    async def call_llm(self, messages):
        if not self.can_make_call():
            raise BudgetExceeded(f"Budget {self.budget} exceeded")

        response = await self.llm.generate(messages)
        self.spent += self.cost_per_call
        return response

Related: Production Agent Deployment

Migration Patterns

From LangChain to LangGraph

# Before: LangChain sequential
from langchain.chains import SequentialChain

chain = SequentialChain(chains=[research_chain, write_chain, edit_chain])

# After: LangGraph stateful
from langgraph.graph import StateGraph

workflow = StateGraph(State)
workflow.add_node("research", research_node)
workflow.add_node("write", write_node)
workflow.add_node("edit", edit_node)
workflow.add_edge("research", "write")
workflow.add_edge("write", "edit")
app = workflow.compile()

From Framework to Direct API

# Before: LangChain
from langchain.agents import create_react_agent
agent = create_react_agent(llm, tools, prompt)
result = agent.invoke({"input": task})

# After: Direct Claude
def custom_agent(task: str):
    messages = [{"role": "user", "content": task}]
    response = client.messages.create(
        model="claude-sonnet-4-5-20250929",
        messages=messages,
        tools=tools
    )
    # Handle tool use...
    return response

Testing Across Frameworks

import pytest
from typing import Protocol

class AgentFramework(Protocol):
    def run(self, task: str) -> str: ...

def test_agent_frameworks():
    """Compare framework outputs"""
    task = "What is 5! (factorial)?"

    # Test each framework
    frameworks = {
        "langchain": langchain_agent,
        "direct_claude": claude_agent,
        "crewai": crew_agent
    }

    for name, agent in frameworks.items():
        result = agent.run(task)
        assert "120" in result, f"{name} failed"
        print(f"{name}: {result}")

Related: Agent Evaluation & Testing

Connection Points

Prerequisites:

• AI Agents Fundamentals — Core concepts
• Tool Use & Function Calling — Tool integration

Framework-specific guides:

• Building Agents with LangChain — LangChain deep dive
• Claude Agent Patterns — Direct Claude API patterns

Production concerns:

• Agent Security Considerations — Framework security
• Production Agent Deployment — Scaling considerations
• Agent Evaluation & Testing — Framework benchmarking