Best AI Agent Orchestration Frameworks (2026): 11 Compared

The 11 Best AI Agent Orchestration Frameworks in 2026

Compiled by Rob Jiang, Chief AI Engineer. Every licence was read from the project's own LICENSE file, every price from the vendor's live pricing page, and every version number from PyPI, npm or the repository changelog, on 21 September 2026. Disclosure: this guide is published by Aissist.io, which sells an agentic AI layer for customer service and sales. Aissist.io is not one of the eleven frameworks reviewed and does not compete with any of them. No vendor reviewed this page before publication.

TL;DR: Every AI agent orchestration framework composes agents well; only three of the eleven we scored — Google ADK, Microsoft Agent Framework and Pydantic AI — give you per-step token accounting from the open-source package with no vendor platform in the path.

Best for, at a glance

1. Best for resumable agents with no vendor runtime: Google ADK
2. Best for agents that must survive anything: Temporal
3. Best for .NET shops and Azure-hosted agents: Microsoft Agent Framework
4. Best for graph-shaped agents with fine state control: LangGraph
5. Best for type-safe Python that keeps its options open: Pydantic AI
6. Best for TypeScript teams: Mastra
7. Best for getting a multi-agent prototype running fast: CrewAI
8. Best for low-latency durable agents on one binary: Restate
9. Best for per-step cost and latency accounting: Inngest
10. Best for event-driven, document-heavy pipelines: LlamaIndex Workflows
11. Best for the shortest path from prompt to working agent: OpenAI Agents SDK

That gap is the whole buying decision, and no page currently ranking for this keyword measures it. Every framework publishes the same feature list: agents, tools, handoffs, memory, a graph or a crew. What separates them in production is narrower and much less fun to market — what happens when a worker dies halfway through a six-step run, whether the model calls you already paid for get re-billed on recovery, and whether a run can wait three days for a human without holding a process open.

Stanford HAI's 2026 AI Index puts the stakes plainly: AI agents "are improving, but still fail roughly one in three attempts on structured benchmarks," with leading models scoring between 62.9% and 70.2% pass@1 on τ-bench. At that failure rate, recovery is not an edge case. It is the main loop.

How we compared these AI agent orchestration frameworks

We scored eleven frameworks out of 30, five points each across six criteria, and ranked them by total. The criteria are deliberately about survival rather than ergonomics, because ergonomics is what every other comparison page already covers.

What disqualifies a tool: anything below 18/30, anything not generally available, and anything without public technical documentation. All eleven cleared the bar; the spread runs 20 to 28. Ties are broken by the replay and interrupt scores combined, then by production evidence — which is how three frameworks on 21 points end up in the order they do.

Two exclusions. Conversational-AI products that market themselves as frameworks are vendor platforms with an SDK attached, and including them makes the licence column meaningless. Microsoft AutoGen gets its own dated section rather than a rank, because scoring a frozen project against live ones would flatter it.

The bias disclosure, up front: this is Aissist.io's blog, and Aissist sells an AI operational layer for customer service and sales. We are not in this list — we are not an orchestration framework, and ranking ourselves in a developer roundup would be the kind of move that makes a page unreadable. What we are is a heavy user of this layer, which is the only reason we have an opinion worth publishing.

Sources: vendor documentation, LICENSE files read from the repositories rather than marketing pages, PyPI and npm release metadata, live pricing pages and published case studies, all read 21 September 2026. Star counts are the rounded figures GitHub displays. The full per-criterion scorecard is the graphic below.

The 11 AI agent orchestration frameworks at a glance

The replay column is the one to read twice. Three of the eleven — Temporal, Restate and Microsoft Agent Framework — state in their own documentation that completed model calls are not re-executed on recovery. That is a billing fact as much as a reliability one.

Who each one is built for

Read the stars column as an ecosystem signal, not a reliability one. CrewAI's 58.8k and LangGraph's 38.1k dwarf Google ADK's 21.1k, and ADK tops our scoring — while shipping in five languages across repositories that are counted separately.

1. Google ADK — best for resumable agents with no vendor runtime

Google's Agent Development Kit (ADK) is an open-source, code-first agent framework for building, debugging and deploying multi-agent systems, run locally or on Cloud Run, GKE, Agent Runtime or any container. Google's ADK documentation calls it "the open-source agent development framework that lets you build, debug, and deploy reliable AI agents at enterprise scale."

Class: orchestration framework with a durable runtime built in · Runs: in your process or on Google's managed Agent Runtime, with no capability cliff between them · Languages: Python, TypeScript, Go, Java, Kotlin.

Durable execution. ADK separates conversation state from execution state and persists both. DatabaseSessionService backs sessions with PostgreSQL, MySQL or SQLite, and the session documentation states data "survives application restarts."

Replay on failure. First-class and unusually explicit. The resume documentation says the feature "allows an agent workflow to pick up where it left off, avoiding the need to restart the entire workflow," enabled with ResumabilityConfig(is_resumable=True). Completed tasks persist as Events, and multi-agent workflows preserve the current sub-agent, loop counts and per-agent completion.

Human-in-the-loop. require_confirmation on a FunctionTool pauses execution and surfaces a payload to a human via web UI or REST API; LongRunningFunctionTool ends the run while outside work proceeds.

Per-step cost and latency. In the open-source package, no platform required. ADK emits OpenTelemetry GenAI spans carrying gen_ai.usage.input_tokens and gen_ai.usage.output_tokens per agent and per tool, exportable to Cloud Trace, Jaeger, Grafana Tempo or Datadog.

