AI Agent Frameworks Compared: What Each One Is For

What a framework actually gives you

Every agent needs the same machinery: a loop that calls the model, runs the tools it asks for and feeds the results back; somewhere to keep state between turns; a way to hand work between agents; retries; and tracing, so you can see what happened when it goes wrong.

A framework packages that machinery. The trade-off is visibility. Anthropic’s engineering guidance on building agents makes the point directly: frameworks help with the low-level plumbing, but their abstractions can hide the actual prompts and responses, which is exactly what you need to see when debugging. Its advice is to start with the model API and adopt a framework only once you understand what it is doing for you.

Microsoft’s own framework documentation says something similar from the other direction: if a plain function can do the task, write the function instead of an agent.

Graph and state orchestration

LangGraph (LangChain, Inc., MIT licence, Python and JavaScript) models an agent system as a graph of nodes over shared state, and focuses on long-running, stateful work: durable execution, human-in-the-loop pauses and streaming. Its documentation is clear that it is low-level and does not abstract your prompts. LangChain itself, since its 1.0 release in October 2025, offers a quicker agent entry point built on the LangGraph runtime.

Microsoft Agent Framework (MIT, Python and .NET) is the successor to both AutoGen and Semantic Kernel, built by the same teams. It reached 1.0 in April 2026. AutoGen is now in maintenance mode — no new features — and its own README tells new users to start with Agent Framework. Semantic Kernel still receives critical fixes, but new features go to Agent Framework.

Google’s Agent Development Kit, ADK (Apache 2.0; Python, Java, Go, TypeScript and Kotlin), combines agents with graph-based workflows. It is optimised for Gemini but documented as model-agnostic and deployable anywhere, not only on Google Cloud.

Model vendors’ own agent SDKs

The OpenAI Agents SDK (MIT, Python and TypeScript) keeps its abstractions deliberately few: agents with instructions and tools, handoffs between agents, guardrails, sessions and tracing. It replaced the experimental Swarm project. OpenAI’s older Assistants API was shut down in August 2026 in favour of the Responses API. The SDK’s docs suggest calling the Responses API directly if you would rather own the loop yourself.

The Claude Agent SDK (Python and TypeScript), formerly the Claude Code SDK, exposes the same agent harness that runs Claude Code — file and shell tools, sub-agents, hooks, permissions, MCP and context management — as a library you embed in your own process. Its use is governed by Anthropic’s commercial terms, so do not assume it is open source in the way the MIT-licensed projects here are.

A vendor SDK is often the thinnest path to a working agent on that vendor’s models. Check how well it supports other models before you depend on that portability.

Teams of role-based agents

CrewAI (MIT, Python) organises work as crews of agents, each with a defined role, alongside Flows — event-driven workflows that control state and execution. Its documentation recommends starting production systems with a Flow and using crews inside it, which is the same “graph of loops” shape described in loops vs graphs. It is a standalone framework, not built on LangChain.

Frameworks built around your data

LlamaIndex (MIT, Python) is built for agents that work over documents and data: connectors, indexes, retrieval and event-driven workflows. Its separate TypeScript edition has been deprecated and archived, so treat it as a Python choice.

Haystack (deepset, Apache 2.0, Python) composes retrieval, routing, memory and generation as pipelines of components, with agents on top. Version 3.0 shipped in July 2026. Both are strong fits when retrieval quality, rather than agent autonomy, is the hard part.

Typed, TypeScript and minimal options

Pydantic AI (MIT, Python) brings typed tools, validated structured output and dependency injection to the agent loop, and switches between model providers with a one-line change. A natural fit for teams already using Pydantic for validation.

For TypeScript teams: the Vercel AI SDK (Apache 2.0) gives one API across model providers plus UI hooks for chat and streaming interfaces, and Mastra (Apache 2.0, with some enterprise-licensed components) adds agents, graph workflows, memory, retrieval and evaluation.

Hugging Face smolagents (Apache 2.0, Python) takes the opposite approach to the heavy frameworks: a deliberately small library whose main agent writes its actions as code, run in a sandbox. Useful for learning how an agent loop works, and for experiments you want to fully understand.

A different kind of tool: DSPy

DSPy (MIT, Python, from Stanford NLP) is not mainly an orchestration framework. Its idea is programming rather than prompting: you declare what each step takes in and returns, and its optimisers search for the prompts — or fine-tune the weights — that perform best against your evaluation data. It pairs naturally with a proper evaluation set, and is pointless without one.

Protocols are not frameworks

Two standards now sit underneath most of these frameworks. The Model Context Protocol (MCP), introduced by Anthropic in November 2024, standardises how a model reaches tools and data; in December 2025 it was donated to the Agentic AI Foundation, a fund under the Linux Foundation. Agent2Agent (A2A), announced by Google in April 2025 and donated to the Linux Foundation that June, standardises how agents from different systems talk to each other.

Building your tools as MCP servers is one of the better defences against framework lock-in: the tools survive a change of framework even when the orchestration code does not.

One layer down: machine learning frameworks

Agent frameworks orchestrate calls to models. Machine learning frameworks are what models are built and run with, and you only need them if you are training or hosting models yourself.

PyTorch, now governed by the PyTorch Foundation under the Linux Foundation, is widely used in both research and production. TensorFlow is Google’s end-to-end platform, and Keras 3 is a high-level API that runs on JAX, TensorFlow or PyTorch. JAX is a research-oriented library for high-performance array computation. scikit-learn is the long-standing library for classical machine learning — the kind of churn, forecasting and fraud models that never needed a neural network. Hugging Face Transformers provides ready-made model definitions for using and fine-tuning open models.

How to choose

Start with your language. Several of these are Python-only; the TypeScript and .NET options are fewer and the choice is correspondingly easier.

Then name the hard part. Long-running, stateful, resumable work points to a graph framework. Retrieval-heavy work points to LlamaIndex or Haystack. A system built on one model vendor points to that vendor’s SDK. A small, well-understood loop points to no framework at all.

Check the status, not just the features. A framework in maintenance mode — as AutoGen now is — is a migration you have scheduled in advance.

Keep the parts that matter portable: prompts in your own files, tools behind MCP, and an evaluation set that runs against any implementation. Those are what carry across when this landscape changes again — which, judging by the last twelve months, it will.