Agentic frameworks: 7 top options and how to choose them

Agentic frameworks are software libraries that developers use to build AI agents: programs where a large language model (LLM) plans, calls tools, and completes multi-step tasks. 

Agent use is growing: in McKinsey's 2026 survey, 40% of respondents at organizations with annual revenue above $1 billion report scaling AI agents in one or more functions.

The 40% is up from 27% a year earlier. To help you choose a framework for building these agents, this guide compares seven agentic frameworks by orchestration style and language, then gives four checks for picking one.

Key takeaways

• Agentic frameworks differ mainly in how they orchestrate agents: through graphs, role-based teams, events, or handoffs between agents.
• This guide compares seven agentic frameworks, including LangGraph, CrewAI, and Microsoft Agent Framework, by orchestration style, language, and best-fit team.
• Choose by programming language, orchestration fit, production features such as saved state and approval steps, and Model Context Protocol (MCP) support. MCP is an open standard that connects agents to external tools.
• An agentic framework covers agent logic; connections to business apps, permissions, and run history are built separately or come from a platform.
• Plain code is enough when an agent follows a short, fixed sequence of steps.

What are agentic frameworks?

An agentic framework is a software library that gives a large language model (LLM) the structure to plan, call tools, remember context, and complete multi-step tasks. The model works through each step without human direction.

An AI agent is software that uses an LLM to reach a goal by choosing actions and checking the results. 

A framework typically handles six jobs for the agent:

• Reasoning loop: repeats a cycle of model decision, action, and result.
• Tool calling: runs the function or API call the model requests.
• Memory and state: stores history and task progress across steps.
• Orchestration: coordinates several agents or steps.
• Human-in-the-loop review: pauses a run so a person can approve or change an action.
• Tracing: records each model call and tool call for debugging.

The table below splits five layers of an agent system into what a framework typically handles and what your team still builds or buys.

Plain code is enough when an agent follows a short, fixed chain of prompts, because plain code gives full control. Frameworks become useful as the logic grows, for example when the model calls functions or several agents work together.

Make's explainer on AI agents describes how agents differ from rule-based automation. 

Make's guide on when to use AI agents explains how to split work between agents and fixed automation.

How do agentic frameworks orchestrate agents?

Every framework runs an agentic loop, in which the model perceives its input, reasons, acts through a tool, and observes the result. 

Make's guide to the agentic loop explains those four stages and shows how to build one. Different agentic frameworks vary in how they control that loop, and many support more than one style. 

The groups below place each framework by its main style.

Graph-based orchestration

A graph-based framework defines a task as nodes (steps) connected by edges (paths between steps), with shared state passed along the way.

• Examples: LangGraph, Microsoft Agent Framework workflows, and workflows in the Google Agent Development Kit (ADK).
• Best fit: tasks with known steps, where predictable paths matter more than flexibility.

Role-based orchestration

A role-based framework models the work as a team, with each agent holding a role, goals, and tools. 

• Examples: CrewAI, which groups specialist agents into crews.
• Best fit: work that splits into specialist tasks, such as research followed by drafting.

Make's comparison of AI agents and agentic automation explains how single-task agents differ from coordinated groups of agents.

Event-driven orchestration

An event-driven framework connects steps through events: each step receives an event, does its work, and returns an event that triggers the next matching step.

• Examples: LlamaIndex Workflows.
• Best fit: tasks with branches, loops, and steps that run in parallel.

Handoff-based agent loops

A handoff-based framework keeps the loop small and lets one agent pass a task to another agent that has a different skill.

• Examples: the OpenAI Agents software development kit (SDK), which adds guardrails, meaning checks on an agent's inputs and outputs, and smolagents (an open-source Python library from Hugging Face for building code agents), in which the agent writes its actions as code.
• Best fit: small multi-agent applications and prototypes where few abstractions keep the code readable.

‍How we chose these agentic frameworks

This list covers code-first agentic frameworks, which developers use to program agent logic in code. 

Each framework passed four checks against its maintainer's official documentation:

• It supports tool calling and multi-step tasks.
• Its maintainer publishes official documentation and a public code repository.
• The set as a whole covers different orchestration styles.
• The set as a whole covers different programming languages.

Each framework supports agentic AI, which Make's explainer defines as systems that perceive, reason, act, and learn with minimal human input.

What are the top agentic frameworks?

Each entry below says what the framework is, lists three standout features, and names the team it fits best.

1. LangGraph

LangGraph is a low-level orchestration framework, meaning you define each step yourself, for long-running agents that keep track of their progress. 

It comes from the makers of LangChain, whose own agent features run on LangGraph, and it also works without LangChain.