Licence · adoption · cost. Apache-2.0, read from the repository LICENSE. 21.1k stars on adk-python, 13.8 million PyPI downloads in the last month. Agent Runtime's Agent Compute is free to 50 hours per month per account, then $0.085 USD per hour, per Google Cloud's pricing page.

"By rebuilding Comcast's Xfinity Assistant with Agent Development Kit (ADK), we've moved beyond simple scripted automation to conversational generative intelligence that delivers personalized troubleshooting and self-service support to our customers. Agent Runtime has been a massive accelerator, allowing us to deploy a sophisticated multi-agent architecture." — Rick Rioboli, Chief Technical Officer, Connectivity & Platforms, Comcast

Pros: Apache-2.0 with resumability in the package, not the platform; per-step token accounting with no vendor in the path; five languages. Cons: the resume docs warn that "tools may execute more than once during resume," so every tool must be idempotent; Custom Agents need code changes to resume, and UI/CLI resume is unsupported; Google renamed Vertex AI to Gemini Enterprise Agent Platform in April 2026 while keeping ReasoningEngine in the API, so expect stale tutorials industry-wide. Our take: ADK is the only entry giving you durable execution, resume and per-step cost accounting under one permissive licence with no hosted dependency. Do not pick it if your tools have side effects you cannot make idempotent — the double-execution caveat is the price of the resume mechanism. See how the layers stack in practice in our write-up of multi-agent architecture.

2. Temporal — best for agents that must survive anything

Temporal is an open-source durable execution platform that runs application code as workflows which resume automatically after crashes, timeouts and multi-day waits, self-hosted or as Temporal Cloud. Its AI documentation states that "Temporal gives AI applications and agents Durable Execution: a Workflow resumes automatically after a crash, a network timeout, or a multi-day wait for a human to approve a step."

Class: durable runtime, not an agent framework — it runs underneath one · Runs: your workers, your infrastructure; the Temporal Service self-hosted or managed · Languages: Go, Java, Python, TypeScript, .NET, PHP, Ruby.

Durable execution. Event-sourced. Temporal's architecture documentation says that if the process running a workflow crashes, "the Temporal Service hands the work to another process, which rebuilds the state of the execution and resumes at the point where it stopped, with local variables and progress intact."

Replay on failure. The strongest statement in this field, and the one that matters for cost: Temporal's OpenAI Agents SDK integration documents that "model calls are executed as Activities, so they retry durably and are not repeated during Workflow replay."

Human-in-the-loop. Signals and Updates, with genuinely idle waiting. Temporal's approvals guide notes that on workflow.wait_condition() "the Worker returns the current task to the Temporal Server and becomes idle — consuming no compute," and that this "works identically whether the wait is five seconds or five months."

Per-step cost and latency. Execution visibility is excellent — every input, activity result, timer and message in order, with OpenTelemetry interceptors across workers. Token cost is not tracked natively and needs an integration such as Langfuse or Braintrust.

Licence · adoption · cost. MIT. 21.7k stars. Temporal's September 2026 funding announcement reports 4,300+ paying customers, 43 million+ open-source installs in August and 1.9 trillion+ Cloud actions processed that month, naming OpenAI, Netflix, Snap and Replit as users. Temporal Cloud bills $50 USD per million Actions ($0.00005 each), with $150 in credits for 90 days.

"There are some things you just want to take as a given when you're building a product, and this is one of them. With Temporal, we don't have to worry about orchestration infrastructure. We can build on the same primitives we've trusted for years and focus on moving the product forward." — Lizzie Siegrist, Product Manager, Retool

Pros: the only entry where a mid-run crash is genuinely a non-event; documented first-party integrations with ten agent frameworks including LangGraph, OpenAI Agents SDK, Pydantic AI, Google ADK and Mastra; MIT with a real self-hosting story. Cons: determinism is a standing tax — Temporal's workflow definition docs require that workflow code "makes the same Workflow API calls in the same sequence, given the same input," so editing agent logic in a running workflow needs a versioning strategy; Event History is capped at 51,200 events or 50 MB; durability "does not extend to MCP servers, which run independently of the Workflow." Our take: Temporal is right when the cost of losing a run exceeds the cost of learning determinism, which for long-running or money-moving agents is most of the time. Do not pick it if your agents are short, cheap and stateless — you pay the adoption tax and bank none of the benefit.

3. Microsoft Agent Framework — best for .NET shops and Azure-hosted agents

Microsoft Agent Framework is an open, multi-language framework for building production-grade AI agents and multi-agent workflows in .NET, Python and Go, deployable locally, to Azure Functions, or to Foundry-hosted infrastructure. It is the merged successor to both AutoGen and Semantic Kernel.

Class: orchestration framework with a durable-workflow engine and an optional managed runtime · Runs: in your process, on Azure Functions, or Foundry-hosted · Languages: .NET, Python, Go.

Durable execution. Two mechanisms. Checkpointing captures, per Microsoft's checkpoints documentation, "the current state of all executors; All pending messages… Pending requests and responses; Shared states" at the end of each superstep, with in-memory, file and Cosmos DB backends. The Durable Task extension separately makes agent sessions "survive process crashes, restarts, and scaling events without losing context," and does not require Azure — a locally hosted Durable Task Scheduler works.

Replay on failure. workflow.run(checkpoint_id=…) in Python, run.RestoreCheckpointAsync() in .NET. On the Durable Task path, Microsoft states that "Completed agent calls aren't re-executed on recovery."

Human-in-the-loop. RequestPort, RequestInfoEvent, ctx.request_info() and @response_handler. Pending requests are saved into the checkpoint and re-emitted on restore — the interrupt survives the crash, which is the part most frameworks skip.

