AI Agent Frameworks & SDKs: A Complete Comparison 2026

# OpenAI Agents SDK
from agents import Agent, Runner, handoff

# Define an agent
research_agent = Agent(
    name="Researcher",
    instructions="You are a research assistant. Find accurate information.",
    tools=[search_web, browse_page]
)

# Define another agent
writer_agent = Agent(
    name="Writer",
    instructions="You are a technical writer. Write clear, concise content.",
    tools=[write_file]
)

# Create handoff between agents
research_agent.add_handoff(writer_agent)

# Run the agent
async def main():
    result = await Runner.run(
        research_agent,
        input="Research AI agents and write a summary"
    )
    print(result.final_output)

# Guardrails for input/output validation
from agents import Agent, GuardrailFunctionOutput

def check_safe_output(output: str) -> GuardrailFunctionOutput:
    """Validate agent output"""
    if "harmful" in output.lower():
        return GuardrailFunctionOutput(
            should_abort=True,
            error_message="Output contains harmful content"
        )
    return GuardrailFunctionOutput(should_abort=False)

# Tracing for debugging
from agents import trace

@trace
async def run_agent():
    result = await Runner.run(agent, input)
    return result

# CrewAI Example
from crewai import Agent, Task, Crew

# Define agents
researcher = Agent(
    role="Research Analyst",
    goal="Find comprehensive information on the topic",
    backstory="Expert at researching any subject",
    tools=[search_tool, scrape_tool]
)

writer = Agent(
    role="Technical Writer",
    goal="Write clear, engaging content",
    backstory="Skilled writer with technical background",
    tools=[write_tool]
)

# Define tasks
research_task = Task(
    description="Research AI agents in 2026",
    agent=researcher,
    expected_output="Comprehensive research notes"
)

write_task = Task(
    description="Write a blog post based on research",
    agent=writer,
    expected_output="Published blog post"
)

# Create crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process="sequential"  # or "parallel"
)

# Execute
result = crew.kickoff()

# Sequential vs Parallel processes
crew = Crew(
    agents=agents,
    tasks=tasks,
    process="sequential",  # Tasks in order
    # process="parallel"    # Tasks simultaneously
)

# Memory for context
from crewai import Memory

crew = Crew(
    agents=agents,
    tasks=tasks,
    memory=True,  # Agents remember past interactions
    memory_config={"provider": "redis"}
)

# Custom tools
from crewai.tools import Tool

custom_tool = Tool(
    name="data_lookup",
    description="Look up data in database",
    func=lambda query: db.query(query)
)

# LangChain Agents
from langchain.agents import create_openai_functions_agent
from langchain_openai import ChatOpenAI
from langchain import hub

# Create agent
llm = ChatOpenAI(model="gpt-4o")
prompt = hub.pull("hwchase17/openai-functions-agent")

agent = create_openai_functions_agent(llm, tools, prompt)

# LangGraph for complex workflows
from langgraph.prebuilt import create_react_agent
from langgraph.graph import StateGraph

# Define workflow
workflow = StateGraph(AgentState)

workflow.add_node("research", research_agent)
workflow.add_node("write", writer_agent)
workflow.add_edge("__start__", "research")
workflow.add_edge("research", "write")
workflow.add_edge("write", "__end__")

app = workflow.compile()

# Complex multi-agent with LangGraph
from langgraph.graph import Graph
from langgraph.prebuilt import ToolNode

# Define state
class AgentState(TypedDict):
    messages: list
    current_task: str
    results: dict

# Create graph
graph = Graph()

# Add nodes
graph.add_node("coordinator", coordinator_agent)
graph.add_node("researcher", researcher_agent)
graph.add_node("executor", executor_agent)

# Define edges
graph.add_edge("__start__", "coordinator")
graph.add_conditional_edges(
    "coordinator",
    decide_next_step,
    {
        "research": "researcher",
        "execute": "executor",
        "done": "__end__"
    }
)

# Compile
app = graph.compile()

# AutoGen Example
from autogen import ConversableAgent, GroupChat, GroupChatManager

# Define agents
assistant = ConversableAgent(
    name="Assistant",
    system_message="You are a helpful AI assistant.",
    llm_config={"model": "gpt-4o"}
)

critic = ConversableAgent(
    name="Critic",
    system_message="You review and critique responses.",
    llm_config={"model": "gpt-4o"}
)

# Group chat for multi-agent
group_chat = GroupChat(
    agents=[assistant, critic],
    messages=[],
    max_round=5
)

manager = GroupChatManager(groupchat=group_chat)

# Start conversation
assistant.initiate_chat(
    manager,
    message="Write a poem about AI"
)

# Custom agent with tools
from autogen import ConversableAgent, function_tool

@function_tool
def search_web(query: str) -> str:
    """Search the web for information"""
    return web_search(query)

@function_tool
def write_file(filename: str, content: str) -> str:
    """Write content to file"""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Written to {filename}"

# Create agent with custom tools
agent = ConversableAgent(
    name="Researcher",
    llm_config={"model": "gpt-4o"},
    function_map={
        "search_web": search_web,
        "write_file": write_file
    }
)

# OpenAI Agents SDK
agent = Agent(
    name="API Helper",
    instructions="Help users with API requests",
    tools=[http_request, parse_json]
)

# CrewAI
agent = Agent(
    role="API Helper",
    goal="Help with API requests",
    tools=[http_request, parse_json]
)

# LangChain
agent = create_openai_functions_agent(llm, tools, prompt)

# CrewAI - Best for this
researcher = Agent(role="Researcher", goal="Find info", tools=[search])
analyst = Agent(role="Analyst", goal="Analyze findings", tools=[analyze])
writer = Agent(role="Writer", goal="Summarize", tools=[write])

crew = Crew(agents=[researcher, analyst, writer], process="sequential")
crew.kickoff("Research AI trends")

# LangGraph - More control
graph = StateGraph()
graph.add_node("research", researcher)
graph.add_node("analyze", analyst)
graph.add_node("write", writer)
# ... define edges

# LangGraph - Best for complex coding
from langgraph.prebuilt import create_react_agent

coding_agent = create_react_agent(
    llm,
    tools=[read_file, write_file, run_command, browser]
)

# AutoGen - For code review
reviewer = ConversableAgent(
    name="Reviewer",
    system_message="Review code for bugs",
    llm_config={"model": "gpt-4o"}
)

# Good: Start with basic agent, add complexity as needed
from openai import Agents

agent = Agent(
    name="Assistant",
    instructions="Help users"
)

# Add tools later
agent.add_tools([search_tool])

# Bad: Building crew when single agent suffices
crew = Crew(
    agents=[
        Agent(role="First"),
        Agent(role="Second"),
        Agent(role="Third"),
        # ... more agents than needed
    ],
    process="sequential"
)

from agents import Agent, RunHooks

class ErrorHandlingHooks(RunHooks):
    async def on_agent_error(self, agent, error):
        # Log error
        logger.error(f"Agent {agent.name} failed: {error}")
        
        # Retry with fallback
        return await retry_with_fallback(agent)
    
    async def on_tool_error(self, tool, error):
        # Handle tool failure
        return fallback_response

agent = Agent(hooks=ErrorHandlingHooks())