Best Agent Frameworks for Production Use
We rank six agent frameworks used in production as of November 2026 and show why none of them handle API permissions, retries, or audit by design.
Key takeaways
- -LangGraph is the strongest pick for complex, stateful multi-agent work that needs checkpointing and human review mid-run.
- -Every framework here manages the reasoning loop well, but each one explicitly leaves credentials, policy, idempotent retries, and audit logging to the caller.
- -The OpenAI Agents SDK and Claude Agent SDK are the fastest paths to a working agent if you are already inside their model ecosystem.
- -A production runtime like Swytchcode sits underneath any of these frameworks and handles the permissions problem none of them solve by design.
The framework decides the loop. Something else decides the permissions.
A framework decides what the agent reasons about and when it calls a tool. That is the loop: read the state, pick a next step, call something, read the result, decide again. LangGraph, CrewAI, the OpenAI Agents SDK, the Claude Agent SDK, the Vercel AI SDK, and Microsoft's Agent Framework are all, at their core, answers to that one question.
None of them answer a second question: is this specific tool call actually allowed to run against a real system, right now, with this argument. That is a permissions question, not a reasoning question. It needs a credential, a policy check, a schema check against the live API, a safe retry, and a record of what happened. A framework's job stops at "the agent decided to call stripe.refund.create." Whether that call should run is a different layer entirely.
This is a "which framework" post. We looked at six frameworks people are actually running in production in November 2026, checked their own docs and changelogs for what they handle versus what they push back to you, and ranked them for different jobs. We also point out, every time, where the loop ends and the permissions problem starts, because that boundary does not move no matter which framework you pick.
How we scored these
We read each framework's own documentation, changelog, or a recent "what's new" writeup from November 2026, rather than relying on memory or marketing pages. For each one we asked how mature the agentic loop and multi-agent story is, what it says explicitly about credentials and policy, and what it leaves unaddressed.
We are not scoring these against Swytchcode, because they are not solving the same problem. A framework that handles the loop well and says nothing about credentials is not a worse framework for that. It is just a framework, doing a framework's job.
1. LangGraph
LangGraph builds agents as graphs: nodes are steps, edges are the control flow between them, and a shared state object moves through the graph. It is the most explicit "loop as a data structure" model of the six, which is why it shows up so often in complex, multi-step enterprise agents.
Its persistence layer is genuinely strong. Checkpointers save a thread's graph state as snapshots, which supports conversation continuity, human-in-the-loop workflows, time travel, and fault tolerance, while stores hold separate application-defined key-value data across threads. That covers resuming a run after an interruption and reviewing a decision mid-flight.
What it does not cover, by its own documentation, is execution safety. The durable execution and persistence pages do not describe retry behavior, do not define "durable execution" as a term, and do not mention API credentials, policy, or permissions at all. Checkpointing state is not the same as deciding whether a write should be retried safely.
Pick LangGraph when the hard part of your agent is the reasoning path itself: branching logic, loops back to earlier steps, multiple specialized nodes sharing one state object. Pair it with something else for the actual calls that path produces.
2. OpenAI Agents SDK
The OpenAI Agents SDK runs a tight, well-documented loop. Runner.run calls the model, executes any tool calls, follows handoffs, and repeats until an agent produces final output or hits the turn limit. Handoffs are first-class here: each one is exposed to the model as a tool named transfer_to_<agent_name>, and input filters control what history the next agent sees.
Guardrails are the SDK's answer to safety, and they are more specific than most frameworks attempt. Input guardrails run only for the first agent in the chain, output guardrails run only for the agent producing final output, and tool guardrails cover guarded function-tool calls, with callable rules failing closed on malformed arguments.
The gaps are specific too. Guardrails do not cover handoff calls or hosted and built-in execution tools, and the docs tell you to enforce that in on_handoff instead. Handoff recovery preserves external effects already performed by the invocation, but the docs describe no general retry or idempotency mechanism, so duplicate side effects are yours to design around. Tracing is on by default for OpenAI's dashboard, but a durable, independent audit trail is left to you to build.
Pick this SDK if you want handoffs and guardrails as native concepts, not bolted-on patterns, and you are comfortable owning retry safety and credential handling yourself.
3. Claude Agent SDK
The Claude Agent SDK is Claude Code packaged as a library. It gives you the same tools, agent loop, and context management that power Claude Code, programmable in Python and TypeScript. That lineage shows in what it ships: built-in tools for reading, editing, and running commands, hooks that run custom code at key points in the agent lifecycle, subagents for focused subtasks, MCP for external tools, permissions to control which tool calls run automatically versus which need approval, and sessions that persist context.
The permissions model deserves a closer look, because the word does double duty across this whole category. Claude Agent SDK permissions govern which of the agent's own tool calls run automatically, approved locally by a person or a configured policy. That is different from validating a call against a live third-party API schema, injecting a brokered credential that never enters the model's context, and writing an audit record outside the agent's own process. The SDK's permissions supervise the agent's actions on your machine, not a call against Stripe or Salesforce in production.
This makes the Claude Agent SDK an excellent fit for coding agents and internal tooling, where "run commands under supervision" is the actual job. For agents that spend most of their time calling external, revenue-touching APIs, you still need a separate execution layer underneath, same as with any framework here.
4. CrewAI
CrewAI organizes agents into crews with roles and tasks, and its newer "Flows" add declarative, graph-like orchestration on top. Flows support declarative definitions with crew and agent actions plus an each loop construct, and conversational flows support context compaction. State handling has matured quickly: checkpointing supports resume, diff, prune, and forking, and memory and knowledge backends are pluggable with runtime state scoped per run.
CrewAI is also the one framework here that has started building toward the permissions problem directly. An Agent Control Plane with a Cost Limit rule type has been added, model call hooks run on all code paths with denials carrying through, and SSRF checks run at each redirect hop with path traversal protections on output files. That is real progress, though it is scoped to CrewAI's own runtime, not a general credential broker or cross-framework audit trail.
Credential handling has tightened up too: a missing or placeholder API key raises a clear error, and credential files and the project .env are created owner-only. That is sensible local hygiene, but it is still a local .env model, which breaks down once credentials need to be shared, rotated, or scoped per tenant.
Pick CrewAI when the job is naturally a crew of specialized roles working a shared task list, and you want first-party guardrail primitives without reaching for a separate policy engine on day one.
5. Vercel AI SDK
The AI SDK's November 2026 release (version 7) is mostly about making the loop more controllable. It handles the tool loop including step limits via stopWhen, running tool calls concurrently by default or sequentially with toolCallConcurrency, tool discovery through toolSearch(), and retrying the failed step on mid-stream errors. The new "Harnesses" feature even lets you drive other agent runtimes, including Claude Code, Codex, and Pi, behind the same generate() and stream() calls, though it is still experimental and capabilities vary by adapter.
What the SDK pushes back to you is stated unusually plainly for a framework doc. For harnesses, credentials come from environment variables you manage. Bridge-backed harnesses need a real network sandbox you create and destroy yourself. Built-in approval is missing on some adapters, so a package like @ai-sdk/policy-opa can layer policies on the toolApproval callback, but you wire it up. Idempotency is on you too, since persistence should use idempotent upserts and "provider-executed tool work may repeat on the retry."
Pick the Vercel AI SDK if you are already on Next.js or want one abstraction over many model providers and, increasingly, over other agent runtimes. Budget separate time for the sandboxing, policy, and idempotency work the docs openly hand you.
6. Microsoft Agent Framework
Microsoft spent 2026 consolidating two frameworks into one. The Agent Framework is an open-source SDK and runtime for orchestrating multi-agent systems that combines AutoGen, a former Microsoft Research project, with the enterprise-ready foundations of Semantic Kernel into one commercial-grade framework. It reached 1.0 and general availability in April 2026, and Microsoft has since moved AutoGen and Semantic Kernel into maintenance mode.
On orchestration, it covers real ground: it supports multi-agent patterns such as Magentic One, lets you orchestrate agents into Workflows, integrates any API via OpenAPI, collaborates across runtimes using Agent2Agent, and connects to tools dynamically through MCP. That is a broad orchestration layer for teams already standardized on .NET or Azure-adjacent Python stacks.
The permissions story, though, is explicitly handed to a different product. Governance and safety features such as task adherence, prompt shields, and PII detection are described as built into Azure AI Foundry, where observability, durability, and compliance are also positioned as built in. Microsoft's own answer to "who handles execution safety" is, in effect, a separate platform, and only if you deploy there. Run the Agent Framework outside Foundry, which many teams on their own infrastructure will, and that governance layer does not travel with you.
Pick the Agent Framework if your team is already in the .NET or Azure ecosystem and wants one orchestration layer instead of maintaining AutoGen and Semantic Kernel side by side. Plan for a separate governance and credential layer regardless of whether Foundry is part of your deployment.
A different layer entirely: Temporal and durable execution
Temporal is not an agent framework and we are not ranking it as one, but it comes up often enough in production agent conversations to deserve a place here. It makes AI agent workflows durable mainly through retries and state persistence: LLM calls and tool calls are retried automatically after transient failures such as rate limits, progress survives crashes, and Temporal can resume a run where it stopped without repeating completed work.
Temporal plugs into a framework's loop rather than replacing it. With the Vercel AI SDK specifically, a Worker is configured with an AI SDK plugin, the model call is swapped for a Temporal-wrapped provider, and tools that make external calls are implemented as Temporal Activities. That solves "what happens if the process restarts mid-run," which is a real and distinct problem from "is this specific call allowed to run." A workflow can be perfectly durable and still fire an API call with no policy check behind it. Durability and permissions are both things a production agent needs, and neither substitutes for the other.
Side-by-side comparison
| Framework | Handles the loop/orchestration | Handles execution/permissions? | Best for |
|---|---|---|---|
| LangGraph | Yes, graphs with strong checkpointing and human-in-the-loop pauses | No, no retries, credentials, or policy described in its own docs | Complex, branching multi-step agents that need state and review |
| OpenAI Agents SDK | Yes, native handoffs and layered guardrails | Partially, guardrails skip handoffs and hosted tools; no general retry/idempotency model | Teams who want handoffs and guardrails as first-class concepts |
| Claude Agent SDK | Yes, the Claude Code agent loop with hooks and subagents | Partially, permissions supervise local tool approval, not production API governance | Coding agents and internal tooling run under human supervision |
| CrewAI | Yes, role-based crews plus declarative Flows | Partially, has its own Control Plane, cost limits, and SSRF checks, scoped to CrewAI | Crews of specialized roles with built-in guardrail primitives |
| Vercel AI SDK | Yes, configurable loop, tool search, and harnesses over other runtimes | No, docs explicitly hand credentials, sandboxing, policy, and idempotency to you | Next.js and multi-provider teams wanting one orchestration layer |
| Microsoft Agent Framework | Yes, Magentic One patterns, Workflows, A2A, MCP | Partially, governance lives in Azure AI Foundry, not the framework itself | .NET and Azure-standardized teams consolidating off AutoGen/SK |
| Temporal (not a framework) | No, wraps an existing framework's loop | No, solves durability (crash recovery, safe resume), not permissions | Long-running agent workflows that must survive restarts |
Where Swytchcode fits (it's not a framework)
Every framework above is good at the thing it set out to do: decide what the agent reasons about and when it calls a tool. None of them is trying to be the layer that decides whether that call is allowed to run, and that is by design, not an oversight. A production runtime is the layer that turns an agent's decision into a real API call under controls that hold at scale, and it is explicitly not the model, the framework, the catalog, or the gateway. LangGraph, CrewAI, and the Agents SDKs manage the loop and the reasoning. Something else has to manage what happens the moment that loop decides to touch a real system.
That something else is what Swytchcode runs. It sits underneath whichever framework you picked, as a CLI, an MCP server, or a thin runtime SDK, and does the part none of the six frameworks above claim to do: an allowlist check so only explicitly approved methods can run, schema validation against the real API before the call leaves, policy evaluation that can read the call's own arguments, credential injection that never puts a key in the model's context, safe retries that only touch POST and PATCH when an idempotency key is set, response validation for the "200 OK, body says failed" case, and a local audit record of what ran and what was blocked.
This is the build-versus-buy argument every team runs into. Every team builds the same middleware (auth, retries, policy, audit), then rebuilds it for the next framework when they switch from LangGraph to the Agents SDK or add a CrewAI crew next to an existing Claude Agent SDK deployment. One execution kernel, reachable from every agent framework through the same thin SDK, means that middleware gets built once. We go deeper on how this plays out across a full agentic stack in our rundown of the best agentic AI platforms for the enterprise, and on the governance side in our guide to API governance tools for AI agents.
If credentials, write safety, and audit are still held together with a .env file and good intentions, that is worth fixing before the framework choice, not after. The idempotency guide and the production guardrails docs are a reasonable place to start, alongside how enterprises are actually building AI agents in 2026. Working code lives in github.com/swytchcodehq/swytchcode-examples, including a LangGraph lead-qualification agent and a Claude-based Gmail assistant, both running real calls through the same execution kernel.
FAQ
Do any of these agent frameworks handle API credentials or permissions on their own?
Not fully, and most of them say so directly in their own docs. LangGraph's persistence pages do not mention credentials or policy at all. The OpenAI Agents SDK's guardrails explicitly skip handoffs and hosted tools. The Vercel AI SDK's own documentation states that credentials come from environment variables you manage and that idempotency is your responsibility. Even CrewAI and Microsoft's Agent Framework, which have made the most visible progress here, scope that work to their own runtime or to a separate platform (Azure AI Foundry) rather than to the open-source framework itself.
Which framework should I pick if I'm just starting out in November 2026?
It depends more on your model ecosystem and the shape of the problem than on any single framework being objectively best. If the hard part is a complex, branching decision path with checkpoints and human review, LangGraph's graph model and checkpointing are the strongest fit. If you're already building on OpenAI's models and want handoffs and guardrails as native primitives, the Agents SDK is the most direct path. If your agent is really a supervised coding or internal-tooling agent, the Claude Agent SDK gives you that loop out of the box. None of these choices change what you still need underneath for the permissions problem.
If frameworks don't handle execution safety, where does that logic normally end up living?
In practice, teams build it themselves, usually inside the "stitching layer" between the framework and the real APIs: a hand-rolled credential store, some retry logic that may or may not be idempotent, a few if statements standing in for policy, and logs scattered across whatever each API call happened to touch. That gets rebuilt every time the team adds a new framework or a new provider. A production runtime like Swytchcode is built specifically to be that layer once, with an allowlist, schema validation, policy evaluation, credential injection, safe retries, response validation, and audit, so it does not need rebuilding per framework.
More content
Best API Catalogs and Registries for AI Agents
We rank Backstage, Postman, Stoplight, SwaggerHub and the agent-native catalogs on one question: does the schema stay current at call time?
Best API Platforms for Fintech AI Agents
We rank Stripe, Modern Treasury, Plaid, Adyen, Increase, and Column on the two things that actually matter for fintech agents.
Best API Testing Tools for AI Agents
We rank the API testing tools worth using for AI-agent-called APIs, and why most of them test against yesterday, not today.