Per-step cost and latency. In the OSS package. The framework emits the gen_ai.client.token.usage histogram per the OpenTelemetry GenAI semantic conventions, exportable to Azure Monitor, Aspire, Jaeger or any OTLP endpoint. Azure AI Foundry is optional.

Licence · adoption · cost. MIT, read from the repository LICENSE. 12.6k stars; the Microsoft.Agents.AI NuGet package shows 8.2M total downloads. The framework is free; Azure's Foundry Agent Service pricing page states "There is no additional charge for creating or running Foundry-native agents using prompts and workflows," with model tokens, tool connections and hosted-agent compute billed separately — the page renders no dollar figures server-side, so we publish none.

"This is the production-ready release: stable APIs, and a commitment to long-term support." — Shawn Henry, Principal Group Product Manager, Microsoft, on Agent Framework 1.0

Pros: the only framework here shipping first-class .NET alongside Python; interrupts that survive checkpointing; OTel token accounting with no platform requirement. Cons: the production, cross-process checkpoint backend is Azure Cosmos DB, which quietly points durability at one cloud; it inherits a migration burden from two predecessor projects; version currency is confusing, since the GitHub releases page lagged the CHANGELOG and PyPI by two releases when we checked. Our take: if your stack is .NET or your agents already live in Azure, this is the least-friction credible option on the list, and the observability story is better than its marketing suggests. Do not pick it for a Python-only greenfield project where ADK or LangGraph have deeper community ground.

4. LangGraph — best for graph-shaped agents with fine state control

LangGraph is a low-level orchestration framework and runtime for building long-running, stateful agents as graphs, used as a plain Python or JavaScript library or deployed on LangSmith's Agent Server. Its overview documentation defines it as "a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents."

Class: orchestration framework with pluggable persistence · Runs: in your process, or on LangChain's managed Agent Server backed by PostgreSQL and a durable task queue · Languages: Python, JavaScript.

Durable execution. Checkpointers, the best-documented persistence layer in this roundup. The checkpointers documentation describes a snapshot "of graph state at each super-step, organized into threads," with savers for Postgres, MongoDB, SQLite and Cosmos DB, and three durability modes — "exit", "async" and "sync", the last giving "high durability at the cost of some performance overhead."

Replay on failure. Present, with a caveat worth the price of the section. get_state_history(), update_state() and invoking with a checkpoint_id let you replay from or fork at any checkpoint, and earlier nodes are not re-executed. But the same documentation states that LLM calls and interrupts "are always re-triggered during replay" — so recovery costs you tokens that Temporal, Restate and Microsoft Agent Framework do not.

Human-in-the-loop. The cleanest API in the category. interrupt() "pauses graph execution and returns a value to the caller," saving state and waiting; you resume with a Command carrying the resume value, per the interrupts documentation. It requires a durable checkpointer and a thread ID in production.

Per-step cost and latency. Split, and the split is commercial. The OSS package surfaces token counts on AIMessage.usage_metadata; dollar cost and latency percentiles are LangSmith features, and LangChain's tracing documentation notes that "Without ls_model_name, token counts may still be recorded but costs won't be estimated."

Licence · adoption · cost. MIT. 38.1k stars and 561.7 million total PyPI downloads, 51.0 million in the last 30 days. LangSmith Developer is $0 per seat with 5k base traces per month; Plus is $39 USD per seat per month with 10k, both then charging $1.50 per LangChain Compute Unit and $1.00 per Storage Unit.

"LangSmith gives us the ability to monitor all of our agents, understand what's working, what's not, what tool calls have failed, what PR just broke the pipeline, and what features our users are adopting." — Kordel France, Director of AI Engineering, Toyota Motor North America

Pros: the most mature persistence layer, with real Postgres and Mongo backends; the most ergonomic interrupt API; the deepest ecosystem, with Klarna, Replit and Elastic named in the repository README. Cons: replay re-fires LLM calls, which turns recovery into a billing event; resuming after an interrupt "restarts the entire node from the beginning," so side effects before the interrupt must be idempotent; cost attribution lives in LangSmith, not in the library. Our take: LangGraph is the safe default for Python teams who want control over graph state and will pay LangSmith for the cost picture. Do not pick it if recovery must be free — put it on Temporal, which it integrates with directly.

5. Pydantic AI — best for type-safe Python that keeps its options open

Pydantic AI is a Python agent framework that adds typed, validated structure to agents, tools and outputs and deliberately delegates durability to an external engine rather than shipping its own. Its durable execution documentation says it "allows you to build durable agents that can preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability."

Class: orchestration framework with pluggable durable execution · Runs: in your process, with durability from whichever backend you attach · Languages: Python.

Durable execution. Delegated by design to five co-maintained integrations — Temporal, DBOS, Prefect, Restate and AWS Lambda — plus Kitaru and Apache Airflow. The documentation is blunt about the boundary: "Durability is not storage."

Replay on failure. Inherited from the backend. Attach Temporal or Restate and you get their guarantees, including model calls that are not repeated; attach nothing and a crash costs you the run.

Human-in-the-loop. First-class and unusually well-typed. A paused run ends with DeferredToolRequests as its output, carrying calls and approvals; you resume by calling the agent again with the original message_history and a populated DeferredToolResults. Tools carry requires_approval, or raise ApprovalRequired and CallDeferred at runtime, per the deferred tools documentation.

Per-step cost and latency. OpenTelemetry-native, in the package. Pydantic Logfire is the first-party viewer but not a requirement — Personal is free with 10 million spans, Team is $49 USD per month with 10 million included and $2 per additional million, per Pydantic's pricing page.

