COMPARISON GUIDE
LangGraph vs CrewAI vs OpenAI Agents SDK (2026)
Use LangGraph when an agent must pause for human approval, wait, and resume after a failure with a record of every step. Use the OpenAI Agents SDK for the fastest start on OpenAI models, and CrewAI when the job fits a team of role-based agents and you want a managed platform with a visual editor. All three are free, MIT-licensed libraries; you pay for models and for any hosted platform.
14 min read
All three frameworks are open source under the MIT licence, so the library itself costs nothing. The real differences are how each one keeps state, pauses for a person, recovers from a failure, and how closely it ties you to one model vendor or one hosted platform.
This guide is for teams that choose a framework for a production project. Versions, prices, GitHub stars and download counts are as read on 13 November 2026 from official docs, pricing pages, GitHub, PyPI and npm; every source is listed at the end. For build and running budgets, see our AI agent development cost guide.
Short Answer: Which Framework to Pick
LangGraph is the safest default for production workflows that need approvals, long waits or recovery after a failure: it saves a checkpoint after every step, and its core API has been stable at version 1.x since October 2025. The OpenAI Agents SDK has the smallest API and the quickest start, and it fits best when you use OpenAI models. CrewAI is the quickest way to model a team of role-based agents, and its managed platform adds a visual editor, but it is Python-only and its governance features (SSO, role-based access) need the Enterprise plan.
| Pick | Pick it if | Watch out for |
|---|---|---|
| LangGraph | The workflow has approval steps, long waits or must resume after a crash, and you want explicit control over every step. Python or TypeScript. | More code and more concepts to learn. Managed hosting and tracing (LangSmith) are paid beyond the free tier. |
| OpenAI Agents SDK | You use OpenAI models, want a small API and a fast start, and your runs are short or you can add a durable-execution engine. | Version 0.x: minor releases can break APIs. Other model providers go through beta adapters. |
| CrewAI | The job maps to a team of role-based agents (research, write, review), you work in Python, and you want a managed platform with a visual editor. | Python only. SSO, role-based access and hosting in your own VPC need the Enterprise plan. |
What Each Framework Is
| Fact | LangGraph | CrewAI | OpenAI Agents SDK |
|---|---|---|---|
| Maintainer | LangChain | CrewAI | OpenAI |
| Licence | MIT | MIT | MIT |
| Languages | Python 3.10+, TypeScript (LangGraph.js) | Python 3.10–3.13 | Python 3.10+, TypeScript |
| Latest version | 1.2.21 Python (12 Nov 2026); 1.7.4 JS (12 Nov 2026) | 1.15.41 (12 Nov 2026) | 0.24.0 Python (15 Oct 2026); 0.22.0 JS (12 Nov 2026) |
| First 1.0 release | 17 Oct 2025 | 20 Oct 2025 | Not yet (0.x) |
| Core abstraction | A graph of shared state, nodes and edges | Crews of role-based agents, run inside event-driven Flows | Agents with tools, handoffs and guardrails, run by a built-in loop |
| Hosted offering | LangSmith: tracing, evals, Agent Server hosting | CrewAI AMP: Studio, deployment, tracing | None for the SDK; the separate Agents API runs in OpenAI’s service |
| Model providers | Any; LangChain is not required | Native: OpenAI, Anthropic, Gemini, Azure OpenAI, Bedrock; more via LiteLLM | OpenAI first; others via compatible endpoints or beta adapters |
LangGraph
LangChain’s docs describe LangGraph as “a low-level orchestration framework and runtime for long-running, stateful agents.” You define a workflow as a graph: shared state, nodes that change it, and edges that decide what runs next. One graph can mix fixed code steps and model-driven steps. LangGraph does not prescribe prompts or agent architecture, and it does not require LangChain, so a node can call any model SDK. LangChain’s own create_agent runs on LangGraph.
- Strengths: a checkpoint after every step, built-in interrupts for approvals, retry policies and per-node timeouts, Python and TypeScript, and a v1 release (October 2025) that kept the core graph APIs unchanged.
- Weaknesses: you write more code than with the other two, and the concepts (state reducers, super-steps, threads) take time to learn. The hosted runtime has changed name: LangChain’s docs state that “LangSmith Deployment is now LangSmith Agent Server.”
- Vendor claim: the GitHub README lists Klarna, Replit and Elastic among companies that use it.
CrewAI
CrewAI’s README calls it “a standalone Python framework with its own primitives for agents, tasks, crews, flows, tools, and orchestration,” so it does not depend on LangChain. It has two layers:
- Crews: teams of agents, each with a role, a goal, a backstory and tools. A crew works through tasks in a sequential process, or a hierarchical one where a manager agent delegates.
- Flows: event-driven workflows with state, conditions, loops and branches. For production, the docs say to start with a Flow and call a Crew from a Flow step when a task needs autonomy.
Strengths: the role-based model is easy to read and to explain to business owners; checkpointing, task guardrails, and a managed platform with a visual editor. Weaknesses: Python only, and the current release does not support Python 3.14. Built-in tracing needs a (free) CrewAI AMP account. The crewai test command scores runs with OpenAI models only. The library sends anonymous telemetry by default; set OTEL_SDK_DISABLED=true to turn it off. CrewAI states that over 100,000 developers have been certified through its community courses and that 65% of the Fortune 500 use it; these are the vendor’s own figures.
OpenAI Agents SDK
OpenAI describes the Agents SDK as “a lightweight, easy-to-use package with very few abstractions” and a production-ready upgrade of its earlier Swarm experiment. An agent is a model with instructions and tools. A runner loops until the task is done: it calls the model, runs any tool calls, follows any handoff, and repeats. Multi-agent work uses two patterns: agents as tools (a manager calls specialists) and handoffs (a triage agent passes the conversation to a specialist). Sessions, guardrails, human approval, tracing, sandbox agents and voice agents are built in.
- Strengths: the smallest API of the three, approvals that work across handoffs and nested agents, and tracing that is on by default.
- Weaknesses: the SDK uses 0.Y.Z versioning, and OpenAI states that minor versions can include breaking changes, so pin the version. The Responses API is the recommended model path; some tool features work only there, and the Any-LLM and LiteLLM adapters for other providers are “best-effort, beta.” Durable execution across process restarts needs a third-party engine such as Temporal or DBOS.
What Each One Costs
The three libraries are free. In every case you pay model providers for tokens. The cost differences are in the optional hosted platforms.
| Item | LangGraph + LangSmith | CrewAI + AMP | OpenAI Agents SDK |
|---|---|---|---|
| Library | Free (MIT) | Free (MIT) | Free (MIT) |
| Free tier | Developer: $0, 1 seat, 5,000 base traces a month | Basic: $0, 50 workflow executions a month, 2 automations | No SDK fee; you pay OpenAI API usage |
| Paid tier | Plus: $39 per seat a month, 10,000 base traces, 1 small serverless Agent Server | Enterprise: custom price | None for the SDK |
| Usage pricing | $0.005 per extra base trace; Agent Server billed per vCPU-hour and GiB-hour | Enterprise: “flexible overage” | Tokens; web search $10 per 1,000 calls; file search $2.50 per 1,000 calls |
| Self-hosting | Library: anywhere. Agent Server: Enterprise, or standalone with a LangSmith licence | Library: anywhere. AMP: your VPC or infrastructure on Enterprise | Runs inside your own application |
| Trace retention | 14 days (base), 180 days (extended) | Not documented | Not documented |
- LangSmith units. LangSmith meters usage in LangChain Standard Units, at $1 per unit. Agent Server runtime costs 0.0675 units per vCPU-hour and 0.0090 per GiB-hour, and its database 0.177 per vCPU-hour and 0.025 per GiB-hour. LangChain recommends always-on dedicated servers for customer-facing agents; serverless servers scale to zero and suit background agents.
- CrewAI Enterprise adds SSO (Microsoft Entra, Okta), role-based access control, PII redaction, and a 45-day onboarding. CrewAI does not publish its price.
- OpenAI hosted tools are billed per call on top of tokens. File search storage is $0.10 per GB a day after 1 GB free.
Side-by-Side: Production Criteria
| Criterion | LangGraph | CrewAI | OpenAI Agents SDK |
|---|---|---|---|
| State and checkpointing | Checkpoint after every super-step, per thread. Postgres, SQLite, Redis, MongoDB, DynamoDB and more. Replay and fork past runs. | Event-driven checkpoints (default: one per finished task) to JSON or SQLite. Flow state persists with @persist. | Sessions store history (SQLite, Redis, SQLAlchemy, MongoDB, Dapr, OpenAI Conversations). Paused runs save as RunState JSON. |
| Human-in-the-loop | interrupt() pauses any node; resume with Command(resume=...). Needs a checkpointer. | @human_feedback in Flows (v1.8.0+) routes approve or reject; an async provider pauses, saves and resumes the Flow. | needs_approval on tools; the run returns interruptions; approve or reject, then resume. |
| Multi-agent patterns | Subagents, handoffs, router, skills, or any custom graph | Crews: sequential or hierarchical (manager agent); Flows call Crews | Agents as tools (manager) and handoffs (triage) |
| Tool calling and MCP | LangChain tools; MCP via MCPAdapter (beta); Agent Server can expose an agent as an MCP server | Python tools; MCP over stdio, SSE and Streamable HTTP; AMP can export a workflow as an MCP server | Function tools with automatic schemas; hosted MCP plus stdio, SSE and Streamable HTTP |
| Streaming | Tokens, state updates, custom events and checkpoints | Frame streaming for Flows; chunk streaming for Crews | run_streamed() streams model output and tool events |
| Tracing | LangSmith (optional; LangGraph works without it) | Built-in tracing in CrewAI AMP; OpenTelemetry; integrations such as Langfuse, Datadog and MLflow | Built-in, on by default, sent to OpenAI; exporters for Langfuse, LangSmith, Datadog and more |
| Evaluation | LangSmith datasets, online and offline evals, annotation queues | crewai test (OpenAI models only); third-party tools | OpenAI’s hosted Evals is read-only and shuts down 30 Nov 2026; OpenAI points to Promptfoo |
| Retries and durability | Retry policy per node (default 3 attempts); per-node timeouts and error handlers (v1.2+) | Restore skips finished tasks; guardrail retries (default 3) | Opt-in runner retries; durable runs via Temporal, Dapr, Restate or DBOS |
| Deployment | Any Python or Node host; or Agent Server: cloud, hybrid, self-hosted, standalone | Any Python host; or AMP on CrewAI cloud, your VPC or your infrastructure | Your own application and infrastructure |
| Model providers | Any model; LangChain is not required | 5 native providers; 100+ via LiteLLM | OpenAI Responses first; others via compatible endpoints or beta adapters |
| Maturity (13 Nov 2026) | 44,888 GitHub stars; 58.7M PyPI downloads in 30 days (includes installs pulled in by LangChain); 17.9M npm | 60,835 stars; 2.6M PyPI downloads in 30 days | 30,648 stars (Python), 4,012 (TypeScript); 19.0M PyPI downloads in 30 days; 8.8M npm |
| Learning curve (our view) | Steepest: state, reducers, super-steps, threads | Gentle for Crews; Flows add a second model to learn | Gentlest: a few primitives in plain Python or TypeScript |
Read the maturity row with care. Stars measure interest, not production use. The langgraph download count includes installs pulled in by the langchain package, which depends on it. Download counts come from pypistats.org (last 30 days, read 13 Nov 2026) and npm (13 Oct – 11 Nov 2026).
Recent changes to know
- OpenAI announced on 3 June 2026 that Agent Builder and its hosted Evals shut down on 30 November 2026. It points Agent Builder users to the Agents SDK or ChatGPT Workspace Agents, and Evals users to Promptfoo. ChatKit remains available.
- LangGraph 1.2 (May 2026) added per-node timeouts and node-level error handlers. LangChain’s docs now call the hosted runtime LangSmith Agent Server, not LangSmith Deployment.
- CrewAI now recommends its native provider integrations over LiteLLM. Its docs say the litellm package “was quarantined on PyPI due to a security/reliability incident.”
Example: One Approval Workflow in Each Framework
A finance team wants an agent that reads an invoice, matches it to a purchase order, and asks a manager to approve any payment above a set amount. The manager may answer the next day. This is how each framework models it, using only documented features:
- LangGraph: four nodes (extract, match, approve, pay) and a conditional edge that sends large amounts to the approve node, which calls
interrupt(). A Postgres checkpointer keeps the paused thread, and the run resumes with the manager’s answer whenever it arrives. - OpenAI Agents SDK: one agent with extract, match and pay tools. The pay tool gets a
needs_approvalfunction that returns true above the threshold. Your app stores the paused run state as JSON in its database until the manager acts. For waits that must survive restarts and retries, add the Temporal or DBOS integration. - CrewAI: a Flow runs the steps and calls a small Crew for extraction and matching. A
@human_feedbackstep with the outcomes “approved” and “rejected” routes the result. With an async feedback provider, the Flow saves its state and resumes when the manager replies. An LLM maps the manager’s free-text reply to an outcome, so check the mapped outcome before money moves.
All three can do the job. LangGraph needs the most code but keeps the most control; the OpenAI SDK needs the least code but leaves durable waiting to you; CrewAI reads the most like a business process.
Production Concerns Buyers Ask About
Human approval steps
All three can stop before a risky action. They differ in where the pause lives and how it survives a restart.
- LangGraph: call
interrupt()in any node or tool. The checkpointer saves the state, and you resume on the same thread hours or days later. A reviewer can approve, reject, or edit the tool call before it runs. - OpenAI Agents SDK: set
needs_approvalon a tool. The run stops and returns the pending calls. Store the run state as JSON, callapproveorreject, and run again. This works after handoffs and inside nested agents. - CrewAI:
@human_feedbackin a Flow collects a reply and routes it to outcomes such as approved or rejected. By default it waits for console input. For production, a custom async provider notifies Slack, email or a webhook; the Flow saves its state and resumes when the reply arrives. CrewAI AMP also offers webhook-based approvals on Enterprise.
Audit logging
None of the three is an audit log. Traces are for debugging, and their retention is short: LangSmith keeps base traces for 14 days and extended traces for 180 days. If an auditor must see who approved what, write each approval, tool call and data change to your own store, with the thread or trace ID as the key. LangGraph’s checkpoint history and the OpenAI SDK’s run state give you the data to log; you own its retention. OpenAI traces can hold model and tool inputs and outputs; set trace_include_sensitive_data to False to leave them out. OpenAI tracing is not available to organisations under Zero Data Retention.
Guardrails
- OpenAI Agents SDK: input guardrails run on the first agent, output guardrails on the agent that gives the final answer, and tool guardrails on every guarded tool call. In blocking mode, the check finishes before the main model starts, so a blocked request does not reach the expensive model.
- CrewAI: task guardrails, written as a Python function or as a plain-language rule that an LLM checks. A failed check retries the task, 3 times by default.
- LangGraph: its docs do not list a guardrail primitive. You add checks as nodes or conditional edges. That gives full control but no ready-made API.
Retries and durable execution
- LangGraph saves state at each super-step. If one parallel node fails, the nodes that finished do not run again on resume. Retry policies default to 3 attempts with backoff.
- CrewAI writes a checkpoint per finished task by default, and a restore skips completed tasks. Automatic checkpoint writes are best-effort: a failed write is logged and the run continues.
- OpenAI Agents SDK can save a paused run and resume it. For runs that span long waits, retries or process restarts, OpenAI’s docs point to integrations with Temporal, Dapr, Restate and DBOS.
Cost control
- OpenAI Agents SDK: a run stops after 10 turns by default (
max_turnsin the SDK source), and each run reports requests and input, output, cached and reasoning tokens. - LangGraph: the default recursion limit is 10,007 super-steps (since 1.1.4), which is high for an agent loop, so set your own. LangSmith’s LLM Gateway adds cost controls, rate limits and model fallbacks.
- CrewAI: an agent must give its best answer after 20 iterations by default (
max_iter);max_rpmandmax_execution_timeadd limits. AMP shows usage and token counts.
Whichever you use, set a token budget per task and alert on cost per completed task. Our agent cost guide shows a worked monthly bill.
Vendor lock-in
- LangGraph is model-neutral. The lock-in risk is the hosted layer: if you build on Agent Server’s APIs (assistants, threads, cron jobs), moving off LangSmith takes work. The library alone runs on your own servers with a Postgres checkpointer. Agent Server can also host agents built with CrewAI, AutoGen or the Claude Agent SDK.
- CrewAI has native integrations for OpenAI, Anthropic, Google Gemini, Azure OpenAI and AWS Bedrock. The platform lock-in is AMP, if you rely on it for deployment, approvals and tracing.
- OpenAI Agents SDK pulls hardest toward one vendor: OpenAI is the default model path, traces go to OpenAI, and several tool features need OpenAI’s Responses API. The shutdown of Agent Builder and hosted Evals is a reminder that hosted features can go away; code you own stays.
When to Use None of Them
- The task follows fixed rules. If no step needs judgment, a workflow tool is usually simpler to build and to audit. See our n8n vs Zapier vs Make comparison.
- One agent with a few tools is enough. LangChain’s own docs say that “not every complex task requires” a multi-agent design, and that a single agent with the right tools and prompt “can often achieve similar results.” OpenAI suggests you call its Responses API directly when you want to own the loop and state yourself, or when the workflow is short-lived.
- The agent works on files, commands or code, on Claude models. Anthropic’s Claude Agent SDK gives you “the same tools, agent loop, and context management that power Claude Code,” in Python and TypeScript. It has the same trade-off as the OpenAI SDK: a fast start, tied to one model vendor.
How CognyX Chooses a Framework
Our core stack for agents is LangChain, LangGraph and AG2 (formerly AutoGen). Every build adds human approval steps for risky actions and a full audit log. Two of our case studies name the OpenAI Agents SDK and the Claude Agent SDK as what we would use if we built those projects today. We decide per project, with these questions:
- Does the task need judgment at all? If not, we build an n8n workflow, not an agent.
- Does any step need a person to approve it, or wait hours or days? Then we lean toward LangGraph, with a persistent checkpointer such as Postgres.
- Is the client already on OpenAI, with short runs? Then the OpenAI Agents SDK is the shortest path.
- Is it a file- or code-heavy agent on Claude? Then the Claude Agent SDK.
- Where must data and traces stay? This decides between hosted tracing and a self-hosted stack.
If you are choosing a partner as well as a framework, read how to choose an AI development company. See how we build AI agents and automation.
Not sure which framework fits your workflow?
In a free 30-minute architecture review, we look at your workflow, the approval and audit steps it needs, and which framework fits it, including when an agent is not the right tool. You own the code and IP, and an NDA applies from day one.
Discuss your agent build
30 minutes with our AI engineers: your workflow, the framework that fits it, and the approval and audit steps it needs.
- [email protected]
- Phone
- +91 99748 12447
- Chat on WhatsApp
Frequently Asked Questions
Is LangGraph better than CrewAI?
For production workflows that must pause for approval or recover after a failure, LangGraph is usually the stronger choice: it saves a checkpoint after every step, has built-in interrupts, and supports Python and TypeScript. CrewAI is faster to start when the job fits a team of role-based agents, and its AMP platform adds a visual editor. CrewAI is Python-only, and SSO and role-based access need its Enterprise plan.
Is the OpenAI Agents SDK only for OpenAI models?
No. The SDK supports OpenAI’s Responses and Chat Completions APIs, any provider with an OpenAI-compatible endpoint, and custom model providers. Any-LLM and LiteLLM adapters add more providers, but OpenAI calls them best-effort and beta. Some features, such as tool search and programmatic tool calling, work only with OpenAI Responses models, and traces go to OpenAI by default.
Which AI agent framework is best for production?
No single framework is best. As of November 2026, LangGraph is the safest default when an agent needs approvals, long waits or recovery after a failure, because it checkpoints every step and its API has been stable at version 1.x since October 2025. The OpenAI Agents SDK suits short runs on OpenAI models. CrewAI suits role-based agent teams in Python. Pin versions and add evals whichever you pick.
Is CrewAI free?
Yes. The CrewAI framework is open source under the MIT licence and free to use. Its hosted platform, CrewAI AMP, has a free Basic plan with 50 workflow executions a month and two automations. The Enterprise plan has custom pricing and adds SSO, role-based access control, and deployment in your own VPC or infrastructure. You pay model providers for tokens separately.
Is LangGraph free?
Yes. The LangGraph library is MIT-licensed and free, and you can run it on your own servers with a Postgres or SQLite checkpointer. LangSmith, the paid platform around it, has a free Developer plan (one seat, 5,000 base traces a month) and a Plus plan at $39 per seat a month. Managed Agent Server hosting needs the Plus or Enterprise plan and is billed on compute.
Do LangGraph, CrewAI and the OpenAI Agents SDK support MCP?
Yes. All three can use tools from Model Context Protocol (MCP) servers. The OpenAI Agents SDK supports hosted MCP and local stdio, SSE and Streamable HTTP servers, with approval rules per server. CrewAI connects over stdio, SSE and Streamable HTTP. LangGraph agents use LangChain’s MCPAdapter, which is in beta, and LangSmith Agent Server can expose an agent as an MCP server.
Sources
All pages checked on 13 November 2026. Versions and release dates come from PyPI and npm; stars from GitHub; download counts from pypistats.org and the npm downloads API.
LangGraph and LangSmith
- LangChain, LangGraph overview (read 13 Nov 2026)
- LangChain, What’s new in LangGraph v1 (read 13 Nov 2026)
- LangChain, Persistence (read 13 Nov 2026)
- LangChain, Checkpointers (read 13 Nov 2026)
- LangChain, Checkpointer integrations (read 13 Nov 2026)
- LangChain, Interrupts (read 13 Nov 2026)
- LangChain, Fault tolerance (read 13 Nov 2026)
- LangChain, Graph API overview: recursion limit (read 13 Nov 2026)
- LangChain, LangGraph streaming (read 13 Nov 2026)
- LangChain, Multi-agent patterns (read 13 Nov 2026)
- LangChain, Model Context Protocol (MCP) (read 13 Nov 2026)
- LangChain, LangSmith Agent Server (read 13 Nov 2026)
- LangChain, Self-host standalone servers (read 13 Nov 2026)
- LangChain, LangSmith plans and pricing (read 13 Nov 2026)
- GitHub, langchain-ai/langgraph: 44,888 stars (read 13 Nov 2026)
- GitHub, langchain-ai/langgraphjs: 3,415 stars (read 13 Nov 2026)
- PyPI, langgraph 1.2.21 (released 12 Nov 2026)
- PyPI, langchain 1.5.0: depends on langgraph (read 13 Nov 2026)
- npm, @langchain/langgraph 1.7.4 (released 12 Nov 2026)
CrewAI
- CrewAI, Introduction (read 13 Nov 2026)
- GitHub, crewAIInc/crewAI README: 60,835 stars (read 13 Nov 2026)
- CrewAI, Flows (read 13 Nov 2026)
- CrewAI, Processes (read 13 Nov 2026)
- CrewAI, Checkpointing (read 13 Nov 2026)
- CrewAI, Tasks: task guardrails (read 13 Nov 2026)
- CrewAI, Agents: max_iter and max_rpm (read 13 Nov 2026)
- CrewAI, Human Feedback in Flows (read 13 Nov 2026)
- CrewAI, Human-in-the-Loop (HITL) Workflows (read 13 Nov 2026)
- CrewAI, Using CrewAI Without LiteLLM (read 13 Nov 2026)
- CrewAI, MCP Servers as Tools in CrewAI (read 13 Nov 2026)
- CrewAI, Streaming (read 13 Nov 2026)
- CrewAI, CrewAI Tracing (read 13 Nov 2026)
- CrewAI, Testing (read 13 Nov 2026)
- CrewAI, CrewAI AMP introduction (read 13 Nov 2026)
- CrewAI, Pricing (read 13 Nov 2026)
- PyPI, crewai 1.15.41 (released 12 Nov 2026)
OpenAI Agents SDK
- OpenAI, Agents SDK overview (read 13 Nov 2026)
- OpenAI, Agents SDK: Models (read 13 Nov 2026)
- OpenAI, Agents SDK: Agent orchestration (read 13 Nov 2026)
- OpenAI, Agents SDK: Human-in-the-loop (read 13 Nov 2026)
- OpenAI, Agents SDK: Running agents (read 13 Nov 2026)
- OpenAI, Agents SDK: Sessions (read 13 Nov 2026)
- OpenAI, Agents SDK: Guardrails (read 13 Nov 2026)
- OpenAI, Agents SDK: Tracing (read 13 Nov 2026)
- OpenAI, Agents SDK: Streaming (read 13 Nov 2026)
- OpenAI, Agents SDK: Model Context Protocol (read 13 Nov 2026)
- OpenAI, Agents SDK: Usage (read 13 Nov 2026)
- OpenAI, Agents SDK: Release process/changelog (read 13 Nov 2026)
- GitHub, openai-agents-python run_config.py: DEFAULT_MAX_TURNS (read 13 Nov 2026)
- OpenAI, Agents: compare runtime options (read 13 Nov 2026)
- OpenAI, Evaluate agent workflows (read 13 Nov 2026)
- OpenAI, Deprecations: Evals and Agent Builder (announced 3 Jun 2026, read 13 Nov 2026)
- OpenAI, API pricing: tools (read 13 Nov 2026)
- GitHub, openai/openai-agents-python: 30,648 stars (read 13 Nov 2026)
- GitHub, openai/openai-agents-js: 4,012 stars (read 13 Nov 2026)
- PyPI, openai-agents 0.24.0 (released 15 Oct 2026)
- npm, @openai/agents 0.22.0 (released 12 Nov 2026)
Download statistics and other SDKs
- pypistats.org, langgraph downloads, last 30 days (read 13 Nov 2026)
- pypistats.org, crewai downloads, last 30 days (read 13 Nov 2026)
- pypistats.org, openai-agents downloads, last 30 days (read 13 Nov 2026)
- npm, @langchain/langgraph downloads, 13 Oct – 11 Nov 2026
- npm, @openai/agents downloads, 13 Oct – 11 Nov 2026
- Anthropic, Claude Agent SDK overview (read 13 Nov 2026)
Published by CognyX AI, an AI development and consulting company in Ahmedabad, India. CognyX builds agents with several of the frameworks compared here. Versions, prices and download counts are as read on 13 November 2026 and change often; check the linked sources before you decide.
Related Guides
Price ranges by project type, hourly rates, and what drives the cost of an AI build.
AI Agent Development Cost (2026)Build cost by agent type, monthly running costs, India vs US rates, and a worked example.
How to Choose an AI Development CompanyA 15-point evaluation checklist and scorecard for shortlisting AI vendors.
Top AI Development Companies in India (2026)Indian AI development firms ranked on AI focus, production work, reviews, and scale.
Top AI Companies in Ahmedabad (2026)AI development firms in Ahmedabad ranked on AI focus, production work, rates, and reviews.
Top AI Companies in Gujarat (2026)AI service companies across Ahmedabad, Gandhinagar, Surat, Vadodara, and Rajkot.
n8n vs Zapier vs Make (2026)Head-to-head comparison of the three automation platforms for AI workflows.