Updated October 2026: LangGraph 1.2 durable execution and interrupts explained, CrewAI’s new free-or-enterprise pricing, LangSmith Plus at $39 a seat, Microsoft Agent Framework after its April 2026 1.0 and the 2026 TypeScript alternatives.

LangGraph vs CrewAI vs AutoGen — The Short Answer

LangGraph is the low-level graph runtime for long-running, branching agents that must pause for a human and survive a crash; CrewAI is the role-based framework for a team of collaborating agents, with deterministic "flows" for fixed pipelines; AutoGen is in maintenance mode, and its successor Microsoft Agent Framework (1.0 since April 2026, Python and .NET) is the default for teams on Azure. As of October 2026, LangGraph is on version 1.2.17 (24 October 2026), CrewAI on 1.15.30 (23 October 2026), and all three frameworks are free open-source code; you pay for the managed platforms and the model calls.

Pick LangGraph when reliability and human approvals matter most, CrewAI when the job splits naturally into roles, and Microsoft Agent Framework when your engineers write .NET or your cloud is Azure. TypeScript teams usually land on Mastra or LangGraph.js instead.

Why This Matters

The previous two lessons gave you the agent loop and the three primitives that make it run. This lesson answers the next question every product team asks: which framework should our engineers build on? The choice is not academic — it decides how fast you ship, how much you pay per run, how easily you can audit what the agent did, and whether you are locked into one cloud. If you are scoping an agent feature for conferencing, surveillance, OTT, e-learning, or telemedicine, you do not need to write the code, but you do need to follow the argument your engineers will have, because picking the wrong framework for the job costs months. By the end you will be able to read any "we'll use LangGraph" or "let's go with CrewAI" proposal and check that the choice fits the task, the team, and the budget.

What An Agent Framework Actually Does

Start with the job, not the brand names. In the previous lesson we said an agent is a language model given three powers it lacks on its own: tools to act in the world, memory to carry knowledge across steps, and planning to turn a goal into ordered actions. Building those three by hand is real work. You have to manage the back-and-forth of every tool call, store and retrieve memory, run the planning loop, handle a step that fails halfway, save progress so a crashed server can resume, and watch what the agent did when it goes wrong. An agent framework is a pre-built library that does this plumbing for you, so your engineers describe what the agent should do and the framework handles how the loop runs.

Think of it like the difference between wiring a house yourself and buying a fuse box. The electricity — the language model — is the same either way. The framework is the standardized box that routes the power safely, trips when something shorts, and lets the next electrician understand the wiring without a tour. Without one, every team hand-rolls its own loop, its own retry logic, and its own memory store, and every one of those is a place to introduce a bug.

Three jobs separate a real framework from a weekend script. The first is orchestration — deciding which step runs next, whether steps run one at a time or several at once, and how one agent hands work to another. The second is state and memory — holding the task in progress and pulling in long-term facts when needed, the way we described agent memory in the last lesson. The third is durability and observability — saving progress so an interrupted job resumes, and recording every decision so a human can see why the agent did what it did. A framework that does all three well is the difference between a demo and a feature you can put in front of a paying customer.

A three-layer diagram: your application on top describes what the agent should do; the agent framework in the middle handles orchestration, state and memory, and durability and observability; the language model and external tools sit at the bottom, with request and result arrows running up and down between the top two layers and call and observation arrows between the bottom two Figure 1. An agent framework is the layer between your application and the model. It manages the three primitives from Lesson 7.2 — tool use, memory, planning — plus the durability and observability that production demands.

The 2026 Shift You Have To Know First

Before comparing the three, you need one piece of news, because it reshapes the whole field and most articles you will find are out of date. In late 2025 and early 2026 the agent-framework world went through a wave of consolidation. Picking a framework in 2026 is not the same decision it was in 2024, and a proposal that cites a 2024 blog post is working from a stale map.

Three things changed. First, in October 2025 LangChain and LangGraph both reached version 1.0 — their first stable major releases, with a promise of no breaking changes until 2.0. LangGraph has since moved to 1.2 (May 2026) and ships patch releases every week or two; there is still no 2.0 as of October 2026. Second, AutoGen was absorbed into Microsoft Agent Framework. Microsoft merged its two agent projects — AutoGen, which came out of Microsoft Research, and Semantic Kernel, its enterprise toolkit — into one framework that entered public preview in October 2025 and shipped version 1.0 on 3 April 2026. The AutoGen repository now says it is in maintenance mode and community-managed: it gets bug fixes and security patches but no new features. Third, CrewAI matured from a simple library into a platform, adding a second execution mode ("flows") and a commercial cloud product alongside its open-source core — and in 2026 it dropped its mid-priced self-serve plan, so the commercial choice is now the free tier or an enterprise contract.