Licence · adoption · cost. MIT. 19.6k stars, 2.6k forks. The framework is free; observability is the only paid surface, and it is optional.

Pros: typed end to end, which catches the class of agent bug that only shows up in production; the approval API is the most precise here; it does not lock you into one durability story. Cons: it ships no durable engine of its own, so "durable" is a decision you still have to make and operate; the approval mechanism is explicitly "not an authorization boundary against an untrusted client"; we found no named practitioner quote about running it in production, which is a real evidence gap against LangGraph or Temporal. Our take: pick Pydantic AI when you want the agent layer typed and the durability layer swappable, and pair it with Temporal or Restate on day one rather than later. Do not pick it if you want batteries included — the battery is sold separately, on purpose.

6. Mastra — best for TypeScript teams

Mastra is a TypeScript framework for AI-powered applications and agents, combining model routing, agents, graph-based workflows, human-in-the-loop control and observability, deployed self-hosted or on the Mastra Platform. Its repository describes it as "the modern TypeScript framework for AI-powered applications and agents."

Class: orchestration framework with workflow persistence and a managed platform · Runs: anywhere Node runs, or on Mastra's hosted platform · Languages: TypeScript.

Durable execution. Snapshots to a storage provider you configure. Mastra's suspend-and-resume documentation states that "Suspension saves the current execution state as a snapshot" and that snapshots "are stored in your configured storage provider and persist across deployments and application restarts."

Replay on failure. Resume from a suspension point is first-class and well documented; recovery from an unplanned crash is not, which is why Mastra scores 3 rather than 5 here. Teams needing crash-grade durability pair it with Temporal, which lists Mastra among its first-party integrations.

Human-in-the-loop. suspend() and resume(), the cleanest expression of the pattern in TypeScript. A step suspends, its state snapshots, and the run picks up when you resume it, with no documented maximum duration. Workflow-level .sleep() and .sleepUntil() set the run to waiting instead — a different mechanism worth not confusing.

Per-step cost and latency. Through Mastra's observability layer, metered on the platform. The pricing page bills observability by events — 100K included on Starter, then $10 per 100K; 1M on Teams, then $8 per 100K — alongside CPU hours at $0.35 and $0.25 respectively.

Licence · adoption · cost. Apache-2.0 with a carve-out: the LICENSE.md excludes content under any ee/ directory, including packages/core/src/auth/ee/ and packages/server/src/server/auth/ee/, which fall under a separate enterprise licence. 27.1k stars, 2.6k forks. Platform Starter is $0 per month with unlimited users, deployments and projects and 15-day retention; Teams is $250 USD per month with six-month retention, SSO and SOC 2 documentation.

Pros: the strongest TypeScript story here, with suspend/resume that survives restarts; self-hosting is genuinely free under Apache-2.0; 40+ model providers behind one router. Cons: the ee/ carve-out means "Apache-2.0" needs an asterisk, and it covers auth — exactly the part an enterprise wants to self-host; crash replay is under-documented relative to suspension; we found no named practitioner quote with a job title about running it in production. Our take: if your team writes TypeScript and does not want to context-switch into Python to get agents, Mastra is the obvious pick and the suspension model is well judged. Do not pick it if your durability requirement is "survive a node dying mid-run" without adding a runtime underneath.

7. CrewAI — best for getting a multi-agent prototype running fast

CrewAI is an open-source Python framework for orchestrating role-based autonomous agents, built around Crews of collaborating agents and Flows of event-driven workflows, self-hosted or deployed on CrewAI AMP. Its introduction calls it "the leading open-source framework for orchestrating autonomous AI agents and building complex workflows."

Class: orchestration framework with incrementally added persistence · Runs: in your process, or on CrewAI's managed AMP infrastructure · Languages: Python.

Durable execution. Two overlapping mechanisms, which is the honest description. Checkpointing "saves a snapshot of execution state during a run so a crew, flow, or agent can resume after a failure or be forked into an alternate branch"; separately, the @persist decorator saves Flow state, defaulting to SQLiteFlowPersistence. Worth keeping straight: CrewAI Memory is an embeddings and RAG recall system, not execution-state persistence.

Replay on failure. Two routes — crewai replay -t <task_id> replays "from this task ID, including all subsequent tasks," and Flows resume via kickoff(inputs={"id": uuid}) or fork via restore_from_state_id. One caveat: auto-checkpoint writes are "best-effort: a failed write is logged and the run continues."

Human-in-the-loop. Tiered, and the tier matters. human_input=True prompts the user before a Task's final answer, and @human_feedback defaults to a blocking console provider; the non-blocking webhook HITL a production deployment actually needs — a run sitting in Pending Human Input, resumed by API — is an Enterprise feature.

Per-step cost and latency. Aggregate only in the open-source package. The Flows documentation states that "each entry in the returned UsageMetrics is the sum across all LLM calls made within a single flow.kickoff() invocation" — no per-step attribution, no cost field, no timing. CrewAI Tracing, which does capture "Execution times, token usage, and costs," requires crewai login and an AMP account, though that account has a free tier.

Licence · adoption · cost. MIT. 58.8k stars — the most of any entry — and 112.6 million total PyPI downloads. CrewAI's blog reports "around 2 billion agentic system executions in the last 12 months," and the company says 65% of the Fortune 500 use it. The Basic tier is $0 with 50 workflow executions per month; Enterprise is quote only, and the overage rate above 50 executions is not published.

