What are the five types of AI agents?

The classic textbook taxonomy lists simple reflex agents, model-based reflex agents, goal-based agents, utility-based agents and learning agents. It describes how an agent decides, not which framework runs it. Most LLM agents built today behave like goal-based agents with tools, and a learning loop is usually added through evaluation and prompt updates rather than live retraining.

Is LangGraph replacing LangChain?

No. LangGraph is the runtime underneath, and LangChain is the higher-level harness built on it. LangChain's `create_agent` gives you a ready agent loop with middleware, and it inherits LangGraph's persistence and human-in-the-loop support. You pick LangChain for speed and drop to LangGraph when you need to design the graph yourself.

Do you need a framework at all to ship an agent?

Not always. A single model calling three or four tools in a loop is a short script with the provider's SDK. A framework earns its place once you need saved state, resumable approvals, parallel branches or standard tracing, because rebuilding those yourself costs more than learning the framework.

What should a single-agent system run on?

A lightweight harness is usually enough. LangChain's `create_agent`, or the provider SDK with your own retry and logging code, handles one agent with tools well. Move to a graph runtime such as LangGraph or Microsoft Agent Framework when that single agent starts waiting on people, branching, or running for hours.

How hard is it to switch agent frameworks after launch?

It depends on how much logic lives inside the framework. If tools are plain functions or MCP servers, prompts sit in your own files and business state stays in your database, a switch mostly rewrites orchestration code. If agents talk freely inside one framework's chat abstraction, expect to redesign the flow and re-run your full evaluation set.

AI Agent Frameworks for Production: LangGraph, AutoGen, CrewAI Compared (2026)

Quick Answer: The main AI agent frameworks in production are LangGraph for durable, stateful graphs and CrewAI for role-based agent crews. AutoGen is now in maintenance mode, and Microsoft points new projects to Microsoft Agent Framework 1.0. MetaGPT is built around a software-company workflow, so it fits code-generation experiments better than business processes.

Picking between AI agent frameworks is mostly a question about failure. A demo agent runs once and exits. A production agent has to survive a crashed pod, wait two days for a manager's approval, and explain afterwards why it called a tool.

So the useful comparison isn't features on a landing page. It's four things: how state is saved, how a human steps in, how you trace a run, and whether the project is still actively developed.

Which frameworks are used to build production AI agent workflows?

LangGraph, CrewAI and Microsoft Agent Framework are the frameworks teams build new production agents on in 2026. LangChain's create_agent covers simpler single-agent loops and runs on LangGraph underneath. AutoGen still runs in many systems, but it's frozen, and MetaGPT is niche.

Here's how they line up on the four questions that matter once an agent is live.

Framework	Saved state and resume	Human-in-the-loop	Tracing	Licence	Project status
LangGraph	Yes (checkpointers, Postgres for production)	Yes (interrupts)	Yes (LangSmith, a separate platform)	MIT	Active
LangChain `create_agent`	Yes (inherits LangGraph)	Yes (middleware)	Yes (LangSmith)	MIT	Active
CrewAI	Yes (`@persist` on Flows)	Yes (`@human_feedback`, webhooks)	Yes (third-party integrations)	MIT	Active
Microsoft Agent Framework	Yes (workflow checkpointing)	Yes	Yes (OpenTelemetry)	MIT	Active, 1.0 release
AutoGen	Yes (`save_state` / `load_state`)	Yes (blocking `UserProxyAgent`)	Yes (OpenTelemetry)	MIT (code)	Maintenance mode
MetaGPT	Yes (breakpoint recovery)	Yes (`is_human` roles)	Not documented	MIT	Research-led, last commit January 2026

Capabilities as documented by each vendor on 21 September 2026; links in the text.

LangGraph's own docs describe it as the orchestration runtime for durable execution, streaming, human-in-the-loop and persistence. That list is close to a definition of what production needs, which is why it keeps coming up first.

LangChain vs LangGraph: which one runs production agents?

LangGraph runs production agents, and LangChain sits on top of it. The langchain vs langgraph question is really about how much control you want: LangChain gives you a ready agent harness, while LangGraph lets you draw the graph yourself.

LangChain's docs now say plainly that its agents are built on top of LangGraph, and that this is how they get durable execution and human-in-the-loop support. In practice:

Start with LangChain create_agent when the job is one model calling a handful of tools in a loop, and middleware (guardrails, retries, approvals) covers your policy needs.
Drop to LangGraph when the process has fixed steps mixed with model-driven ones, parallel branches, or waits that last hours. LangGraph can mix deterministic nodes and agent nodes in one graph.
Use a persistent checkpointer from day one. The docs warn that the in-memory saver loses every checkpoint when the process restarts.

If your team already knows the older chains API, our langchain cheat sheet is a quick refresher, and the ReAct agent walkthrough shows the loop pattern create_agent now packages.

How do AutoGen, CrewAI and MetaGPT compare for multi-agent work?

CrewAI is the active choice for role-based multi-agent work, AutoGen is frozen, and MetaGPT is specialised for generating software. They share the "team of agents" idea but differ on who controls the flow.