The practical takeaway is blunt. If an engineer proposes "AutoGen," ask whether they mean the old AutoGen or its successor, Microsoft Agent Framework — because building new work on a framework in maintenance mode is a slow-motion mistake. And if a comparison they show you predates October 2025, treat its version-specific claims with suspicion. The names survived; the products underneath them moved.

A vertical timeline of the 2025-2026 consolidation: in 2024 to early 2025 CrewAI adds flows and the AMP Cloud platform over its open-source crews; in October 2025 LangChain and LangGraph reach 1.0 and create_agent starts running on the LangGraph runtime; in October 2025 Microsoft merges AutoGen and Semantic Kernel into Microsoft Agent Framework in public preview; in April 2026 Microsoft Agent Framework 1.0 ships for Python and .NET while the old projects move to maintenance mode Figure 2. The 2025–2026 consolidation. LangChain/LangGraph hit 1.0; AutoGen and Semantic Kernel merged into Microsoft Agent Framework (1.0 in April 2026); CrewAI grew a flows mode and a cloud platform. Any comparison older than this is working from a stale map.

What Is LangGraph — And How Is It Different From LangChain?

This is the single most common point of confusion in 2026, so handle it first. LangChain and LangGraph are two different tools from the same company, and you do not have to choose between them — they are designed to work together.

LangChain is the high-level, get-started-fast toolkit. It gives you a standard way to call any model provider — OpenAI, Anthropic, Google, and hundreds of others — through one common interface, so swapping the underlying model is a one-line change rather than a rewrite. Its main building block is a function called create_agent, which sets up the basic agent loop — send a request to the model, run any tool it asks for, feed the result back, repeat until done — in a few lines. If your agent fits that standard loop, LangChain is the quickest path to a working version.

LangGraph is the low-level, control-first runtime that sits underneath. Where LangChain hands you a pre-shaped loop, LangGraph hands you the parts to build any shape you want. Its core idea is in the name: you describe the agent's work as a graph — a map of steps (called nodes) connected by arrows (called edges) that show which step leads to which. Because a graph can loop back on itself and branch in different directions, LangGraph can express workflows that the simple straight-line loop cannot: an agent that retries a failed step, pauses to wait for a human's approval, runs two branches at once, or recovers from a crash exactly where it stopped.

Here is the relationship that resolves the confusion: LangChain's create_agent runs on the LangGraph engine under the hood. Since the October 2025 releases, the two are formally layered. You start with LangChain's high-level shortcut, and when your agent outgrows the standard loop, you drop down to LangGraph for fine control — without switching frameworks or rewriting from scratch. The common phrasing in 2026 is correct: you do not pick LangChain or LangGraph; you start high and drop low as the task demands.

Two LangGraph capabilities deserve a plain-language name because they are why production teams choose it. Durable state means the agent's progress is saved automatically, so if the server restarts in the middle of a long job, the agent resumes from its last completed step instead of starting over. Built-in persistence means you can pause an agent for hours or days — waiting for a human to approve a step, say — and pick the workflow back up later, without your engineers writing custom database code to remember the half-finished task. For a video product, that is the difference between an investigation agent that survives an overnight run and one that loses everything when a machine reboots.

LangGraph also ships a companion tool worth knowing by name: LangSmith Studio (originally LangGraph Studio), a visual workspace where engineers can watch an agent move through its graph step by step, inspect what it decided at each node, and debug a stuck run. It is part of LangSmith, LangChain's commercial platform for observability, evaluation and hosting — the hosting piece, once called LangGraph Platform, is sold as LangSmith Deployment in 2026. We cover that kind of monitoring in the agent evaluation and observability lesson.

The adoption story backs the choice. At the 1.0 launch in October 2025, LangChain reported 90 million monthly downloads across its frameworks and named production users including Uber, LinkedIn, Klarna, JP Morgan and Cisco. When a framework runs at companies that size, you are not the one discovering its sharp edges.

A stacked diagram: the LangChain layer with its create_agent shortcut sits on top of the LangGraph runtime, whose graph runs Start, Reason, Act and Check with an arrow looping back to Start for loops, branches and retries, and which carries durable state, built-in persistence and human-in-the-loop Figure 3. LangChain sits on top of LangGraph. Start with LangChain's create_agent for the standard loop; drop to LangGraph's graph, durable state, and persistence when the agent needs to loop, branch, pause, or recover. Same stack, no rewrite.