• Durable execution: an agent resumes from where it stopped after a failure.
• Human review: you can inspect and change agent state at any point.
• Memory and tracing: short-term and long-term memory, plus tracing in LangSmith, LangChain's tracing and debugging product.

Best for: Python engineers who want explicit control over every path; a JavaScript version, LangGraph.js, also exists.

2. CrewAI

CrewAI is an open-source Python framework for orchestrating teams of role-based agents. It is a standalone framework with its own components.

• Crews: teams of agents, each with a role, goals, and tools, that delegate tasks to one another.
• Flows: the layer that manages state and controls execution; CrewAI's documentation recommends starting with a Flow and adding a crew where a step needs a team.
• MCP support: agents can use tools hosted on MCP servers.

Best for: teams that want to model work as a group of specialists.

3. Microsoft Agent Framework

Microsoft Agent Framework is the successor to AutoGen, Microsoft's earlier multi-agent framework, and Semantic Kernel, Microsoft's earlier toolkit for connecting models to existing code. 

The Python and .NET versions, where .NET is Microsoft's application development platform, reached version 1.0 in Apr 2026.

• Orchestration patterns: including sequential, concurrent, handoff, and group chat, plus graph-based workflows, all with checkpointing, which saves progress, and human approvals.
• Model providers: including Microsoft Foundry, Anthropic, Azure OpenAI, OpenAI, and Ollama.
• MCP tools: agents can discover and call tools on MCP servers, and Make's guide to its MCP server explains how an agent runs Make scenarios as tools.

Best for: .NET teams, Microsoft-centered stacks, and teams migrating from AutoGen or Semantic Kernel.

4. OpenAI Agents SDK

The OpenAI Agents SDK is a lightweight framework with few abstractions for building multi-agent applications. It works with models from other providers as well as OpenAI's own.

• Core components: agents, handoffs, guardrails, sessions that keep memory during a run, and tracing.
• Guardrails: checks that validate inputs and outputs in parallel with the run and fail fast when a check fails.
• Language and tools: Python-first, with a JavaScript version in a separate repository, and support for MCP server tools.

Best for: small multi-agent applications with minimal framework code.

5. Google Agent Development Kit

Google's ADK is a framework that works with models from many providers and supports Python, TypeScript, Go, Java, and Kotlin. 

It scales from single agents to multi-agent systems through graph-based workflows and sub-agent delegation, in which one agent hands work to another.

• Models: works with Gemini and almost any other generative AI model, including through adapters for hosted and local models.
• Deployment: runs in containers on your own infrastructure or on Google Cloud, such as Cloud Run.
• Tools: supports MCP tools, and an agent can be exposed as an MCP server.

Best for: Java, Go, and Kotlin teams, and teams that deploy on Google Cloud.

6. LlamaIndex Workflows

LlamaIndex Workflows is an event-driven orchestration layer in Python from LlamaIndex, a framework for building agents over documents and data. 

Its documentation includes ‘retrieval-augmented generation’ (RAG) examples, in which the system retrieves relevant documents and gives them to the model before it answers.

• Event-driven steps: events connect steps, and branches, loops, and parallel steps are written as ordinary Python.
• Shared state and checkpoints: state is shared within a run, and durable workflows can checkpoint and resume after a restart.
• Standalone install: Workflows installs separately from the full LlamaIndex library.

Best for: document-heavy agents with branching logic.

7. smolagents

Next up, we have smolagents, which is an open-source Python library from Hugging Face, kept small by design so the agent logic is short enough to read in full. 

Its main agent type, the code agent, writes its actions as Python code.

• Code agents: writing actions as code lets one step combine function calls, loops, and conditionals.
• Models and tools: works with Hugging Face Inference Providers, with OpenAI and Anthropic models through the LiteLLM adapter, and with local models; tools can come from MCP servers.
• Sandboxing: the agent runs model-written code, so the documentation recommends an isolated sandbox, such as Modal, Blaxel, E2B, or Docker, to keep it away from your other systems.

Best for: prototypes and teams that want readable internals.

Agentic frameworks at a glance

The table below compares the seven frameworks by orchestration style, supported languages, and best-fit team.

The table lists code-first agentic frameworks. Make also has a ranked review of AI agent platforms that compares hosted platforms and code-first options by integration breadth, governance, and pricing.

How do you choose an agentic framework?

Four checks narrow the seven agentic frameworks above to two finalists: language fit, orchestration fit, production features, and protocol and model support. 

You pick the two by applying the checks to your own team and task, then test both on one real task before you commit.

Match the framework to your team's language and stack

A framework in a language your team already writes saves the cost of learning another one. Filter by the languages column in the comparison table from the previous section first.