Pros: the fastest path from zero to a working multi-agent crew, by some distance; MIT with no carve-outs; the largest community in this list. Cons: durability arrived in three separate systems rather than one, and the default persistence is local SQLite; production-grade async HITL sits behind Enterprise; despite the size of the community we could not verify a single named practitioner quote with a job title about running CrewAI in production, which is an odd gap at 58.8k stars. Our take: CrewAI earns its stars on time-to-first-crew, and for exploration that is the metric that matters. Do not pick it as the durability layer for a system where a dropped run costs money — the OSS package will get you to a demo faster than it gets you to an SLA.

8. Restate — best for low-latency durable agents on one binary

Restate is a durable application runtime shipped as a single binary, combining durable execution, keyed state, queues, RPC and timers, self-hosted or as Restate Cloud. Its homepage describes it as "a low-latency application runtime with durable execution, keyed state, queues, RPC, timers, flow control, and operational control in one binary."

Class: durable runtime with a documented agent pattern library · Runs: one self-hosted binary, or Restate Cloud · Languages: TypeScript, Python, Java, Kotlin, Go, Rust.

Durable execution. Journaling with replay. Restate's key concepts documentation says it tracks "every step of your code execution in a journal," recording "both the operation and its result," and on failure "replays the journal, skipping completed steps and resuming from exactly where it left off."

Replay on failure. The most explicit statement any vendor here publishes. Restate's durable agents pattern states flatly: "Completed steps are replayed from the journal (no re-execution)," "Execution resumes from the first incomplete step," and "LLM calls are not repeated (saving cost and time)." Every LLM response is persisted and replayed from the journal on recovery.

Human-in-the-loop. Durable promises. The human-in-the-loop pattern has an agent create a durable promise, take a callback ID and suspend — "freeing compute resources (no idle billing on serverless)" — then resume "from the exact point it paused" when an approver resolves it over HTTP. No maximum wait is documented.

Per-step cost and latency. Journal-level visibility: a "Journal view: Inspect the step-by-step execution of any agent, including inputs, outputs, and timings." Token cost is not tracked natively.

Licence · adoption · cost. This is the column that costs Restate points. The server is BUSL-1.1, and the LICENSE file says so in its own words: "The Business Source License (this document, or the 'License') is not an Open Source license." It converts to Apache-2.0 four years after release, and the additional use grant permits internal production use while forbidding a public Restate platform service. The client SDKs are MIT. 4.4k stars. Restate Cloud is free to 50k durable actions per month and starts at $75 per month; the per-action overage rate is not published.

"Everyone here was shocked at how easy it was to get up and running with Restate. In a couple of hours, we successfully implemented Restate as the orchestrator of a pipeline that was very error prone and not durable at all, causing a lot of stress." — Sebastian Hindhede, CTO, Advisoa

Pros: the clearest published guarantee that recovery does not re-bill your model calls; sixteen documented AI patterns, from racing agents to rollback on failure; one binary to run locally, which is a real developer-experience advantage over a multi-service control plane. Cons: BUSL-1.1 is not open source and some procurement teams stop reading there; the smallest ecosystem in this list at 4.4k stars with no published customer counts; a step that blocks for over a minute without journalling gets suspended and retried by default, which is a subtle trap for slow model calls that are not wrapped correctly. Our take: Restate is the best-argued durable runtime for agents specifically, and its pattern library reads like it was written by people who have shipped one. Do not pick it if your organisation treats non-OSI licences as a hard stop — that is a policy question, and it will not be won in a design review.

9. Inngest — best for per-step cost and latency accounting

Inngest is a durable execution and workflow orchestration platform where each step runs as a separate HTTP request against your own serverless functions, servers or edge, with an SSPL-licensed self-hostable server and a managed cloud. It ships AgentKit, a TypeScript agent framework, alongside step.ai inference primitives.

Class: durable runtime with an agent framework attached · Runs: your functions, anywhere they already run; Inngest invokes them · Languages: TypeScript, Python, Go.

Durable execution. Step memoization. Inngest's execution documentation explains that "each step in your function is executed as a separate HTTP request" and that completed steps are memoized, so the function "resumes, skipping any steps that have already been completed."

Replay on failure. Completed steps are not re-run — "the step's code is not executed, instead the SDK injects the result into the return value." The catch is architectural: the function body around your steps re-executes at every step boundary, so anything not wrapped in step.run() is redone every time.

Human-in-the-loop. step.waitForEvent pauses a run until a matching event arrives, with the clearest published limits of any entry: maximum run length of 30 days on Free, 90 on Basic and 366 on Pro, and sleeps "at maximum… for a year."

Per-step cost and latency. The most complete here, and it is not close. Inngest's AI observability documentation tracks token usage per AI call, computes "Estimated cost" from uncached tokens at each model's list price, and reports p50, p95 and p99 latency per call — automatically for the OpenAI, Anthropic and Google Generative AI SDKs once an OpenTelemetry provider is loaded. It scores 4 rather than 5 on our rubric for one reason: the numbers land in Inngest's dashboard, not in a backend you own.

Licence · adoption · cost. SSPL-1.0 for the core server, with an irrevocable Apache-2.0 grant effective on the third anniversary of each release; AgentKit is Apache-2.0. 5.8k stars for the server, 926 for AgentKit. Hobby is $0 per month with 50k executions; Pro starts at $99 USD per month with 1M included. Read the billing unit carefully: Inngest's pricing page defines an execution as "a single durable function run plus each step inside it," so a five-step function costs six executions.

"Replays and error handling are so critical. Being able to replay functions is incredibly useful because outcomes can be unpredictable. Whether it's an outage or data inconsistency somewhere that affects function runs, having the ability to retry that work ensures we process everything end-to-end without missing a thing." — Diego Escobedo, Founding Engineer, Outtake