LangGraph Durable Execution, Interrupts And Human-In-The-Loop

Durable execution in LangGraph means the graph saves a checkpoint of its state as it runs, so a job that crashes, times out or waits for a person resumes from the last completed step instead of starting over; the step that was interrupted runs again. It needs two things: a checkpointer (the storage that keeps the snapshots) and a thread ID (the label that tells LangGraph which saved run to continue). The in-memory saver is for tests only, because it loses everything on restart; the LangGraph docs recommend PostgresSaver for production and SqliteSaver for development (checked October 2026).

You choose how eagerly LangGraph writes those checkpoints with the durability setting, which has three modes. "exit" saves only when the run ends — it completes, fails or stops at an interrupt — so it is fastest but cannot recover a run that dies halfway. "async" saves while the next step is already running, with a small risk of losing the latest checkpoint in a crash. "sync" saves before every next step starts — the slowest and the safest. For an overnight surveillance review or a multi-day approval chain, "sync" is the safer choice, whatever the library default.

Interrupts are how LangGraph does human-in-the-loop. A node calls interrupt() with a question or a draft for review; the graph pauses, its state is saved, and your application shows the payload to a person. When that person answers, the app resumes the same thread with Command(resume=...), and the answer becomes the return value of interrupt(). Two rules catch teams out. First, on resume the paused node runs again from its first line, so anything before the interrupt — sending an email, charging a card, writing to a database — must be safe to repeat. Second, the fixed breakpoints interrupt_before and interrupt_after are meant for debugging, not for real approval steps. Since version 1.2.12 (September 2026) an interrupt can also declare a response_schema, so a malformed human answer is rejected instead of silently accepted.

The other frameworks now offer the same building blocks under different names. Here is how each one stores progress and pauses for a person, as of October 2026:

Framework How progress is saved How a human approves a step Good fit
LangGraph 1.2 Checkpointer per thread (Postgres, SQLite); durability = exit / async / sync interrupt() + Command(resume=...) Long, branching jobs that must survive restarts
CrewAI 1.15 Flow state persisted with @persist, SQLite by default Human feedback steps defined in the flow Fixed pipelines that call a crew at one step
Microsoft Agent Framework 1.x Session-based state and workflow state management for long-running runs Human-in-the-loop workflows; tool-call approval in the Agent Harness .NET and Azure teams
Mastra 1.x (TypeScript) Workflow snapshots in storage; agent memory, including Observational Memory (Feb 2026) Workflow suspend() and resume() TypeScript and web-stack teams
OpenAI Agents SDK Sandbox snapshots and rehydration (April 2026, Python first) Guardrails and tool approval in the agent loop Teams committed to OpenAI models

For a product owner the question to ask is simple: "If the server reboots at step 7 of 12, or the reviewer answers tomorrow, what happens?" A good proposal names the checkpointer or store, the durability mode, and how a repeated step avoids doing its side effect twice.

What Is CrewAI?

CrewAI takes a different mental model, and it is the most intuitive of the three for a non-technical reader. Instead of asking you to draw a graph, it asks you to describe a team. You define each agent the way you would write a job description — a role ("video analyst"), a goal ("find every person who entered after hours"), and a back-story that shapes how it behaves — then group several of these agents into a crew that works toward a shared objective. The agents collaborate, hand findings to one another, and divide the work, much like a small department of specialists. CrewAI is an independent Python framework — early versions built on LangChain, but it was rebuilt to stand on its own — and it is known for getting a believable multi-agent setup running quickly.

CrewAI has two modes, and the distinction maps cleanly onto the planning patterns from the last lesson. Crews are the role-based, model-driven mode: you give the team a goal and the agents figure out how to collaborate, which is flexible but less predictable. Flows are the event-driven, deterministic mode: you lay out an explicit sequence — when this happens, do that — for work that must run the same way every time and be auditable afterward. The guidance that follows is simple: reach for a crew when the path to the answer is open-ended and you want agents to reason their way there; reach for a flow when the steps are fixed and you need a repeatable, inspectable pipeline. Many real systems combine both — a deterministic flow that calls a reasoning crew at the one step that actually needs judgment.