• .NET teams can start with Microsoft Agent Framework, and Java, Go, and Kotlin teams can start with Google ADK.
• Teams that write only Python can shortlist any of the seven frameworks compared above.
• Frameworks also change names and owners: Microsoft Agent Framework replaced AutoGen and Semantic Kernel, so check a project's maintenance status in its documentation before you commit.

Match the orchestration style to how predictable the task is

Tasks with known steps suit graph-based or event-driven frameworks, because you define each path in advance. 

Open-ended tasks that need several specialists suit role-based or handoff-based frameworks, because the agents decide who works next.

• Known sequence: shortlist LangGraph, Google ADK workflows, or LlamaIndex Workflows.
• Open-ended collaboration: shortlist CrewAI or the OpenAI Agents SDK.

Check production features before you commit

In a LangChain survey of 1,340 respondents, 32% cited quality as a top barrier to putting agents into production. 

Frameworks with tracing, saved state, and human approval give you ways to find and correct quality problems, so test those features on a real task.

• Saved state: confirm that a run resumes from its last step after a failure.
• Human approval: confirm that a person can approve an action before it runs; Make's guide to autonomous AI covers where to keep people in the approval loop.
• Tracing: confirm that you can see every model call and tool call in a run.

Check protocol support and model flexibility

The Model Context Protocol (MCP) is an open standard, introduced by Anthropic, that lets an agent call tools hosted on any compliant server. 

Frameworks that document MCP tool support include Microsoft Agent Framework, the OpenAI Agents SDK, Google ADK, CrewAI, and smolagents.

• Tool access: the Make MCP Server exposes Make scenarios as tools that MCP-compatible agents can call. A framework agent can then run scenarios that use any of Make's 3,500+ apps and integrations.
• Model choice: frameworks that work with models from more than one provider include the OpenAI Agents SDK, Google ADK, smolagents, and Microsoft Agent Framework.

‍

How does Make fit alongside agentic frameworks?

For teams whose agents need only logic written in code, an agentic framework is a solid baseline. 

While those whose agents must act inside business apps, with permissions and run history, the next question is where those actions run.

Make's guide to the execution layer for agents describes four parts that reliable agent work needs: code, system access, context, and governance. 

A framework and Make combine in three ways:

• A framework agent calls Make: the agent uses the MCP Server to run Make scenarios as tools.
• Make calls outside tools: a scenario uses tools hosted on external MCP servers through the MCP Client, which Make's guide to the setup walks through.
• The agent is built in Make: Make AI Agents are built and debugged on the same canvas as scenarios. The Reasoning Panel shows each step and the tools used, and manual approvals are available

Make has 3,500+ apps and integrations, giving agents in all three setups the same business systems to act on.

Which agentic framework will you test first?

Pick among agentic frameworks by language fit, orchestration style, and production features, then text your choice on one real task.

Take one task from your backlog, build it in two of the seven frameworks above, and compare the traces. 

If the agent has to act inside business apps, try Make. Build the automation yourself or describe what you need to Maia by Make, Make's AI coworker, who will do so with you. 

Then, review each step it builds in the Scenario Builder.

Frequently asked questions

Q1: What are examples of agentic frameworks?

Examples of agentic frameworks include LangGraph, CrewAI, Microsoft Agent Framework, the OpenAI Agents software development kit (SDK), Google's Agent Development Kit (ADK), LlamaIndex Workflows, and smolagents. They differ in orchestration style, programming language, and production features.

Q2: Which agentic framework is best?

No single agentic framework is best for every team. The right choice depends on your programming language, how predictable the task is, and the production features you need, so test two finalists on one real task.

Q3: What is the difference between an LLM and an agentic framework?

A large language model (LLM) generates text or decisions from a prompt. An agentic framework wraps the LLM with a reasoning loop, tool calling, memory, and human review, so the model can complete multi-step tasks.

Q4: Do you need an agentic framework to build an AI agent?

Plain code is enough for an AI agent that follows a short, fixed sequence of steps, because plain code gives full control. A framework becomes useful when the agent calls many tools or coordinates several agents.

Q5: Which agentic frameworks work with Python?

As of Oct 2026, LangGraph, CrewAI, Microsoft Agent Framework, the OpenAI Agents software development kit (SDK), Google's Agent Development Kit (ADK), LlamaIndex Workflows, and smolagents all support Python. Several also support other languages, including JavaScript, Java, and Go.

Q6: What is the difference between an agentic framework and an AI agent platform?

An agentic framework is a code library that developers use to program agent logic. An AI agent platform such as Make hosts the agent, connects it to business apps, and adds visual building, approvals, and run history.