Pros: native token cost and p95 latency per AI call, which nobody else ships; no workers or queues to run; published, specific limits instead of vague assurances. Cons: SSPL is not an OSI-approved open-source licence; per-step billing multiplies linearly with a chatty agent loop, against a 1000-step cap and 32MB run-state ceiling; waitForEvent has two real footguns — events sent before the function runs are not matched, and a losing wait in a race is not cancelled. Our take: Inngest is the right answer when "what did step four cost and how slow was it" is a question you ask weekly, and the serverless execution model fits how you already deploy. Do not pick it for fine-grained agent loops with hundreds of steps — the billing unit and the step cap both work against you.

10. LlamaIndex Workflows — best for event-driven, document-heavy pipelines

LlamaIndex Workflows is an event-driven, async-first Python framework for controlling the execution flow of agents through steps that emit and consume events, usable as a library, as a server, or deployed via the llamactl CLI. The project describes Workflows as "an event-driven, async-first, step-based way to control the execution flow of AI applications like agents."

Class: orchestration framework with snapshot-based persistence · Runs: in your process, behind a WorkflowServer, or via llamactl · Languages: Python.

Durable execution. Context snapshots. The state documentation explains that state "is serialized when you snapshot a run to make it durable, so keep it to values a JSON serializer can encode," using ctx.to_dict() and Context.from_dict() with a configurable serializer. Durability is therefore something you invoke, not something that happens by default.

Replay on failure. Restore from a snapshot you took. There is no automatic checkpoint-per-step mechanism equivalent to LangGraph's supersteps or Temporal's event history, and the ctx.wait_for_event() path carries a documented replay cost: "The step always runs at least once up to the waiter, which then raises an internal exception to pause execution. Any code before the wait_for_event call must be safe to repeat."

Human-in-the-loop. Clean and event-shaped. One step returns an InputRequiredEvent, another consumes a HumanResponseEvent, and the caller replies with handler.send_event(HumanResponseEvent(...)). For waits spanning separate HTTP requests, the documented pattern is to "snapshot the context after the prompt, store it, and restore it when the response arrives" — durability is explicit, which is either honest or inconvenient depending on your temperament.

Per-step cost and latency. Through instrumentation hooks and OpenTelemetry exporters rather than a built-in cost view. There is no native token-cost dashboard in the open-source package.

Licence · adoption · cost. MIT. The Workflows runtime lives in the llama-agents repository at 451 stars — a fraction of the LlamaIndex brand's reach, and a fair signal that the runtime is much newer than the library it came from. LlamaCloud pricing is not published on a public page; treat it as quote only.

Pros: the event-driven model maps naturally onto branching, looping and parallel steps without a DSL; MIT with no carve-outs; strongest fit when retrieval over documents is the actual workload rather than an afterthought. Cons: durability is opt-in and manual, so a crash between snapshots loses work; the wait_for_event replay caveat puts an idempotency burden on step code; the runtime's small repository and the platform's unpublished pricing make it the hardest entry here to evaluate on evidence. Our take: pick LlamaIndex Workflows when your agent is fundamentally a document pipeline with branches and you already use LlamaIndex for retrieval. Do not pick it as a general-purpose durable orchestration layer — snapshotting by hand is a fine primitive and a poor guarantee.

11. OpenAI Agents SDK — best for the shortest path from prompt to working agent

The OpenAI Agents SDK is a lightweight Python and TypeScript library for building agentic apps from a few primitives — agents, handoffs, guardrails and sessions — running inside your own process, with a separate OpenAI-hosted Agents API for teams that would rather not run the loop at all. The docs describe it as a way to "build agentic AI apps in a lightweight, easy-to-use package with very few abstractions."

Class: orchestration framework with a managed sibling runtime · Runs: in your process; the Agents API runs OpenAI's Codex harness on OpenAI's infrastructure · Languages: Python, TypeScript.

Durable execution. This is where our rubric bites hardest. Sessions "store conversation history for a specific session, allowing agents to maintain context without requiring explicit manual memory management," backed by SQLite, Redis, SQLAlchemy, MongoDB or an encrypted store. That is durable transcript, not durable execution: a crash mid-run gives you the conversation back, not the frontier. The exception is RunState, which serialises at an approval interruption via state.to_json().

Replay on failure. Not supported as a first-class mechanism, and OpenAI says so. The Agents API sessions documentation states: "Streams do not replay missed events. After a disconnect, retrieve the session and its saved items to recover the work." Recovery is reconnect-and-refetch, not step replay.

Human-in-the-loop. First-class, and better than the rest of the SDK's durability story would suggest. needs_approval on a tool pauses the run and fills RunResult.interruptions with ToolApprovalItem entries; you call result.to_state(), approve or reject, and re-run — and per the HITL documentation, "the resumed run continues where it left off." Because RunState serialises, the approval survives a restart.

Per-step cost and latency. Run-aggregated in the package: "Usage is aggregated across all model calls during the run, including model calls that produce tool calls or handoffs." Per-step timing comes from tracing, on by default and viewed in OpenAI's hosted Traces dashboard — free, but hosted.

Licence · adoption · cost. MIT. 28.6k stars and 14.0 million PyPI downloads in the last month; openai-agents 0.22.3 shipped 17 September 2026. The SDK is free and the Agents API, in public beta since 10 September 2026, adds no platform fee — OpenAI's announcement states "There are no additional fees for using the Agents API – you simply pay for the tokens and tools your agents use."

"At Nash, we deploy thousands of long-running AI agents that manage hundreds of millions of deliveries across global logistics networks. OpenAI's Agents API gives us the durable session and orchestration layer we need for agents operating continuously in production managing context, recovery, and multi-step execution." — Aziz Alghunaim, Co-founder & CTO, Nash.ai