CrewAI also leans hardest of the three into being a commercial product, not just a library. Alongside the open-source framework (MIT licence) it offers a hosted agent management platform, sold as CrewAI AMP, with a visual editor, a copilot to help build agents, built-in monitoring, and guardrails. The company markets heavy enterprise traction, claiming use across a majority of the Fortune 500; treat that as a vendor figure rather than an audited statistic, but the direction is clear: CrewAI wants to be the framework a business team can adopt with managed support, not only the one engineers clone from a code repository.

What Is AutoGen — Now Microsoft Agent Framework?

AutoGen began as a research project from Microsoft for building agents that solve problems by talking to each other. Its signature pattern is a conversation between specialized agents — for example, one agent that writes a plan, a second that critiques it, and a third that executes it — passing messages back and forth until they converge on an answer. That conversational, multi-agent style made AutoGen a favorite for experimentation and for tasks where several perspectives improve the result.

Here is the part that reshapes the decision in 2026. Microsoft has folded AutoGen, together with its enterprise toolkit Semantic Kernel, into a single new framework: Microsoft Agent Framework. It entered public preview in October 2025 and reached version 1.0 — its production-ready, stable-API release — on 3 April 2026, available for both Python and the .NET platform (the toolset for building software in Microsoft's ecosystem) as open source under the MIT licence. Since then Microsoft has added the Agent Harness and Foundry Hosted Agents, both generally available by August 2026, and a Go version in public preview. The original AutoGen repository is in maintenance mode: it still receives bug fixes and security patches, but new features go into Microsoft Agent Framework instead, and Microsoft publishes migration guides and migration assistants to move existing projects over. A community fork, AG2, continues the older AutoGen 0.2 line separately from Microsoft.

What you get in the successor is the combination its makers intended: AutoGen's easy agent-and-conversation abstractions joined to Semantic Kernel's enterprise features — managed state, type safety (guard-rails that catch certain mistakes before the code runs), middleware, and telemetry — plus a graph-based workflow system for laying out explicit multi-agent execution paths. In other words, the new framework borrows the graph idea that makes LangGraph powerful and the multi-agent idea that made AutoGen interesting, and aims them at teams already invested in Microsoft's cloud, Azure.

The practical rule for a product team: choosing "AutoGen" today means choosing Microsoft Agent Framework, and it is the natural fit when your organization already runs on Azure and .NET, or when your engineers want Microsoft's enterprise support behind their agents. If you are not in the Microsoft ecosystem, the gravity that pulls teams toward Agent Framework is weaker, and LangGraph or CrewAI will usually feel more native.

Single Agent Or A Team Of Agents?

One decision cuts across all three frameworks and shapes which one fits, so it is worth pausing on: does your task need a single agent, or several agents working together — a multi-agent system? The distinction is exactly what it sounds like. A single agent is one reasoning loop with one set of tools and one memory. A multi-agent system is several such agents, each with a narrower job, that pass work between them — what the field calls a handoff — until the goal is met.

Multi-agent designs are fashionable, and the fashion has a cost. The appeal is real: splitting a hard job across specialists can improve quality, because an agent focused only on "writing the incident report" tends to do it better than one juggling detection, retrieval, and writing at once. AutoGen built its reputation on exactly this conversational, several-agents-talking pattern, and CrewAI's whole metaphor is a team. But every extra agent adds a seam — a place where one agent misunderstands what another handed it, where the cost of model calls multiplies, and where debugging gets harder because the failure could be in any member of the team or in the conversation between them. A two-agent system is more than twice as hard to reason about as a one-agent system.

The honest guidance, echoed by the framework makers themselves, is to start with a single agent and add more only when one agent measurably cannot do the job. Many tasks that look like they need a team — "transcribe, then summarize, then draft actions" — are really one agent calling three tools in sequence, not three agents negotiating. Reserve true multi-agent designs for work where the sub-jobs clearly benefit from separate reasoning and separate context: a meeting copilot where a live-transcription agent and a research agent really do run on different rhythms, or an investigation where one agent gathers evidence and a distinct, more cautious agent decides whether to escalate. All three frameworks can do single-agent and multi-agent work; the question is whether your task earns the extra agents, not whether the framework allows them.

The Head-To-Head Comparison

With each framework defined, here is how they line up on the dimensions that decide real projects. Read the table as a starting filter, not a verdict — the right choice depends on your task, which we get to next.

Dimension LangGraph (+ LangChain) CrewAI AutoGen → Microsoft Agent Framework
Mental model Graph of steps (nodes + edges) A team ("crew") of role-based agents Agents in conversation + graph workflows
Control level Lowest — build any shape Higher-level — describe roles Mid — abstractions + enterprise features
Fastest to a first agent LangChain create_agent (high) High — describe a crew Medium
Best at Reliable, long-running, custom flows Multi-agent collaboration; quick teams Azure/.NET shops; conversational multi-agent
Durability / resume Strong — durable state, persistence Flow state via @persist (SQLite by default); crews are not checkpointed Strong — managed state
Language Python, JavaScript Python Python, .NET (Go in preview)
Maturity (Oct 2026) 1.0 Oct 2025; now 1.2.17 1.15.30, platform-backed 1.0 Apr 2026; AutoGen in maintenance
Commercial cloud LangSmith (Deployment, Studio, tracing) CrewAI AMP Microsoft Foundry (formerly Azure AI Foundry)
Pick it when You need control and reliability You think in collaborating roles You live in the Microsoft cloud

One honest caveat belongs under this table. The three are converging. LangGraph added higher-level shortcuts through LangChain; CrewAI added deterministic flows; Microsoft Agent Framework added graph workflows. The gaps that made these frameworks feel completely different in 2024 are narrowing, which is good news for you: there are fewer wrong answers than there used to be, and the cost of switching later is lower because they increasingly speak the same concepts.

What It Costs

Frameworks themselves are open-source and free to run on your own machines — you pay for the model calls and the servers, which we break down in the cost-of-AI lesson. The money question is about the managed platforms the framework companies sell on top, which handle hosting, monitoring, and scaling so your team does not have to. Their pricing models differ in a way that matters for budgeting, and the published numbers below were checked on the vendors' pricing pages in October 2026 and change often — confirm current rates before you commit.

LangChain's commercial side is LangSmith: tracing and evaluation, LangSmith Studio, and LangSmith Deployment for hosting agents. As of October 2026 the Developer plan is free for one seat with 5,000 base traces a month; Plus costs $39 per seat per month with 10,000 base traces and one free small serverless deployment, and usage beyond that is billed pay-as-you-go; Enterprise is a custom contract with hybrid and self-hosted options. CrewAI prices by execution — one full run of a crew or flow. Its free Basic plan includes 50 executions a month as a hard cap, the $25 Professional plan it sold earlier is no longer listed, and anything above the free cap goes to an Enterprise contract sized to your workflow. Microsoft Agent Framework is free and open-source; the costs appear when you run it on Microsoft Foundry and Azure's managed agent services, billed like the rest of Azure.

The arithmetic is worth doing once, because the pricing units differ. Suppose a surveillance product runs a nightly investigator agent across 40 cameras, and each camera's nightly review counts as one execution. That is 40 executions a night, or 40 × 30 = 1,200 executions a month — 24 times CrewAI's free cap of 50, so on CrewAI's hosted platform you are already in an enterprise conversation, or you self-host the open-source framework and pay only for servers and model calls. The same workload traced in LangSmith, at one trace per review, is 1,200 traces a month — inside the 10,000 included with one Plus seat, so the platform line stays at $39 a month. Scale to 400 cameras and you get 12,000 executions or traces a month: past the Plus allowance, so the extra traces are billed at LangSmith's pay-as-you-go rate, and far past any free tier. The model calls under each run are a separate and usually larger line, which the cost-of-AI lesson works through. The lesson is not that one vendor is cheaper; it is that you must map your real usage — runs per day times days times sites — onto each vendor's pricing unit before you pick a plan, or the bill will not match the demo.

Beyond The Big Three

LangGraph, CrewAI, and AutoGen dominate the search traffic and the conversation, but they are not the only credible choices in 2026, and a thorough proposal will at least mention the alternatives. A few worth knowing by name: the OpenAI Agents SDK is a lean toolkit, the production successor to OpenAI's earlier "Swarm" experiment, built around agents, handoffs, guardrails and tools; its April 2026 update added native sandbox execution and snapshot-based recovery, so a long task can resume in a fresh container. Google's Agent Development Kit (ADK) is tuned for Gemini but can use other models, now ships for Python, TypeScript, Go, Java and Kotlin, and is the natural pick on Google Cloud; version 2.4.0 (July 2026) lets an agent call a whole workflow as a tool. Mastra is the standout for teams who build in TypeScript rather than Python — it reached version 1.0 on 20 January 2026, ships memory, workflow suspend-and-resume and human-in-the-loop controls, and slots neatly into modern web stacks. If your question is which CrewAI alternative works for a TypeScript team, the 2026 short list is Mastra, LangGraph.js and the TypeScript builds of the OpenAI Agents SDK and Google ADK. And low-code tools like n8n let non-engineers assemble agent workflows by connecting boxes on a canvas, trading fine control for speed and accessibility.

We give these newer entrants a full treatment — including Manus AI, the Claude Agent SDK, OpenAI Swarm, Google ADK, and n8n — in a dedicated 2026 framework deep-dive. For this lesson, the point is only that the big three are the safe default, not the entire field.

How To Actually Choose

Strip away the brand loyalty and the decision comes down to a handful of questions about your task, your team, and your constraints. Walk them in order and the field narrows fast.

Start with the shape of the work. If the agent's job is one open-ended goal handled by a single reasoning loop with a few tools, you do not need heavy machinery — LangChain's create_agent (running on LangGraph) gets you there fastest, and Mastra does the same for TypeScript teams. If the job naturally splits across several specialists who collaborate — an analyst, a writer, a reviewer — CrewAI's team metaphor will feel native. If the job is a long-running, branching, must-not-lose-progress workflow with human approvals in the middle, that is LangGraph's home ground.

Then layer on the team and the ecosystem. Your engineers' language is a hard constraint, not a preference: Python teams have every option, TypeScript teams lean Mastra or LangGraph's JavaScript build, and .NET teams gravitate to Microsoft Agent Framework. Your cloud matters too — Azure shops toward Microsoft Agent Framework, Google Cloud shops toward ADK — because the managed services, billing, and support are already in place there.

Finally, weigh control versus speed. More control means more code and a steeper learning curve but fewer surprises in production; more speed means a working agent this week but less room to customize when the task gets unusual. There is no universally "best" framework, despite how the question is often phrased — there is only the best fit for a specific task, team, and budget. The reassuring part, given how the three are converging, is that a reasonable choice today is rarely a trap tomorrow.

A top-down decision tree: the shape of the work splits into one open-ended loop, collaborating roles, and long and branching work, leading to LangChain with create_agent or Mastra in TypeScript, to CrewAI crews, and to LangGraph with durable state and persistence; below, a second filter by team language and cloud points .NET and Azure shops to Microsoft Agent Framework and Google Cloud shops to Google ADK Figure 4. A framework decision tree. Start with the shape of the work, then filter by team language and cloud. There is no single best framework — only the best fit for a task, a team, and a budget.

Matching Frameworks To Video Agent Jobs

This section grounds the abstract decision in the video work the rest of this curriculum builds toward. Three agent jobs recur across our domains, and each one points to a different framework strength.

A video investigator agent for surveillance — the subject of a later lesson — runs long, branches based on what a detector finds, and must survive an overnight job without losing its place. It pauses for a human to confirm a flagged clip before escalating. That profile — long-running, branching, human-in-the-loop, must-not-lose-progress — is the textbook case for LangGraph's durable state and persistence.

A meeting copilot agent for conferencing — covered in its own lesson and related to the LiveKit meeting assistant build — often splits naturally into roles: one agent transcribes and tracks the live discussion, another retrieves relevant context, a third drafts follow-up actions. When the work decomposes into collaborating specialists like that, CrewAI's crew metaphor is the most direct expression of the design.

An async video-review agent for an OTT or e-learning archive — the archive pattern lesson — usually runs the same fixed sequence over every file: ingest, transcribe, tag, index. The steps do not change from file to file, so the work wants a deterministic pipeline — CrewAI flows, a LangGraph graph with fixed edges, or a Microsoft Agent Framework workflow if the shop is on Azure. The reasoning model is called only where judgment is truly needed, keeping the cost down.

Three rows mapping video agent jobs to framework strengths: a surveillance video investigator that runs overnight, branches on what the detector finds and pauses for a human to confirm maps to LangGraph; a conferencing meeting copilot that splits into transcribe, retrieve and draft roles maps to CrewAI crews; an OTT and e-learning async video review that repeats the same fixed steps for every file maps to flows, a graph or a workflow Figure 5. The same decision, applied to three recurring video agent jobs. The job's shape — long and branching, role-divided, or a fixed pipeline — points to the framework strength that fits it.

A Common And Expensive Mistake

The most frequent framework error is not picking the "wrong" one — it is reaching for a framework at all when the task does not need an agent. As we said in the last lesson, if the steps never change, you do not need an open-ended planner; you need a plain script that calls the model at the one step that needs it. Standing up LangGraph, a vector database, and a multi-agent crew to summarize a single ten-minute clip is over-engineering that costs money to run and months to maintain. The discipline that keeps agent projects healthy is matching the tool to the job: use a workflow when the path is fixed, an agent when it truly is not, and the simplest framework that covers the real requirement. A second, related mistake is chasing the newest framework because it trended last month; the boring, 1.0-stable choice your engineers already know will usually ship sooner and break less.

Frequently Asked Questions

Is AutoGen still maintained in 2026?

Only for fixes. The AutoGen repository says it is in maintenance mode and community-managed, with no new features; Microsoft points new work to Microsoft Agent Framework, which reached 1.0 on 3 April 2026.

When did Microsoft merge AutoGen and Semantic Kernel?

Microsoft announced Microsoft Agent Framework, the merger of AutoGen and Semantic Kernel, as a public preview in October 2025 and shipped the production 1.0 release for Python and .NET on 3 April 2026.

What is durable execution in LangGraph?

It is LangGraph saving a checkpoint of the graph's state per thread, so an interrupted or crashed run resumes from the last saved step. You need a checkpointer such as PostgresSaver and a thread ID, and you choose the durability mode: exit, async or sync.

How do interrupts and human-in-the-loop work in LangGraph?

A node calls interrupt(), the graph pauses with its state saved, and the app resumes the same thread with Command(resume=...). The paused node re-runs from its start on resume, so code before the interrupt must be safe to repeat.

Is LangGraph free?

Yes. The LangGraph library is open source and free to run on your own servers. LangSmith, the hosted platform for tracing and deployment, has a free one-seat Developer plan and a Plus plan at $39 per seat per month (October 2026).

LangGraph or CrewAI — which should we choose?

Choose LangGraph when you need fine control, long-running jobs and human approvals that survive restarts; choose CrewAI when the work splits into collaborating roles and you want a working multi-agent prototype fast. Some teams prototype in CrewAI and move the production version to LangGraph.

How much does CrewAI cost?

The open-source framework is free. The hosted platform has a free Basic plan capped at 50 executions a month and custom-priced Enterprise plans; the $25 Professional plan is no longer listed (checked October 2026).

↓ Free download: Agent Framework Decision — Cheat SheetOne page: what LangGraph, CrewAI and Microsoft Agent Framework each are, what changed in the 2025-2026 consolidation, the head-to-head matrix, the pricing unit each vendor bills on, and the rules for choosing.

Where Fora Soft Fits In

We build video products across conferencing, streaming, OTT, surveillance, e-learning, telemedicine, and AR/VR, and when a feature needs an agent, the framework choice is one of the first design decisions we make with a client. Our approach is to start from the task — its shape, its reliability needs, and its budget — and let that pick the framework, rather than defaulting to whatever is fashionable. For a long-running surveillance investigation we lean toward control and durability; for a conferencing copilot that splits into clear roles we lean toward the team metaphor; for a fixed archive pipeline we lean toward a deterministic workflow that calls a model only where it earns its cost. The frameworks are converging, so we optimize for what the client's engineers can maintain after we hand the system over — because an agent feature nobody on the team understands is a liability, not an asset. When the agent has to watch the video itself — an investigator agent over camera feeds, say — our AI video agent development team builds the detection and tracking layer it calls. Agent features like these are what our AI integration services deliver inside existing video products, and the LLM workflows and retrieval behind them come from our generative AI development work.

AI for Video: From Real-Time Pipelines and Agents to Serving, Cost, Compliance, and Verticals - book cover

The book

AI for Video: A Complete Guide to Intelligence in Video Products: From Real-Time Pipelines and Agents to Serving, Cost, Compliance, and Verticals

We wrote a seven-volume handbook that takes the whole video stack apart, from the pixel to production, and this lesson continues in Volume 7. It runs the agent chapters in full — the loop primitives, the frameworks and the runtimes under them, memory and tools, the serving stack, and the cost-per-stream-hour arithmetic that turns a per-execution price into a monthly bill. Volume 6 sits next to it with the capabilities your agent will call: detection, tracking, speech, and retrieval over a video archive. Written by Nikolay Sapunov, CEO at Fora Soft.

Read it on Amazon →Kindle & paperback · Fora Soft Video Engineering Handbook

Scoping an agent feature and unsure which framework fits?

Tell us the shape of the work and we will tell you what we would build it on, what it costs to run at your volume, and what your own engineers will have to maintain after handover. 250+ video products shipped since 2005.

Book a 30-min call →WhatsApp →Email us →

See our case studies

References

  1. LangChain — "LangChain and LangGraph Agent Frameworks Reach v1.0 Milestones" (October 22, 2025) — https://www.langchain.com/blog/langchain-langgraph-1dot0 — tier 3 (framework author). Source of truth for the LangChain/LangGraph 1.0 releases, the create_agent abstraction running on the LangGraph runtime, durable state, persistence, middleware, and the named production users (Uber, LinkedIn, Klarna, JP Morgan, Cisco).
  2. LangChain — LangGraph product page and documentation — https://www.langchain.com/langgraph and https://docs.langchain.com — tier 3 (author/de-facto spec). Graph-based execution model (nodes/edges), StateGraph, LangGraph Studio, and the LangChain-on-LangGraph layering.
  3. LangChain — LangSmith pricing — https://www.langchain.com/pricing — tier 4 (vendor). Developer (free, one seat, 5k base traces), Plus ($39 per seat per month, 10k base traces, one free serverless deployment), Enterprise. Checked October 2026.
  4. CrewAI — official site and documentation (Crews vs Flows, CrewAI AMP) — https://docs.crewai.com and https://crewai.com — tier 3 (author). The crew/role model, the flows event-driven mode, the hosted platform, and the independent-of-LangChain status.
  5. CrewAI — pricing page — https://www.crewai.com/pricing — tier 4 (vendor). Free Basic plan (50 executions a month, hard cap) and custom Enterprise; the Professional plan is no longer listed. Checked October 2026. The Fortune 500 figure is a vendor marketing claim, flagged as such in the body.
  6. Microsoft — "Microsoft Agent Framework Overview" (Microsoft Learn) — https://learn.microsoft.com/en-us/agent-framework/overview/ — tier 3 (author). The convergence of AutoGen and Semantic Kernel, Python + .NET support, MIT license, managed state, workflows, and the maintenance-mode status of the predecessors.
  7. Yao et al. — "ReAct: Synergizing Reasoning and Acting in Language Models," arXiv:2210.03629 (Princeton University & Google, 2022) — https://arxiv.org/abs/2210.03629 — tier 5 (primary). The reason–act loop these frameworks implement; grounds the "what a framework orchestrates" section.
  8. Model Context Protocol — official specification and documentation — https://modelcontextprotocol.io — tier 3 (de-facto spec). The open tool-connection standard all three frameworks now support (e.g., LangGraph's MCP integration), referenced as the standard way tools are wired in.
  9. Firecrawl — "The best open source frameworks for building AI agents in 2026" — https://www.firecrawl.dev/blog/best-open-source-agent-frameworks — tier 6 (orientation only). Used to cross-check 2026 adoption figures (download counts, GitHub stars) for OpenAI Agents SDK, Google ADK, and Mastra; each figure treated as approximate and labelled as early-2026.
  10. LangChain — "Durable execution", LangGraph documentation — https://docs.langchain.com/oss/python/langgraph/durable-execution — tier 3 (author). Checkpointers, thread IDs and the exit / async / sync durability modes.
  11. LangChain — "Interrupts", LangGraph documentation — https://docs.langchain.com/oss/python/langgraph/interrupts — tier 3 (author). interrupt(), Command(resume=...), node re-execution on resume, static breakpoints, response_schema (langgraph 1.2.12+).
  12. PyPI — langgraph release history — https://pypi.org/project/langgraph/ — tier 3 (package registry). 1.2.0 (12 May 2026) to 1.2.17 (24 October 2026).
  13. CrewAI — changelog — https://docs.crewai.com/en/changelog — tier 3 (author). Version 1.15.30 (23 October 2026), flow persistence and human-feedback changes in 2026.
  14. Microsoft — "Microsoft Agent Framework Version 1.0" (April 3, 2026) — https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/ — tier 3 (author). 1.0 for .NET and Python, migration assistants for AutoGen and Semantic Kernel.
  15. Microsoft — AutoGen repository README — https://github.com/microsoft/autogen — tier 3 (author). Maintenance mode, community-managed, Agent Framework as successor.
  16. InfoQ — "Microsoft Agent Framework: Agent Harness and Foundry Hosted Agents GA" (August 2026) — https://www.infoq.com/news/2026/08/agent-framework-harness-ga/ — tier 4 (trade press).
  17. OpenAI — Agents SDK repository and documentation, including the April 15, 2026 "next evolution of the Agents SDK" release — https://github.com/openai/openai-agents-python — tier 3 (author). Native sandbox execution, snapshots and rehydration, Python first.
  18. Mastra — blog and announcements — https://mastra.ai/blog — tier 3 (author). Mastra 1.0 (20 January 2026), Observational Memory (9 February 2026).