TL;DR
Of the seven code-first AI agent frameworks developers should evaluate in November 2026, pick LangGraph for approval-heavy workflows, CrewAI for role-based teams and your cloud’s SDK for one identity boundary. The vendor-backed options are Microsoft Agent Framework, OpenAI Agents SDK, Google ADK and Strands Agents, while Pydantic AI leads on typed, validated output. AutoGen is off the list, because Microsoft archived its repository and points new users to Microsoft Agent Framework. Every version in this guide was re-checked at PyPI on November 3, 2026. The real differences sit in durable execution, mid-run human approval, tracing, evaluation and support for the MCP and A2A protocols. All seven core libraries are free under MIT or Apache 2.0, so model tokens and operations make up the actual bill.
Key Takeaways
AutoGen is archived and no longer maintained, so any 2025 shortlist that still lists it carries a dead entry.
Match the job first: approvals and long runs point to LangGraph or Microsoft Agent Framework, role-based teams to CrewAI and typed extraction to Pydantic AI.
LangGraph handles branching, checkpointing and mid-run human approval better than any other open-source option.
CrewAI gets a role-based agent team running with the least boilerplate, while its Flows layer adds deterministic control.
MCP and A2A turned tool access and agent handoffs into shared protocols, so switching frameworks costs less.
The framework license is free in every case, so the bill is model tokens, hosting and tracing, and turn limits are cost controls.
Pick by where your agents run, since the vendor SDKs favor one cloud while LangGraph, CrewAI and Pydantic AI run anywhere.
Watch on YouTube
How Enterprise AI Agents Are Designed for Real Business Decisions
How enterprise agents are scoped around one real decision and the data, tools and approvals it needs.
AutoGen Is Archived: What That Means for Your Shortlist
On September 30, 2025, autogen-agentchat 0.7.5 reached PyPI. Thirteen months later it is still the last release, and Microsoft’s AutoGen repository says the project is archived and no longer maintained.
The same README also sends new users to Microsoft Agent Framework and links a migration guide. A shortlist written in 2025 that still names AutoGen is carrying an entry that will never get another fix.
That change is only the most visible one, because framework choice in 2026 also turns on questions a demo rarely asks. Can a run resume after a crash, and can a person approve a step before it runs? Can you then swap the model without a rewrite?
This guide is written for developers and engineering leads who will write the agent in code. It covers code-first libraries only, not hosted or no-code builder platforms.
If you are moving an existing AutoGen codebase, our AutoGen vs LangChain comparison covers where that code can land.
Which AI Agent Framework for Which Job
Start with the job, then check five things. Can a run survive a crash, and where can a person approve a step? Which protocols does it speak, which languages does it support and how mature is the release line?
The table answers those questions for the seven frameworks in this guide. The profiles and comparison tables further down carry the detail.
Table 1: Which AI agent framework fits which job, snapshot, November 3, 2026
Framework Pick it for State and durability Human approval MCP and A2A Languages Maturity
LangGraph Branching workflows with approvals and long runs Native checkpointing; a crashed run resumes from its last step Interrupt at any node MCP yes; A2A via Agent Server endpoint Python, JavaScript 1.x since October 2025 CrewAI Role-based agent teams with little setup Flows state Task-level approval MCP yes; A2A client and server Python 1.x, very fast release pace; pin versions Microsoft Agent Framework Agents inside an Azure identity and billing boundary Native, long-running workflows Built into workflows MCP yes, including hosted MCP; A2A yes Python, .NET (Go in preview) 1.x; successor to AutoGen and Semantic Kernel OpenAI Agents SDK A working single agent within a week on OpenAI models Session persistence Guardrail-based MCP yes; A2A not built in Python, TypeScript Still below 1.0; pin it Google ADK Teams outside Python, and agents from several vendors Native Callback-based MCP native; A2A experimental Python, TypeScript, Go, Java, Kotlin 2.x Pydantic AI Typed extraction and classification Durable execution on engines such as Temporal and DBOS Tool approval built in MCP yes; A2A through the separate FastA2A project Python 2.x Strands Agents Model-led agents on AWS Persisted sessions and state Interrupts that pause for approval MCP yes; A2A guide and client tool Python, TypeScript 1.x
The most common head-to-head is LangGraph vs CrewAI. Pick LangGraph when you need to control every transition and pause anywhere for approval. Pick CrewAI when the work splits into named roles and a fast first crew matters more than fine-grained control.
Two rules settle most of the remaining cases. If the first release needs an approval step or a run that outlasts a request timeout, start on LangGraph or Microsoft Agent Framework. If the agent must stay inside one cloud’s identity boundary, start with that cloud’s SDK.
Framework or Platform?
A framework is a library your engineers import, test, deploy and operate. A builder platform is a product your team configures, with hosting, identity and billing already in place. If a business team will own the agent, or you want to buy rather than build, read our buyer’s guide to AI agent builder platforms instead. The rest of this guide is about frameworks only.
What an AI Agent Framework Actually Gives You
An AI agent framework is the runtime that sits between your application code and a language model. It runs the loop in which the model reasons, calls a tool, reads the result and then decides what to do next.
You can write that loop by hand, and plenty of teams start that way before they switch. Within a quarter, though, most of them have rebuilt the same five components.
Tool calling and schemas. Turning a Python function into something a model can call reliably, then validating what comes back.State. Keeping conversation history, intermediate results and scratchpad memory intact while a run spans many model calls.Control flow. Branching, retries, loops with a stopping condition, and parallel steps that fan back in once they finish.Multi-agent coordination. Handing work between specialized agents so context survives and no run loops forever.Observability. Traces of every model call, tool call, token count and failure, so an engineer can debug a bad run.
A framework earns its place when it does those five well enough that your team writes business logic instead of plumbing. It stops earning its place when its abstractions hide something you need to control, such as a silent retry or a tool output nobody logged.
The framework is also only one layer of the system, and our guide to AI agent architecture maps the layers around it.
The Agent Loop
Every framework on this list runs some version of the same four-step loop. The model plans a step, calls a tool, observes the result and then decides whether to continue or stop.
For example, take an accounts-payable agent asked what is open for one vendor. It plans a lookup, calls the invoice tool, reads three open invoices and then decides that one of them needs a payment approval.
The interesting engineering sits between those steps, though. State is written after each observation, so a crash does not erase the work done so far. An approval gate sits just before the step that spends money, where a person can inspect the plan and edit it.
Limits also wrap the whole loop. A recursion or turn limit stops a run when it keeps calling tools, and a budget cap stops one that keeps spending tokens. Our walkthrough of how to build AI agents covers the loop step by step.
Do You Need a Framework at All?
If you can write a plain function to handle the task, write the function instead of building an agent.
Skip the framework when the workflow is deterministic, or when one model call with a structured output schema does the job. In that case, a direct SDK call plus your existing job scheduler is cheaper to run and far easier to audit. The episode below weighs that exact trade between an agent and a traditional workflow.
Reach for a framework when the number of steps is decided at runtime. The same goes for a model that must choose between several tools, or a job that needs more than one agent. The shape of that work then decides which kind of framework fits.
Single agent with tools. One model, a handful of tools and a turn limit. The OpenAI Agents SDK, Pydantic AI and Strands Agents keep this light.Multi-agent team. Specialists hand work to each other until the task is done. CrewAI and Microsoft Agent Framework model this directly, and our guide to multi-agent AI systems explains when the extra agents pay off.Graph workflow. Explicit nodes, edges and state, with branches you can audit. LangGraph fits here, as well as the workflow layers of Microsoft Agent Framework and Google ADK.
If the job is mostly answering questions in a chat window, you may not need an agent at all. Our comparison of AI agents vs chatbots draws that line from the user’s side.
What Changed Between 2025 and 2026
Three shifts matter more than any single release, and each one changes how you should read an older comparison. Together they explain why the 2026 shortlist is shorter than before.
The Field Consolidated Around Maintained Projects
LangChain and LangGraph both reached 1.0 on October 22, 2025. The LangChain 1.0 announcement promised no breaking changes until 2.0, and langchain itself had reached version 1.4.8 by November 3, 2026.
CrewAI moved to a fast cadence after its own 1.0. Its PyPI history shows 69 releases between September 1 and November 3, 2026, an average of more than seven a week.
Microsoft also folded AutoGen and Semantic Kernel into one successor, Microsoft Agent Framework.
Release history is therefore a selection criterion, and a framework with no release in six months deserves a harder look.
Tool Access and Agent Handoffs Became Protocols
The Model Context Protocol (MCP) standardized how an agent reaches a tool or a data source. The Agent2Agent protocol (A2A) standardized how one agent delegates work to another.
A2A launched as a Linux Foundation project on June 23, 2025 , with AWS, Cisco, Microsoft, Salesforce, SAP and ServiceNow backing it at launch. Neutral governance also gives competing vendors one handoff format to build against.
Both protocols moved integration work out of the framework layer, so frameworks compete less on connectors. A tool exposed over MCP works with any framework that speaks MCP, so switching frameworks no longer means rewriting every connector.
Our breakdown of MCP vs A2A covers where each protocol fits and when to use both. For the tool side in code, our LangGraph MCP integration guide walks through a working server.
Durability Became Table Stakes
Early agent code lost everything when a process died. Enterprise agents run for minutes or hours, and some wait days before an approval arrives. Checkpointing and resumable runs are therefore standard in the serious frameworks.
Durability also shapes coordination, and our guide to AI agent orchestration covers the patterns that depend on state surviving between steps.
Taken together, the three shifts raise the entry bar for every framework. Durable execution and MCP support are what a 2026 framework needs before it makes the shortlist, not what makes it win.
The Seven AI Agent Frameworks Worth Evaluating in 2026
Seven AI agent frameworks cover almost every enterprise build in late 2026.
Versions and licenses below were read from PyPI and GitHub on November 3, 2026, rather than from vendor marketing. They move fast, so treat the table as a snapshot and re-check before you commit.
Table 2: The seven AI agent frameworks at a glance, snapshot, November 3, 2026
Framework Backed by Latest release (PyPI) License Languages Built for
LangGraph LangChain 1.2.19 , Oct 30, 2026MIT Python, JavaScript Stateful, branching, long-running workflows CrewAI CrewAI Inc. 1.15.35 , Nov 3, 2026MIT Python Role-based agent teams with little setup Microsoft Agent Framework Microsoft 1.24.0 , Oct 30, 2026MIT Python, .NET (Go in public preview, separate repo) Enterprise multi-agent workflows on Azure OpenAI Agents SDK OpenAI 0.24.0 , Oct 15, 2026MIT Python, TypeScript Fast builds on a small set of primitives Google ADK Google 2.13.0 , Oct 23, 2026Apache 2.0 Python, TypeScript, Go, Java, Kotlin Code-first agents, optimized for Gemini, model-agnostic Pydantic AI Pydantic 2.65.0 , Nov 3, 2026MIT Python Type-safe agents with validated outputs Strands Agents AWS and community 1.63.0 , Oct 30, 2026Apache 2.0 Python, TypeScript Model-driven agents, Amazon Bedrock by default
Five of the seven ship under MIT and two under Apache 2.0, so none of them charges for the core library.
The commercial question, however, sits beside the library. Price the managed platform you would run it on, such as LangSmith Deployment (formerly LangGraph Platform), CrewAI AMP or Microsoft Foundry, before you compare total cost. The cost check below then works through the model bill, which is usually the largest line.
1. LangGraph
LangGraph models an agent as a graph of nodes and edges around an explicit, typed state object. That design handles branching, retries and cycles more predictably than a prompt-and-loop library does.
Its headline capabilities are durable execution, human-in-the-loop interrupts, layered memory, as well as tracing through LangSmith. A crashed run resumes from its last checkpoint instead of starting over and paying for every model call again.
LangChain 1.x sits above it as the higher-level agent layer, with a create_agent entry point and middleware for summarization, redaction and approval. Our LangChain vs LangGraph comparison explains when to use each and where the boundary falls.
The sample below is a minimal StateGraph that summarizes a vendor’s open invoices, then pauses for a person before anything is paid.
# Illustrative: a LangGraph StateGraph with a checkpointer and a human approval step
from typing import TypedDict
from langchain.chat_models import init_chat_model
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.types import interrupt, Command
model = init_chat_model(model="openai:gpt-6.1-sol")
class APState(TypedDict):
vendor_id: str
summary: str
decision: str
def summarize(state: APState) -> dict:
invoices = lookup_invoices(state["vendor_id"]) # your invoice tool
reply = model.invoke(f"Summarize these open invoices: {invoices}")
return {"summary": reply.content}
def approve(state: APState) -> dict:
decision = interrupt({"action": "approve_payment", "summary": state["summary"]})
return {"decision": decision}
builder = StateGraph(APState)
builder.add_node("summarize", summarize)
builder.add_node("approve", approve)
builder.add_edge(START, "summarize")
builder.add_edge("summarize", "approve")
builder.add_edge("approve", END)
with PostgresSaver.from_conn_string(PG_URI) as checkpointer:
graph = builder.compile(checkpointer=checkpointer)
config = {"configurable": {"thread_id": "ap-run-4417"}, "recursion_limit": 25}
graph.invoke({"vendor_id": "A-4417"}, config) # pauses at the approve node
graph.invoke(Command(resume="yes"), config) # resumes once a person answersThree details make this production code rather than a demo. The Postgres checkpointer survives a restart, the thread_id names the run to resume, and interrupt() pauses the graph until a person answers. Keep recursion_limit set as well, so a looping graph fails fast instead of spending tokens.
Choose it when the workflow has real branching, an approval step or a run that outlasts a request timeout. Think twice when the task is one agent with three tools, because the graph is overhead you do not need.
2. CrewAI
CrewAI organizes work around agents with a role, a goal and a backstory, grouped into a crew that runs tasks. That framing maps onto processes people already describe as team handoffs, so non-engineers can follow a design review.
The framework also has two layers worth separating. Crews give you autonomous collaboration between agents, while Flows give you event-driven, stateful control over the order of steps.
Its release pace is the fastest on this list, with 69 releases since September 1 and version 1.15.35 on November 3, 2026. Pin versions and read the changelog before each upgrade.
Two settings carry most of the production risk, so set both early. Set max_iter on every agent so a stuck reasoning loop ends. Set max_rpm on the crew so a parallel run does not trip your provider’s rate limit halfway through a batch.
Choose it when the problem splits into named roles such as researcher, analyst and reviewer. Think twice when you need fine-grained control over every transition, because the role metaphor hides some of it.
3. Microsoft Agent Framework
Microsoft Agent Framework is the successor to both AutoGen and Semantic Kernel, built by the same teams. Version 1.24.0 shipped on October 30, 2026, under the MIT license.
It ships for Python and .NET, while its GitHub repository points to a Go SDK, in public preview, kept in a separate repo. Graph-based workflows, OpenTelemetry tracing, middleware and Microsoft Foundry deployment come built in rather than bolted on.
# Illustrative: a Microsoft Agent Framework agent on Microsoft Foundry
from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential
agent = Agent(
client=FoundryChatClient(
project_endpoint="https://<your-foundry-project-endpoint>",
model="<your-model-deployment>", # your Foundry model deployment name
credential=AzureCliCredential(),
),
name="ClaimsTriageAgent",
instructions="Triage inbound claims and flag anything above threshold.",
)
result = await agent.run("Triage claim 88213.")Migration is the practical question when a team still runs AutoGen code. Microsoft publishes a migration guide from AutoGen, and a working AutoGen group chat usually maps to a handoff workflow rather than a full rewrite.
Choose it when the organization already runs on Azure and needs agents inside its existing identity, governance and billing boundary. Think twice when your stack is Python-only and cloud-neutral. Our CrewAI vs AutoGen vs Microsoft Agent Framework breakdown covers the migration angle in depth.
Kanerika Service
Plan a Production AI Agent
Kanerika scopes the workflow, picks the framework and builds agents with approvals, tracing and governance in place.
Explore Agentic AI Services 4. OpenAI Agents SDK
The OpenAI Agents SDK is the production successor to OpenAI’s Swarm experiment. It keeps a deliberately small surface: three primitives, plus sessions for memory.
Agents. A model with instructions and tools.Handoffs. One agent delegating a task to another.Guardrails. Validation on inputs and outputs.Sessions. Memory that persists once a turn ends.
Built-in tracing makes runs visible without extra wiring. The SDK also works with non-OpenAI providers through LiteLLM, though the tightest integration is with OpenAI’s own hosted tools.
Set max_turns on the runner before the first real test. Without it, two agents that can hand off to each other will keep doing so, and the cost appears on the invoice before it appears on a dashboard.
Best fit is a team that wants a working agent within a week, especially when it is already committed to OpenAI models. Version 0.24.0, released on October 15, 2026, is still below 1.0, so pin it and read the release notes before each upgrade. Our post on OpenAI AgentKit covers the adjacent visual layer.
5. Google Agent Development Kit
Google’s Agent Development Kit (ADK) is a code-first toolkit that spans Python, TypeScript, Go, Java and Kotlin. Version 2.13.0 shipped on October 23, 2026, under Apache 2.0.
The project README describes ADK as optimized for Gemini while staying model-agnostic and deployment-agnostic. Gemini gets the smoothest path, while other models and hosting targets stay open.
ADK combines graph workflows with plain code, and it also treats context as something to manage, filtering and summarizing what reaches the model. It supports MCP natively, and its A2A module, still labeled experimental, matters when agents from several vendors must cooperate.
Best fit is a team that wants a vendor-maintained framework but no single-model commitment. It also suits teams that do not write Python, since no other option on this list covers as many languages.
6. Pydantic AI
Pydantic AI brings the validation model Python developers already use for API schemas into the agent loop. Outputs are typed and validated, so a class of silent model errors becomes an exception you can catch and retry.
It supports the major model providers and also adds durable execution, streaming and Pydantic Logfire tracing. Teams that already standardize on Pydantic pick it up quickly, because its output types are ordinary Pydantic models.
Best fit is extraction and classification work, where schema-conformant output matters more than elaborate orchestration. Version 2.65.0 shipped on November 3, 2026, under the MIT license.
7. Strands Agents
Strands Agents takes a model-driven approach to agent design. The model plans, while the SDK supplies the lifecycle, tool management and observability around it.
Its repository documents Amazon Bedrock as the default provider, with first-class support for Bedrock, Anthropic, OpenAI and Gemini models. Version 1.63.0 shipped on October 30, 2026, under Apache 2.0.
It runs in your own process with no hosted control plane, so it suits AWS-centric teams that want to avoid a heavier orchestration layer.
Best fit is an AWS deployment where the agent logic is model-led rather than a fixed sequence of auditable steps.
Also Worth Knowing
Five more projects also deserve a line each, since each one wins a specific kind of project.
Semantic Kernel. Still shipping, with version 1.46.0 on October 28, 2026, though Microsoft positions Agent Framework as its successor, as our Semantic Kernel vs LangChain comparison explains.LlamaIndex Workflows. The strongest option when the agent is mainly a retrieval and document problem, with llama-index-core 0.14.25 released on September 21, 2026, as well as a place in our LlamaIndex vs LangChain vs Haystack comparison.smolagents. A deliberately small Hugging Face library for agents that write and run code, under Apache 2.0. Its last release , 1.26.0, came on May 29, 2026, with none since.Mastra. The most complete TypeScript-native option when a team’s product is already a Node application.Claude Agent SDK. Anthropic’s MIT-licensed SDK for building agents on Claude models, at version 0.2.177 on November 3, 2026.
AI Assessment
How Ready Is Your Organization for Production AI Agents?
Before you run a spike, score your AI maturity across data, governance, skills and operations, and see which gaps to close first.
Start Your AI Assessment → AI Agent Frameworks Compared on Production Criteria
Feature checklists age badly, so the rows below compare behavior instead. They describe what each framework does when something goes wrong, which changes far more slowly than the API surface.
The ratings are Kanerika’s reading of each project’s documentation as of November 3, 2026, rather than a benchmark.
Table 3: How five widely used AI agent frameworks compare on production behavior
Capability LangGraph CrewAI MS Agent Framework OpenAI Agents SDK Google ADK
Durable execution and resume Native checkpointing Via Flows state Native, long-running Session persistence Native Human-in-the-loop Interrupt at any node Task-level approval Built into workflows Guardrail-based Callback-based Long-term memory Built-in store Built-in memory Context providers Sessions Session and memory services Native MCP support Yes Yes Yes, including hosted MCP Yes Yes Native A2A support Via Agent Server endpoint Yes, client and server Yes Not built in Yes, experimental Model portability Any provider Any provider Any provider Best with OpenAI Model-agnostic, optimized for Gemini Tracing and evaluation LangSmith Built-in plus third party OpenTelemetry Built-in tracing Built-in eval suite Managed deployment path LangSmith Deployment CrewAI AMP Microsoft Foundry OpenAI platform Deployment-agnostic
Two rows deserve emphasis, though. Native A2A support matters as soon as agents from different teams or vendors must talk. A managed deployment path also decides whether your platform team inherits new infrastructure.
Pydantic AI and Strands Agents sit outside this table, since Pydantic AI competes on typed output and Strands on a light, model-led runtime. The use-case table below reflects both.
Seven Criteria for Evaluating an AI Agent Framework
Run every candidate through the same questions using the same workflow. Answer them with a two-day spike rather than a docs page, because documentation rarely admits a weakness.
The seven criteria test behavior when something fails. A final cost check then puts a price on the run, which is where a framework’s design shows up on the invoice.
1. Durable Execution
Kill the process halfway through a run, then restart it. A framework with real checkpointing resumes from the last completed step, while a weaker one restarts from zero and repeats every paid model call.
Also check where checkpoints live. An in-memory store passes a demo but loses everything on the first deploy.
2. State and Memory
Separate working memory inside one run from long-term memory that persists across sessions. Most frameworks handle the first well but differ sharply on the second, which is where account history and personalization live.
For example, a support agent should recall last month’s ticket from the same customer without replaying the whole thread. Test that in the spike by closing a session and opening a new one.
3. Human in the Loop
Any agent that spends money, sends external messages or changes a record needs an approval gate. Then check whether a person can inspect and edit agent state mid-run, or only approve a final output.
Placement matters as much as the feature. Put the gate just before the side effect, so a rejected step costs one model call rather than the whole run.
4. Protocol Support
Native MCP means your tools will work with the next framework too. Native A2A similarly means an agent your team did not build can call yours.
Both also lower the cost of a future migration, which is the real hedge against picking wrong.
5. Observability
You need traces at the level of individual model and tool calls, with token counts and latency attached. Without them, debugging an agent that fails once in 200 runs turns into guesswork.
Prefer frameworks that emit OpenTelemetry, so agent traces land beside your other services. Our guide to AI agent observability covers what to instrument and where.
6. Evaluation
Ask how the framework supports repeatable scoring against a fixed dataset. Teams that skip this ship a regression every time they change a prompt, then hear about it from users.
The dataset should also come from real inputs and include the failures you already know about. See AI agent evaluation for a working method.
7. Model Portability
Model prices and capabilities shift every few months. So estimate the work to swap the underlying model, and treat any framework where that means a rewrite as a commercial risk.
An LLM gateway in front of the framework makes the swap cheaper again, because routing and keys live outside the agent code.
The Cost Check: What a Run Actually Costs
Every framework here is free to use, so the bill comes from models and operations. Model tokens are usually the largest line, while the framework’s design decides how many of them a run consumes.
The prices below were read from vendor pages on November 2, 2026. They are in US dollars per million tokens, and Gemini 4 Argon rises to $4.00 and $20.00 from December 1, 2026.
Table 4: Model prices per million tokens, read November 2, 2026
Model Input Output
GPT-6.1 Sol $2.00 $10.00 GPT-6 Luna $0.10 $0.50 Claude Opus 5.5 $4.00 $20.00 Claude Sonnet 5.5 $2.00 $10.00 Claude Haiku 5.5 (prompts up to 100K tokens) $0.10 $0.50 Gemini 4 Argon (through November 30, 2026) $2.00 $10.00 Gemini 3.8 Flash (through December 31, 2026) $0.75 $3.75
Here is a worked example with its assumptions stated. Suppose, for example, that one run makes 10 model calls, each with 8,000 input tokens and 800 output tokens.
That adds up to 80,000 input and 8,000 output tokens per run. On GPT-6.1 Sol it costs $0.16 plus $0.08, or $0.24 per run, which is $2,400 for 10,000 runs a month.
The same run on Claude Haiku 5.5, by comparison, costs $0.008 plus $0.004, or $0.012, which is $120 a month. A loop that doubles the call count doubles either bill, which is why turn limits and recursion limits are cost controls.
Checklist
Check Your Agentic AI Readiness
Score your data, tools, approvals and governance before an agent reaches production.
Get the Checklist → Tracing, hosting and evaluation runs also come on top of tokens. Our guide to AI agent development cost breaks down the build side of the budget.
How to Choose an AI Agent Framework by Use Case
Most debates about AI agent frameworks end once the use case is stated precisely. The table below maps common enterprise patterns to a default choice and a credible alternative.
Table 5: Framework selection by use case
Use case Default choice Alternative Why
Multi-step workflow with approvals LangGraph Microsoft Agent Framework Interrupts and checkpointing are native Research or content team of agents CrewAI Google ADK Role decomposition with little boilerplate Agents inside an Azure estate Microsoft Agent Framework Semantic Kernel, for existing code Identity, Foundry and .NET support Fast prototype on OpenAI models OpenAI Agents SDK Pydantic AI Fewest primitives to learn Document and retrieval-heavy agent LlamaIndex Workflows LangGraph Indexing and retrieval are the core problem (LlamaIndex sits outside the seven) Structured data extraction at scale Pydantic AI OpenAI Agents SDK Validated, typed outputs AWS-native deployment Strands Agents Google ADK Bedrock by default, no hosted control plane Agents from several vendors that must interoperate Google ADK Microsoft Agent Framework Native A2A on both sides, still experimental in ADK
A Rule for the First Release
The first row of the table hides the most expensive mistake. If any step in the first release needs a person’s approval, start on LangGraph or Microsoft Agent Framework. Do the same when a run may outlast a request timeout, even if version one looks simple.
Write the decision down as a rule your team can apply to the next project as well as this one. The matrix below condenses the use-case table into that rule.
Match the Framework to Your Team’s Language
Language narrows the field before features do. Python teams can pick any of the seven, and TypeScript teams still have five options: LangGraph’s JavaScript version, the OpenAI Agents SDK, Google ADK, Strands Agents and Mastra.
.NET shops have one natural home in Microsoft Agent Framework. Teams writing Go, Java or Kotlin will find Google ADK the broadest option, with Microsoft’s separate Go SDK as a second look for Go.
When more than one agent is involved, sequence them before you pick a library. Our guide to multi-agent workflows covers how to order the handoffs and where state should live.
Where Agent Projects Break on the Way to Production
The choice of framework explains fewer failures than most teams expect. These five failure points show up whichever library sits underneath, and our post on AI agent challenges covers the operational side in more depth.
Real Data Breaks Brittle Prompts
A prototype usually runs on clean sample inputs. Production inputs carry missing fields, inconsistent formats and edge cases nobody described, so prompts tuned on the clean set degrade quietly.
The fix is an evaluation set built from real historical inputs before the pilot ends. Include the records your team already knows are awkward, because those are the ones the model meets first.
Handoffs Loop and Costs Spiral
Two agents that can each call the other will eventually do so, and they continue until something stops them. So set explicit iteration limits, a budget cap per run and a termination condition that does not depend on the model.
Each framework names the limit differently: max_turns in the OpenAI Agents SDK, max_iter in CrewAI and recursion_limit in LangGraph. Set all of them before the first load test, not after the first invoice.
Long Runs Lose State
A run that takes eleven minutes will eventually meet a timeout, a deploy or a restart. Without checkpointing, all of that work and spend is gone.
A useful test is to deploy a new version while a run is paused at an approval. When the run resumes cleanly on the new code, both the checkpoint format and the release process are ready.
That is why durable execution moved from a nice feature to a selection criterion. The storage behind the checkpointer also belongs in the infrastructure plan, which our guide to AI agent infrastructure covers.
No Traces Means No Root Cause
An agent that fails once in fifty runs is almost impossible to debug from logs alone, because the failing path is rarely the logged one. Turn tracing on before the pilot, not after the first incident.
Keep the calling identity on every trace while you are at it. The same record that explains a failure also answers the auditor’s question later.
Governance Arrives Late
Data access, PII handling, model approval and audit logging are usually raised by a risk team only after a working demo exists. Bringing those questions into the design phase instead avoids a rebuild.
The cheapest moment to answer them is before the first prompt is written. The next section covers what that means for the framework and the data underneath it.
Governing Agent Frameworks: Access Control, Audit Trails and Errors
Governance is where the framework matters least and the surrounding design matters most. What decides whether an agent is safe to deploy is the data and tool surface underneath it.
Two agents on different frameworks, pointed at the same permissioned data layer, behave about the same. Two agents on the same framework, in contrast, behave nothing alike when only one has row-level permissions.
None of the seven frameworks enforces your access model for you. Each gives an agent whatever credentials you hand it, so the agent inherits the permissions of the identity it runs as.
Public frameworks also help structure the controls. The NIST AI Risk Management Framework , released on January 26, 2023, added a generative AI profile, NIST-AI-600-1, on July 26, 2024. Our agentic AI governance guide maps that kind of control set to agents.
The Permission Question Nobody Asks Until the Security Review
Most first builds run the agent under one service account with broad read access, because that is the quickest path. It works in a pilot but fails the moment two users with different entitlements ask the same question.
The OWASP Top 10 for LLM applications (2025) names this risk LLM06 Excessive Agency, alongside LLM01 Prompt Injection. An agent with more permissions than its task needs turns a manipulated prompt into a real action.
Three patterns solve it, listed here in ascending order of effort.
Identity pass-through. The agent calls downstream systems as the end user, so existing entitlements apply unchanged. It is the cleanest option, and it is also one reason Microsoft Agent Framework appeals to teams on Entra ID.Filtered retrieval. The agent queries a governed layer that applies row-level and column-level security before results reach the model. A catalog such as Microsoft Purview or Unity Catalog earns its keep here, and agentic RAG designs need the most care.Tool-level authorization. Each MCP tool checks the caller’s entitlement and then refuses out-of-scope calls. It is the most portable across frameworks but also the most code to maintain.
Pick one deliberately at design time. Retrofitting any of the three onto a working agent means re-testing every prompt and tool, because the data the model sees has changed. Our guide to agentic AI security covers the threat side.
Audit Trails Are a Framework Selection Criterion
A reviewer will eventually ask what the agent did, on whose behalf, with which data and who approved it. Answering that question needs the trace to carry the calling identity as well as the model and tool calls.
That is an instrumentation property, not something you get for free. Frameworks with OpenTelemetry output make it simpler, because the traces land in the observability stack your other services already use.
Also decide early how long traces are kept and who can read them. Traces often hold the same customer data the agent read, so they need the same access controls as the source systems.
Kanerika Service
Govern AI Agents Before They Reach Production
Kanerika designs access controls, audit trails and approval policies for AI agents, mapped to the data governance you already run.
Explore AI Governance How Errors and Exceptions Actually Get Handled
Agent failures split into three kinds, and each one needs a different response.
Tool failures. A timeout or a 500 from a downstream system. Retry with backoff, then return the failure to the model as a structured error so it can choose an alternative instead of inventing a result.Validation failures. The model returned something, but it does not match the expected schema. Retry once with the validation error appended, the loop Pydantic AI formalizes, then hand off to a person.Reasoning failures. The agent loops, oscillates between two tools or declares success before doing the work. Only iteration caps, budget ceilings and an evaluation suite catch these, because no exception is raised.
The third kind is the one that reaches production, because it never looks like an error in a log. Treat a run that finished without an exception as unverified until an evaluation scores its output.
Vertical Requirements Change the Shortlist
Regulated industries narrow the field quickly. Banking and insurance work usually needs identity pass-through, full audit trails and a deployment target inside an existing compliance boundary. That profile favors Microsoft Agent Framework or a self-hosted LangGraph.
Marketing, support and internal research teams have more latitude, so the lighter frameworks win on speed to first value.
How Kanerika Builds Production Agent Systems
Kanerika builds agent systems inside a broader data and AI practice, so framework selection starts with the data and permissions an agent will touch. The framework is chosen second, after a data-access audit, and the engagement below shows why.
What This Looks Like on a Real Engagement
A global expert-network business could not reliably match niche survey requests to the right specialist. Its data sat in three disconnected systems, which produced mismatched experts, rework and a heavy support load.
Kanerika built a context-aware agent that used semantic search across skills, domains and expertise levels. It validated each shortlist against past participation and compliance data before anyone saw it.
The published results were an 80% decrease in mismatch tickets, a 40% increase in mapping accuracy and 22% bandwidth savings for the internal team. The deciding work was the governed retrieval layer, built before any orchestration code.
Case Study
80% Fewer Mismatch Tickets with a Context-Aware AI Agent
A global expert-network business matched survey requests to specialists across three disconnected systems, with a 40% increase in mapping accuracy and 22% bandwidth savings.
Read the Case Study → How Kanerika Sequences an Agent Engagement
Our agentic AI services follow four stages, and each one ends with an exit condition rather than a deadline.
Use-case and data-access audit. Map the decision the agent will make, then the systems it must touch and the permissions each one requires.Framework choice. Score candidates against the seven criteria above, then prototype the same workflow on two of them before committing.Governance build. Add scoped tool permissions, approval gates, an audit trail and tracing, while our AI governance practice owns the control set.Evaluation and staged rollout. Score every prompt or model change against a fixed evaluation set, then widen access in stages with human review.
The checkpointer is persistent from the first prototype, and approval gates sit directly before any write to a system of record. Turn limits and budget caps also go in before the first load test. Each default is cheap on day one but expensive to retrofit after launch.
An exit condition is a test the work must pass, such as every tool call carrying the end user’s identity. A stage that fails its test repeats instead of slipping into the next one.
Our Own Agents Follow the Same Pattern
Our own products are also built the same way. Karl analyzes enterprise data and answers business questions, with a reported 62% time saving on data analysis and a 78% increase in team efficiency. Klara checks documents while keeping a human reviewer in the loop.
This work runs inside a compliance boundary, so credentials shape the design. Kanerika is a Microsoft Solutions Partner for Data and AI with the Analytics specialization, a Databricks Consulting Partner and a Snowflake Select Tier partner.
We hold ISO 27001, ISO 27701 and ISO 9001 certifications, are SOC 2 Type II compliant and are CMMI Level 3 appraised. Everest Group named Kanerika a Major Contender in its 2026 Microsoft Azure Services PEAK Matrix.
Talk to Kanerika
Choosing a Framework for a Production Agent?
Bring one workflow. Kanerika will map it to the criteria in this guide and recommend a framework, an approval design and a rollout plan.
Talk to Kanerika → Wrapping Up
The seven worth evaluating in November 2026 are LangGraph, CrewAI, Microsoft Agent Framework, OpenAI Agents SDK, Google ADK, Pydantic AI and Strands Agents. AutoGen has left the list, while the protocol layer underneath the rest is shared.
Run your shortlist through the criteria with a two-day spike rather than a feature table. Durability, approval gates, tracing and evaluation will tell you more in that spike than a month of reading.
Then check the result against the permission model you actually have. Of the seven AI agent frameworks worth evaluating, the right one is the one that passes your spike while respecting that boundary.
Frequently Asked Questions
What are AI agent frameworks?
AI agent frameworks are software libraries that run the loop in which a language model plans, calls tools, reads results and picks the next step. They also manage state, memory, retries, approvals and tracing. LangGraph, CrewAI, Microsoft Agent Framework and Google ADK are common examples. They let engineers write business logic instead of rebuilding that plumbing.
What are the 5 types of agents in AI?
The classic textbook list has five types. Simple reflex agents act on the current input. Model-based reflex agents keep an internal picture of the world. Goal-based agents choose actions that reach a goal. Utility-based agents weigh options by expected value. Learning agents improve from feedback. Most LLM agents combine goal-based planning with tool use.
Is AutoGen still maintained?
No. Microsoft’s AutoGen README says the project is archived and no longer maintained. The last release of autogen-agentchat on PyPI was 0.7.5, published on September 30, 2025. Microsoft points new users to Microsoft Agent Framework and links a migration guide. Existing AutoGen code still runs, but it will not receive new features or fixes.
What is the difference between LangChain and LangGraph?
LangChain is the higher-level layer, with a create_agent entry point, model integrations and middleware. LangGraph is the lower-level runtime, with typed state, nodes, edges, checkpoints and interrupts. Both reached 1.0 on October 22, 2025, with a promise of no breaking changes until 2.0. Start with LangChain and move to LangGraph for explicit control.
Do AI agent frameworks support MCP and A2A?
All five frameworks in our production table support the Model Context Protocol for tool access. A2A support varies more. Microsoft Agent Framework and CrewAI support it natively, Google ADK offers an experimental module and LangGraph exposes it through Agent Server. The OpenAI Agents SDK has no built-in A2A. A2A became a Linux Foundation project on June 23, 2025.
Can AI agent frameworks work with multiple LLM providers?
Yes, though the depth of support varies. LangGraph, CrewAI, Pydantic AI and Microsoft Agent Framework work with many providers. Google ADK is optimized for Gemini but model-agnostic. Strands Agents defaults to Amazon Bedrock and supports Anthropic, OpenAI and Gemini. The OpenAI Agents SDK works best with OpenAI models. An LLM gateway makes switching cheaper.
How is the OpenAI Agents SDK different from LangGraph?
The OpenAI Agents SDK keeps a small surface of agents, handoffs, guardrails and sessions, and the model drives the control flow. LangGraph makes control flow explicit as a graph with typed state, checkpoints and interrupts. Pick the SDK for fast builds on OpenAI models. Pick LangGraph when approvals, branching or crash recovery must be auditable.
Is ChatGPT an AI agent?
ChatGPT is a chat assistant built on OpenAI’s language models. It acts as an agent when it is given tools, a goal and permission to take several steps without a new prompt at each one. Developers build the same behavior into their own products with frameworks such as the OpenAI Agents SDK, which adds handoffs, guardrails and sessions.
What are level 3 AI agents?
Level 3 usually describes agents that plan and complete multi-step tasks on their own, using tools and APIs without a person approving every step. They manage memory, retry failed steps and may coordinate with other agents. The label comes from informal autonomy scales rather than a formal standard, so check how each vendor defines it before comparing.
What is the best framework for agents?
No single framework wins every case. LangGraph suits stateful workflows with approvals. CrewAI suits role-based agent teams. Microsoft Agent Framework fits Azure estates, Strands Agents fits AWS and Google ADK fits Gemini-first or multi-language teams. Pydantic AI leads on typed output. Test your top two candidates with the same real workflow before you commit to one.
Which is better, CrewAI or AutoGen?
AutoGen is no longer a live option. Microsoft archived the repository, its last PyPI release was 0.7.5 on September 30, 2025, and new users are pointed to Microsoft Agent Framework. The useful comparison in 2026 is CrewAI against Microsoft Agent Framework. CrewAI is faster for role-based teams, and Agent Framework fits Azure identity and governance.
Is AutoGen owned by Microsoft?
Yes. AutoGen began as a Microsoft project and lives in Microsoft’s GitHub organization. The repository is now archived and no longer maintained. Microsoft built Microsoft Agent Framework as the successor to AutoGen and Semantic Kernel, using the same teams, and publishes a migration guide for existing AutoGen code. New projects should start on Agent Framework.
Can CrewAI execute code?
Yes, when you give an agent a code execution tool and the permissions to use it. CrewAI agents can call APIs, scripts and external systems through tools. Run code execution inside a sandbox, limit what the sandbox can reach and set max_iter on the agent. That keeps a stuck reasoning loop from running code over and over.
Is AutoGen free to use?
AutoGen’s code remains free under its open-source license, and you can still install it from PyPI. Because the repository is archived, it no longer receives fixes, including security fixes. That makes it a poor base for new production work. Microsoft Agent Framework is also free under the MIT license and is the maintained successor to AutoGen.
Is CrewAI open source?
Yes. CrewAI is open source under the MIT license, and its code is on GitHub. Version 1.15.35 shipped on PyPI on November 3, 2026, and the project published 69 releases between September 1 and November 3, 2026. CrewAI AMP, the managed platform that sits beside the library, is a separate commercial product.