Pros: the lowest-friction start of anything here, with genuinely few abstractions to learn; the approval mechanism is excellent and survives serialisation; MIT, and the hosted option costs nothing above tokens. Cons: sessions persist conversation, not execution, which is the single most consequential distinction on this page; the Agents API "currently supports data residency only in the United States and does not support Zero Data Retention," a hard stop for EU-resident or ZDR-contracted workloads; usage accounting is run-aggregated with no latency, so per-step timing effectively means using OpenAI's hosted traces. Our take: start here if you are validating whether an agent solves the problem at all — nothing gets you there faster, and the tool-approval design is the best in the field. Move the durability question before launch: Temporal's integration runs the agent loop inside a workflow with model calls as activities, which is the shortest path from this SDK to a system that survives a deploy.

What happened to AutoGen, and do you have to migrate?

Microsoft AutoGen is in maintenance mode and has been since 2 October 2025 — nearly a year, not a week, whatever the aggregators say. The microsoft/autogen README states it plainly: "AutoGen is now in maintenance mode. It will not receive new features or enhancements and is community managed going forward." New users are pointed at Microsoft Agent Framework; existing users are pointed at an official migration guide.

Here is the timeline, dated, because most coverage of this is not:

"AutoGen will still be maintained -- it has a stable API and will continue to receive critical bug fixes and security patches -- but we will not be adding significant new features to it." — Eric Zhu, AutoGen Maintainer, microsoft/autogen Discussion #7066

So do you have to migrate? Not urgently. AutoGen has a stable API, still gets security patches, and carries 60.4k stars — more than any live framework in our list. What it does not have is a published end-of-support date: we searched the README and the announcement discussion and there is none. Semantic Kernel got an explicit support commitment of at least one year past Agent Framework's GA. AutoGen got community management.

That asymmetry is the actual signal. Migrate when you next touch the orchestration layer for another reason, and treat the guide's breaking changes as the real cost: the event-driven Team becomes a typed, graph-based Workflow, AssistantAgent is single-turn unless you raise max_tool_iterations while Agent Framework's Agent is multi-turn by default, and FunctionTool gives way to a @tool decorator with inferred schemas. None of that is a weekend.

What do these AI agent orchestration frameworks actually cost to run?

At realistic volumes the orchestration layer is nearly free, and the surprises live in the billing units rather than the headline rates. Here is one scenario run through every published pricing model: 2,000 agent runs per month, six checkpointed steps each, one human approval per run waiting an average of four hours.

Three hidden costs do the real damage. Inngest bills the run plus every step inside it, so a chatty agent loop multiplies its bill by its own step count. Temporal bills timer starts as Actions, so an agent idling on a human approval consumes no compute but still accrues Actions. And LangSmith will record token counts without estimating cost unless you attach ls_model_name metadata, which is the kind of thing you discover during a budget review rather than during setup.

Then there is the cost nobody puts in a pricing table: the tokens you pay for twice. A framework that re-executes completed model calls on recovery re-bills every step it already paid for.

Aissist runs its own multi-agent architecture, AgentMesh™, against live helpdesk volume across Intercom, Zendesk, Freshdesk, Gorgias, Kustomer, Front, Salesforce and HubSpot. Aissist's cost benchmark publishes the billing rule for that work as min(interactions × $0.09, $0.60 per resolution) — a $0.60 ceiling per resolution. That is our own figure on our own blog, and we would label it vendor-claimed if anyone else published it. At that unit economic, re-running a six-step resolution because a worker restarted does not just cost latency: it re-bills the steps that already succeeded, and it re-fires their side effects into somebody else's helpdesk. Which is why, of the five capability columns in the comparison table near the top of this page, replay-on-failure is the one we would check before signing anything.

How do you choose an AI agent orchestration framework?

Choose by the failure you cannot afford, not by the abstraction you like most. Seven rules, in the order we would apply them:

• If a lost run costs money or touches a customer's system, choose Temporal or Restate, because they are the only entries whose documentation states that completed model calls are not re-executed on recovery.
• If you need per-step token cost without sending traces to a vendor, choose Google ADK, Microsoft Agent Framework or Pydantic AI, because all three emit OpenTelemetry GenAI spans to any OTLP backend you already run.
• If your stack is .NET or already in Azure, choose Microsoft Agent Framework, because nothing else here ships first-class .NET and its interrupts survive checkpointing.
• If your team writes TypeScript, choose Mastra or Inngest — Mastra if you want the agent framework, Inngest if you want the durable runtime and the cost dashboard.
• If you are still deciding whether an agent solves the problem, choose the OpenAI Agents SDK, because it gets you to a working answer fastest, and move the durability question before launch.
• If you want maximum control over graph state and will pay for observability, choose LangGraph, because its checkpointer layer is the most mature and LangSmith is the price of the cost picture.
• If you want the agent layer typed and the durability layer swappable, choose Pydantic AI, and attach Temporal, DBOS, Prefect, Restate or AWS Lambda on day one rather than after the first incident.

One rule that is not about products: pick the runtime before the framework if durability matters, and the framework before the runtime if it does not. Frameworks are easy to swap and hard to love; runtimes are the opposite. Our build vs buy analysis covers the layer above this decision, where the question stops being which framework and becomes whether to assemble the system at all.

Orchestration, agent framework, control plane: what is the difference?

These three terms describe three different layers, and the market uses them interchangeably, which is why comparison pages in this category read like they are comparing unlike things — because they are.

