Framework Landscape

"Choosing a framework is easy. Living with that choice for two years is the hard part."

Census, Framework-Fatigued AI Agent

1. The Framework Landscape in 2026

The agent framework ecosystem has matured rapidly. In 2024, teams had to choose between a handful of experimental libraries. By early 2026, the landscape includes production-grade frameworks from major cloud providers, well-funded startups, and active open-source communities. Each framework makes different trade-offs between simplicity and control, abstraction level and flexibility, single-agent focus and multi-agent orchestration. Understanding these trade-offs is essential for selecting the right foundation for your agent system.

LangGraph (LangChain) models agents as directed graphs where nodes are functions and edges define control flow. State is passed between nodes as a typed dictionary, and conditional edges enable branching logic. LangGraph's strength is fine-grained control: you define exactly how the agent loop works, where checkpoints are saved, and how errors are handled. Its weakness is verbosity. Simple agents require more boilerplate than higher-level frameworks.

CrewAI takes a role-based approach inspired by human teams. You define agents with roles, goals, and backstories, then assemble them into crews that execute tasks. CrewAI abstracts away the graph structure, making it fast to prototype collaborative multi-agent systems. The trade-off is less control over execution flow: you cannot easily implement custom conditional logic or fine-grained state management. CrewAI is excellent for content generation, research, and analysis workflows where the flow is relatively linear.

AutoGen/AG2 (Microsoft) focuses on multi-agent conversation. Agents communicate through structured messages, with patterns like GroupChat managing turn-taking and topic management. AutoGen excels at debate-style interactions and code review workflows where agents need to build on each other's outputs. OpenAI Agents SDK provides a minimal, provider-native framework with built-in support for tool use, handoffs between agents, and guardrails. Google ADK integrates tightly with Gemini and Google Cloud services. smolagents (Hugging Face) emphasizes simplicity and code-based tool execution. PydanticAI brings type safety to agent development with Pydantic model validation. Semantic Kernel (Microsoft) integrates with the .NET and Java ecosystems.

The Same Agent in Three Frameworks

This snippet implements the same research agent in LangGraph, CrewAI, and OpenAI Swarm to compare framework APIs.

# LangGraph: Research Agent
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class ResearchState(TypedDict):
 messages: Annotated[list, add_messages]
 search_results: list
 report: str

def search_node(state):
 query = state["messages"][-1].content
 results = web_search(query)
 return {"search_results": results}

def write_node(state):
 report = llm.invoke(
 f"Write a research report based on:\n{state['search_results']}"
 )
 return {"report": report.content}

graph = StateGraph(ResearchState)
graph.add_node("search", search_node)
graph.add_node("write", write_node)
graph.set_entry_point("search")
graph.add_edge("search", "write")
graph.add_edge("write", END)
research_agent = graph.compile()

# CrewAI: Research Agent
from crewai import Agent, Task, Crew

researcher = Agent(
 role="Research Analyst",
 goal="Find comprehensive information on the given topic",
 tools=[web_search_tool],
 llm="gpt-4o",
)

writer = Agent(
 role="Report Writer",
 goal="Write a clear, well-structured research report",
 llm="gpt-4o",
)

search_task = Task(
 description="Research the topic: {topic}",
 agent=researcher,
 expected_output="A list of key findings with sources",
)

write_task = Task(
 description="Write a research report from the findings",
 agent=writer,
 expected_output="A well-structured research report",
 context=[search_task],
)

crew = Crew(agents=[researcher, writer], tasks=[search_task, write_task])
result = crew.kickoff(inputs={"topic": "quantum computing advances in 2025"})

# OpenAI Agents SDK: Research Agent
from openai import agents

search_agent = agents.Agent(
 name="researcher",
 instructions="Search the web for information on the given topic.",
 tools=[web_search_tool],
 model="gpt-4o",
)

writer_agent = agents.Agent(
 name="writer",
 instructions="Write a research report from the provided findings.",
 model="gpt-4o",
)

# Use handoff to chain agents
orchestrator = agents.Agent(
 name="orchestrator",
 instructions="Coordinate research: first search, then write a report.",
 handoffs=[search_agent, writer_agent],
 model="gpt-4o",
)

result = agents.Runner.run_sync(orchestrator, "Research quantum computing advances")

Lab: Build the Same Agent in Three Frameworks

2. Framework Selection Guide

Choosing a framework is a consequential decision that affects development speed, maintenance burden, and scaling potential. The decision matrix should consider: team expertise (Python familiarity, async programming comfort), application complexity (simple tool loop vs. complex multi-agent workflow), deployment requirements (cloud provider preferences, compliance constraints), and long-term flexibility (will you outgrow the framework's abstractions?).

For startups and prototypes, start with a higher-level framework (CrewAI, PydanticAI) or the native provider SDK. These minimize boilerplate and let you focus on the agent's logic rather than infrastructure. For production systems with complex state management, conditional workflows, and compliance requirements, LangGraph or a custom framework built on the raw API provides the control you need. For organizations committed to a specific cloud provider, the provider's SDK (OpenAI Agents SDK, Google ADK, Semantic Kernel for Azure) integrates most smoothly with the surrounding infrastructure.

pip install torch transformers numpy

# TODO: Implement setup code here

# Complete solution for 2. Framework Selection Guide
# TODO: Full implementation here

Exercises