Frameworks & Tools

Overview of major agentic AI frameworks and runtimes: OpenAI Agents SDK, LangGraph, CrewAI, Google ADK, smolagents, AutoGen, and more.

A growing ecosystem of frameworks supports the development of agentic AI systems. Each takes a different approach to orchestration, tool integration, and multi-agent coordination. This page provides a brief overview of the major options to help you evaluate which might suit your needs.

LangGraph

LangGraph is a framework for building stateful, multi-step agent applications as graphs. Built on top of LangChain, it models agent logic as nodes and edges in a directed graph, giving developers fine-grained control over execution flow, state management, and branching logic.

Key strength: Explicit graph-based control flow that makes complex agent architectures visible and debuggable.

LangGraph Documentation

Google ADK

Google’s Agent Development Kit (ADK) provides patterns and primitives for building agentic systems with a focus on production design patterns (including human-in-the-loop) and integration with Google’s ecosystem.

Key strength: Opinionated production patterns and integration with Google’s tooling.

HuggingFace smolagents

smolagents is a lightweight framework that highlights the difference between code agents (agents that write code to execute) and tool-calling agents (structured calls). It emphasizes simplicity and minimal abstraction.

Key strength: Clear, minimal primitives with a strong “code agent” path.

Microsoft AutoGen

AutoGen (Microsoft) is a framework for multi-agent conversational systems. Agents communicate via message passing and patterns emerge from conversation structure. It supports fully autonomous and human-in-the-loop configurations.

Key strength: Flexible conversation-based multi-agent patterns.

AutoGen Documentation

Amazon Bedrock AI Agent

Amazon Bedrock Agents provides a managed service for building agents within the AWS ecosystem. It handles orchestration, memory, and tool integration with tight connections to other AWS services. Agents are configured through a combination of instructions, action groups, and knowledge bases.

Key strength: Deep AWS integration and fully managed infrastructure, reducing operational overhead for teams already on AWS.

Amazon Bedrock Agents Documentation

Anthropic Agent SDK

Anthropic’s Agent SDK provides a lightweight, Python-based framework for building agents powered by Claude. It emphasizes simplicity and directness, offering primitives for tool use, multi-agent handoffs, and guardrails without imposing heavy abstractions.

Key strength: Minimal abstraction layer designed around the patterns described in Anthropic’s “Building Effective Agents” research, favoring transparency over framework magic.

Anthropic Agent SDK on GitHub

OpenAI Agents SDK

The OpenAI Agents SDK provides tools for building single and multi-agent workflows with OpenAI models. It includes built-in support for agent handoffs, guardrails, tracing, and tool integration, with a focus on making common patterns easy to implement.

Key strength: Streamlined developer experience with built-in tracing and observability for debugging agent behavior.

OpenAI Agents SDK Documentation

CrewAI

CrewAI is a framework for orchestrating multiple AI agents that work together as a team. It uses a role-based model where each agent has a defined role, goal, and backstory, and agents collaborate to accomplish tasks through structured processes.

Key strength: Intuitive role-based abstractions that make multi-agent collaboration straightforward to set up and reason about.

CrewAI Documentation

LlamaIndex (Agents)

LlamaIndex has expanded from RAG tooling into agent orchestration primitives, including “agent-as-a-service” patterns and integrations for agentic retrieval.

Key strength: Strong data + retrieval foundations that carry into agentic RAG.

Choosing a Framework

Before adopting any framework, consider Anthropic’s advice: start with direct API usage and simple code. Frameworks add convenience but also add abstraction that can obscure what is actually happening. Understand the underlying patterns first, then evaluate whether a framework genuinely reduces complexity for your specific use case --- or whether it simply moves it around.