An agent framework is the library you write agents in: the loop, tools, handoffs, structured outputs and memory. LangGraph, CrewAI, Pydantic AI, Mastra, the OpenAI Agents SDK, Google ADK and LlamaIndex Workflows are agent frameworks. It answers how do I express what the agent does.

An orchestration runtime is what the agent runs on: durable execution, retries, replay, timers, and waits that hold no process open. Temporal, Restate and Inngest are orchestration runtimes; Google ADK and Microsoft Agent Framework include one. It answers what happens when this breaks. Temporal's AI documentation lists ten agent frameworks it runs underneath — LangGraph, OpenAI Agents SDK, Pydantic AI, Google ADK and Mastra among them — which tells you how the two layers are actually combined in production.

An agent control plane is what governs all of it. Forrester's Leslie Joseph defines it as "an enterprise control plane that inventories, governs, orchestrates, and assures heterogeneous AI agents across vendors and domains," and argues in a March 2026 analysis that it is "the third functional plane in an enterprise agentic architecture, alongside the build plane and the orchestration plane," where "governance must sit outside both build and orchestration environments." It answers who is allowed to run what, and can you prove it.

That third layer is arriving fast. In Forrester's poll of 47 technology vendors in late February 2026, "seventy-nine percent of participating vendors recognize agent control planes as a meaningful and distinct product category," and IDC's Zhenya Sun reports enterprises now allocating "an average of 16.7% of their total planned AI spending to AI and Agent security and governance." WSO2 took Agent Manager, an Apache-2.0 control plane, to general availability on 15 September 2026, positioning it as "one inventory for every agent on any model, framework or runtime."

One more category people call a framework: platform-native agent languages are not portable. Salesforce open-sourced Agent Script under Apache-2.0 at TDX in April 2026, and the repository is explicit — "What we're not open sourcing (yet) is the runtime… you can parse, lint, compile, and build tooling around Agent Script, but running agents requires Salesforce's runtime environment." Agentforce's Multi-Agent Orchestration reached GA on 11 September 2026. Both are real; neither is a framework you can take with you. For how these layers stack in a working system, see our notes on how multi-agent AI coordinates across business functions and on the gateway layer between agents and the systems they act on.

Durability is a property of the runtime, not the framework

These eleven frameworks differ far less in how they compose agents than their documentation suggests, and far more in what happens when something dies mid-run. Google ADK tops our scoring as the only entry shipping resumable execution and per-step token accounting in an Apache-2.0 package with no hosted dependency. Temporal is second and would be first on a pure survival rubric. The OpenAI Agents SDK is eleventh and will still be the right first choice for many teams, because reaching a working agent quickly is a legitimate goal and durability can be added underneath later.

So the practical answer is usually two products: a framework your team enjoys writing, and a runtime that makes a crash boring. Pick the second one first if the run is worth money. If you would rather not assemble either — because the agents you need are customer service and sales agents, not infrastructure — that is a different decision, and we have written about it.

Running agents against real ticket volume rather than benchmarks? Aissist.io's AgentMesh™ is the multi-agent layer behind an 83% average resolution rate on live helpdesk traffic — built so a restart costs a retry, not a re-bill. See how the architecture works →

Frequently asked questions

What is the best AI agent orchestration framework in 2026?

Google ADK scores highest in our rubric at 28 out of 30, because it ships durable execution, resume and per-step token accounting under Apache-2.0 with no hosted platform required. Temporal follows at 27 and is the stronger pick when surviving failure matters more than framework ergonomics.

What is the difference between an AI agent framework and agent orchestration?

An agent framework is the library you write agents in — the loop, tools, handoffs and memory. Orchestration is what runs them: durable execution, retries, replay and timers. Several products do both, but they are separable layers, and most production systems combine one of each.

Which AI agent frameworks support durable execution?

Google ADK, Microsoft Agent Framework, LangGraph, CrewAI, Mastra and LlamaIndex Workflows all persist workflow execution state in their open-source packages. Temporal, Restate and Inngest provide durable execution as runtimes underneath any framework. The OpenAI Agents SDK persists conversation history rather than execution state.

Does LangGraph re-run LLM calls when a workflow replays?

Yes. LangGraph's checkpointer documentation states that LLM calls and interrupts "are always re-triggered during replay," so recovering a failed run costs tokens again. Temporal, Restate and Microsoft Agent Framework's Durable Task path all document the opposite behaviour.

Is Microsoft AutoGen still maintained in 2026?

AutoGen is in maintenance mode — bug fixes, security patches and documentation only, community managed, with no published end-of-support date. Its last release, 0.7.5, shipped 30 September 2025. Microsoft directs new projects to Agent Framework and publishes an AutoGen migration guide.

Which agent framework is best for TypeScript?

Mastra is the strongest TypeScript agent framework, with suspend() and resume() that snapshot state to your storage provider and survive restarts. Inngest is the better choice if you want a durable runtime with native per-step token cost and p95 latency rather than an agent framework.

How much does AI agent orchestration cost?

The orchestration layer itself is close to free at moderate volume — 2,000 runs a month sits inside the free tier on Inngest, Restate and Mastra. Costs come from model tokens, from billing units that multiply with step count, and from observability platforms priced per trace or per span.

Do I need an agent control plane as well as a framework?

Only once you are running agents from more than one framework or team. A control plane inventories and governs agents across runtimes; Forrester found 79% of 47 polled vendors treat it as a distinct category. Below that scale, your framework's own observability is enough.

Changelog

• September 2026 — First published. Eleven frameworks scored against the six production criteria; AutoGen's maintenance-mode timeline corrected to October 2025 against the primary source; all licences read from repository LICENSE files; all prices read from live vendor pricing pages on 21 September 2026.