In this article
Before you start
Why interviewers ask this
Framework choice is a proxy for design judgment, so interviewers ask it to see whether you pick tools from requirements or from habit. Typical prompts are "which agent framework would you use and why", "would you use a framework at all", or "how do you make a multi-agent system reliable".
A weak answer lists features copied from a README. A strong answer starts from the control the task needs, names the cost of each style in model calls and failure modes, and knows which of the three is still maintained. The last point matters: the facts below are dated as of October 2026, and frameworks in this area change quickly, so a good candidate says when they last checked.
What each one is
- Agent framework
- An agent framework is a code library that runs the loop between a language model and its tools, and adds structure for state, memory, control flow and multi-agent coordination. It does not supply the model; you connect one.
- State graph
- A state graph is a program drawn as nodes and edges in which every node reads and updates one shared state object, and the edges decide which node runs next. Loops and branches are edges, so the control flow is visible.
- Checkpointer
- A checkpointer is a component that saves the state of a graph run after each step, so the run can be paused, resumed or replayed from a saved point.
- Crew
- A crew is a team of role-based agents that is given a list of tasks and works through them under a process, such as one task after another.
LangGraph in plain words
LangGraph is a low-level orchestration library built around a state graph. Its overview calls it "a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents", and says it does not abstract prompts or architecture. Orchestration here means deciding which step runs next and what state it sees. Durable execution means a long run can stop partway and continue later without starting over.
You add nodes and edges to a graph, compile it, and run it. The same page lists durable execution, human oversight and memory as core capabilities, and its persistence page says checkpointers save a thread's graph state as checkpoints (a thread is one conversation or run, identified by an ID), which supports resuming after an interruption and recovering from failures. It is built by LangChain Inc., but the overview says it can be used without LangChain.
CrewAI in plain words
CrewAI organizes work as crews of role-based agents, wrapped in flows (a flow is the application-level program that holds state and decides which crew or step runs next). Its introduction describes Flows as the backbone of an application, with state management and control flow such as conditionals, loops and branching, and Crews as the units of work inside a Flow. It advises that for any production-ready application you start with a Flow.
The Crews page says the default process is sequential, with tasks executed one after another, and the other option is hierarchical, in which a manager agent delegates tasks and validates outcomes, and which needs a manager model (the language model that powers the manager agent). Crews use CrewAI's unified Memory class, which as of October 2026 replaces the older separate memory types. Short-term, long-term and entity memory is the older split into stores for the current run, for lessons kept across runs, and for facts about named things.
It can also save progress. Its Checkpointing page says checkpoints let crews, flows and agents resume after failures, with a snapshot written by default once per finished task, and a run can be resumed or forked. Its Flows page describes a @persist decorator for automatic Flow state persistence. So resumable state is not unique to LangGraph.
AutoGen in plain words
AutoGen was a Microsoft framework for message-passing agents, and as of October 2026 it is archived. Message passing is agents cooperating by sending each other messages, and event-driven means a message arriving triggers the next step. The repository README says the project is archived and no longer maintained, with no bug fixes, security fixes, new features or support, and that Microsoft Agent Framework is its enterprise-ready successor. It lists a Core application programming interface (API) for message passing, an AgentChat API for rapid prototyping and an Extensions API.
The Microsoft Agent Framework overview says the framework combines AutoGen's agent abstractions with Semantic Kernel's enterprise features (Semantic Kernel is Microsoft's earlier software kit for building language-model apps) and adds graph-based workflows with explicit execution paths. For a new project, the real comparison is therefore LangGraph, CrewAI and Agent Framework.
Knowing it is half the job. Saying it is the other half.
Interview Clozo is an AI interview copilot for real interview rounds: it hears the question and puts a strong answer on your screen, and you say it in your own words. See the features or how it works.
Start Free Trial →Worked example
| Fact | LangGraph | CrewAI | AutoGen |
|---|---|---|---|
| Core idea | Low-level state graph of nodes and edges | Role-based crews inside flows | Message-passing agents |
| Control flow | You write the edges | Flow logic plus a crew process | Event-driven messages |
| Saved state | Checkpoints per thread (one run or conversation) | Checkpoints per task; Flow @persist | See successor framework |
| Status, October 2026 | Maintained, per its docs | Maintained, per its docs | Archived by Microsoft |
The table states what each project's own pages say, and nothing in it comes from a benchmark we ran. What follows is the cost arithmetic, and it is illustrative: it assumes each model call is good enough with probability 0.95 and takes 2 seconds, and it counts calls by style1. For the manager style it also assumes the manager catches a bad worker output with probability 0.8, after which the task is redone once.
Text description of the diagram
- LangGraph is a low-level state graph with checkpoints.
- CrewAI uses role-based crews inside flows, with checkpoints and Flow persistence.
- AutoGen is archived as of October 2026.
Take a job with five tasks.
| Style | Model calls | Time | Job comes out right |
|---|---|---|---|
| Sequential pipeline, no check | 5 | 10 s | 0.7738 |
| Manager checks each task, one redo | at least 15 | 30 s or more | 0.9414 |
| Free conversation, four turns per task | 20 | 40 s | 0.3585 |
In the sequential pipeline every call must be good, so the job succeeds with 0.95 to the power 5, which is 0.7738. With a manager, each task succeeds if the worker is good (0.95) or if it is bad, the manager catches it (0.8) and the redo is good: 0.95 + 0.05 x 0.8 x 0.95 = 0.988, and five tasks give 0.988 to the power 5, which is 0.94141. The check triples the calls and the time, and it buys reliability. A free conversation has no check, only more turns, so it just compounds the failure chance. The catch rate is an assumption, and real calls are correlated, so read the trend and not the figures.
Text description of the diagram
- A sequential pipeline makes 5 model calls for five tasks.
- A manager-checked crew makes at least 15 calls for five tasks.
- A free conversation at four turns per task makes 20 calls.
The takeaway for the design: a review step buys reliability but multiplies calls and latency, so spend it only where a failure is costly. That is the reason to prefer the explicit edges of a graph, or a simple sequential process, until a task proves it needs more.
Trade-offs and edge cases
No framework removes the need to design the agent; each one moves where the design effort goes. The main cases:
- Control versus speed to a prototype. LangGraph asks you to write nodes and edges, which is more code and more visibility. CrewAI's role and task vocabulary gets a demo running quickly but puts more behaviour inside the crew process. Pick by how much of the control flow you must be able to read and test.
- Durable runs. A run that can last minutes or hours needs saved state. LangGraph documents checkpoints per thread, and CrewAI documents checkpoints per finished task plus
@persistfor Flows (October 2026). LangGraph leaves the structure to you, while CrewAI supplies more of it; check each framework's docs for what is saved and how you resume, and see human in the loop for AI agents for approval points. - Maintenance risk. A framework can be archived, as AutoGen was. Prefer code whose model calls and tool schemas are thin wrappers you could move, and log every call so you can tell what happened; observability for language-model apps covers tracing.
- No framework at all. Anthropic's Building effective agents (December 2024) advises "finding the simplest solution possible" and sometimes "not building agentic systems at all", and says to "start by using large language model (LLM) APIs directly". The Agent Framework overview makes a similar point: if you can write a function to handle the task, do that. A loop with two tools and a step limit is a legitimate answer.
Text description of the diagram
- A simple loop with few tools needs no framework.
- Steps you write yourself point to a graph with saved state.
- A task that needs a role-based team points to a crew inside a flow.
- Existing AutoGen code needs a migration plan.
How to answer it in an interview
Which agent framework would you choose, and why?
I start from the control the task needs. If I want to write every step and edge myself and keep the state inspectable, I use LangGraph, because it is low-level and does not abstract prompts or architecture. If the task fits a team of role-based agents inside a defined flow, CrewAI fits, and it also has checkpoints and Flow persistence for resuming runs. I would not start a new project on AutoGen, because it is archived and its successor is Microsoft Agent Framework. And every review step adds model calls, so I add them only where a mistake is expensive, and I trace every run.
The spoken structure is: state the requirement, map it to one framework, name the maintenance fact, then give the cost trade-off.
Common mistakes
- "AutoGen is the standard for multi-agent systems" (wrong). Its repository is archived, and Microsoft names Agent Framework as the successor (right: cite the status and its date).
- "CrewAI is just LangChain" (wrong). Its introduction does not describe it that way, and it presents its own Flows and Crews (right: describe the concepts it documents).
- "More agents means a better answer" (wrong). Each agent adds calls and latency, and only a real check, such as the manager's catch step, raises reliability, as the table of calls above shows (right: add an agent only when one cannot do the job, and say what it checks).
- "A framework makes the system reliable" (wrong). It structures the loop, but you still need validation, limits and tracing (right: say what you add on top).
Follow-up questions
Is AutoGen still maintained?
No. As of October 2026 the repository README says the project is archived, with no bug fixes, security fixes, new features or support, and points to Microsoft Agent Framework as its successor. Existing users are directed to a migration guide.
Can CrewAI be used without LangChain?
Its documentation introduces Crews and Flows as its own concepts and does not describe a LangChain dependency on the pages read. Check the current install requirements before you commit, because dependencies change between releases.
Do you need a framework to build an agent?
No. An agent is a model, tools and a loop with limits, and a few dozen lines can run one. A framework earns its place when you need saved state, human approval, tracing or several cooperating agents, as in the AI agent architecture guide.
How do you add human approval to an agent graph?
Pause the run before the risky step, save the state, show a person the proposed action and resume only on approval. LangGraph's persistence page lists human-in-the-loop workflows among the uses of checkpointers.
Which framework is best for production?
None is best in general; choose by the control, state and support you need, and re-check maintenance status before you commit. In a system design round, system design habits apply: define the failure modes first, then pick tools that expose them.
- LangGraph is a low-level state graph where you write every edge; CrewAI is role-based crews inside flows, and both offer checkpoints for resuming runs.
- AutoGen is archived as of October 2026, and Microsoft Agent Framework is named as its successor.
- A manager check triples model calls but can raise job reliability; extra conversation turns without a check only add cost.
- If you can write the steps down, write them; a framework is optional for a simple loop.
- Say the date when you quote framework status, because it changes.
Sources
- LangGraph overview (LangChain documentation) — LangChain (page shows no date; read 2026-10-24), 24 Oct 2026
- LangGraph persistence (LangChain documentation) — LangChain (page shows no date; read 2026-10-24), 24 Oct 2026
- CrewAI documentation: Introduction — CrewAI (page shows no date; read 2026-10-24), 24 Oct 2026
- CrewAI documentation: Crews — CrewAI (page shows no date; read 2026-10-24), 24 Oct 2026
- CrewAI documentation: Checkpointing — CrewAI (page shows no date; read 2026-10-24), 24 Oct 2026
- CrewAI documentation: Flows — CrewAI (page shows no date; read 2026-10-24), 24 Oct 2026
- CrewAI documentation: Memory — CrewAI (page shows no date; read 2026-10-24), 24 Oct 2026
- Building effective agents (Anthropic) — Anthropic (published 2024-12-19; read 2026-10-24), 19 Dec 2024
- microsoft/autogen repository README — Microsoft (repository page; read 2026-10-24), 24 Oct 2026
- Microsoft Agent Framework overview — Microsoft Learn (page updated 2026-08-25; read 2026-10-24), 25 Aug 2026