AutoGen and its successor

The AutoGen repository now carries a notice that AutoGen is in maintenance mode and will not receive new features, and it sends new users to Microsoft Agent Framework. AutoGen's human-in-the-loop design is a known limit for production: its docs say a UserProxyAgent blocks the team until the user answers, and that state can't be saved or resumed.

Microsoft Agent Framework replaces both AutoGen and Semantic Kernel. Its graph-based workflows include checkpointing, streaming, human-in-the-loop and time-travel, with OpenTelemetry built in, for Python and .NET.

CrewAI

CrewAI splits work into Crews (agents with roles, goals and tools) and Flows (event-driven, stateful control). Its docs say that for any production-ready application, you should start with a Flow and call a Crew inside a step. That's the core of crewai vs langgraph: CrewAI gives you role-playing agents with less wiring, while LangGraph gives you explicit control over every edge.

For a hands-on start, see our crewai tutorial.

MetaGPT

MetaGPT assigns agents software-company roles (product manager, architect, engineer) and runs them through standard operating procedures. Its README describes a software company as a multi-agent system, and it currently supports Python 3.9 up to, but not including, 3.12. It's strong for code-generation research and weaker as a base for invoice or ticket workflows.

What does 'production-ready' mean for an agent framework?

A production-ready agent framework saves state outside the process, lets a human pause and edit a run without blocking it, emits traces you can ship to your own backend, and is still maintained. Anything missing one of these needs extra engineering around it.

There's no single best ai agent framework, but every serious candidate should pass this checklist:

Durable state. Checkpoints go to a real database, so a restart resumes the run instead of repeating tool calls that already charged a card or sent an email.
Non-blocking human review. The run pauses, persists, and resumes when an approver acts, even days later.
Tracing in your stack. OpenTelemetry output or a clean exporter, so traces land where your other services already report.
Deterministic steps next to agentic ones. Most business processes are largely fixed logic, so the framework shouldn't force a model call into every step.
Active maintenance and a clear licence. A permissive licence (all six above are MIT) and a project that ships security fixes.

How do AI development firms choose a framework for a client build?

AI development firms usually choose by the client's platform first and the process shape second. The client's cloud, language and observability stack narrow the field before any feature comparison starts. Before choosing any framework, decide whether you need code at all; custom AI agents vs no-code builders covers that trade-off.

Azure and .NET shops lean toward Microsoft Agent Framework, because it ships .NET support and the Foundry hosting path.
Python teams with long, branching processes lean toward LangGraph for explicit graphs and checkpoints.
Content, research and back-office tasks split into roles often fit CrewAI Flows with a Crew for the open-ended step.

For existing AutoGen systems, the langgraph vs autogen decision has changed shape. Since AutoGen won't get new features, the real choice is between migrating to Microsoft Agent Framework, using Microsoft's migration guide, or moving to LangGraph.

How do you keep an agent framework from locking you in?

You avoid lock-in by keeping business logic, tools, prompts and evaluation data outside the framework, and treating the framework as the thin layer that sequences them. Then a migration rewrites the wiring, not the product.

Tools as plain functions or MCP servers. LangChain and Microsoft Agent Framework both document MCP tool support, and AutoGen ships an MCP workbench.
Model access behind one internal client. Swapping providers shouldn't touch agent code.
Your own state store. Keep the business record (orders, tickets, approvals) in your database; the framework checkpoints only run state.
A framework-neutral eval set. The same test cases should run against the old and new implementation.

Choosing the best ai agent framework matters less than keeping this boundary clean.

What mistakes should you avoid when choosing an AI agent framework?

The costliest mistakes are choosing on demo speed, starting on a frozen project, and adding durability later. Each one works in a pilot and fails under real traffic.

Starting a new build on AutoGen after its maintenance-mode notice.
Shipping the in-memory checkpointer because the tutorial used it.
Letting agents talk freely when the process has fixed steps; free-form multi-agent chat is hard to test and audit.
Blocking human approvals that hold a worker thread instead of persisting and resuming.
Skipping traces until the first incident, when you most need them.
Pinning to an old Python because one framework's range requires it.

How Origins AI picks a framework for a client build

Origins AI (originshq.com) is an AI-augmented engineering company that builds custom AI workflows and agents for product teams. Its AI workflow development services page names LangChain as a framework it uses, and its technology grid shows AutoGen and MetaGPT.

On a client build, the team maps the process first, marking fixed steps, model-driven steps and approval points, then picks the framework that matches the client's cloud and language. The same page describes integration with existing cloud and legacy systems through APIs, middleware and custom connectors, and lists AI agent deployment among its services.

Origins AI reports offering dedicated AI teams, project-based contracts, time-and-materials and build-operate-transfer engagements. It describes fixed-cost, milestone-based and subscription pricing models and doesn't publish a rate card.

Talk to an engineer

Choosing a framework for a real process? Book a call and walk through your workflow with an engineer.

Written by Apoorva Kumar, Co-Founder & CEO, Origins AI.