LangGraph models an agent as a graph of nodes over a typed state object, and persists that state through a pluggable checkpointer (in-memory, SQLite, Postgres) so a run can be paused, resumed after a process restart, forked, or rewound to an earlier step. Interrupts are a first-class primitive, which is what makes human-in-the-loop approval workable rather than bolted on. LangChain's own agent abstractions are now built on top of it, and Deep Agents is a harness layered above that. The library is MIT and free; hosted deployment and tracing run through LangSmith, where the Plus tier is $39/seat/month with 10k base traces and compute metered at $1.50/LCU.
| Language | Python 1.2.x, JavaScript/TypeScript 1.4.x |
|---|
| Abstraction level | Low — explicit state graph |
|---|
| Durability / state | Checkpointers (memory/SQLite/Postgres), resume, fork, time travel |
|---|
| Streaming | Token, node-update and custom event streams |
|---|
| Observability hooks | LangSmith native; OpenTelemetry export |
|---|
| GitHub stars | 41.1k (Python) + 3.3k (JS) |
|---|
Watch out: The graph API is genuinely more code than a plain tool loop, and for a request-scoped agent that finishes in seconds the checkpointing machinery is pure overhead. Debugging is materially worse without LangSmith, which is the commercial hook. The surrounding ecosystem renames things often — LangGraph Platform deployments now live under LangSmith Cloud, with organisations on old pricing grandfathered only until October 1, 2026 — so docs and blog posts age fast.
Library $0 (MIT). LangSmith: Developer $0/seat (1 seat, 5k base traces/mo), Plus $39/seat/mo (10k base traces, 1 free small serverless deployment), Enterprise custom; usage metered at $1.50/LCU compute and $1.00/LSU storage.
· open source
LangChain 1.x threw out most of the 0.x chain zoo and reduced to a single agent constructor, create_agent, described in its own docs as "a minimal, highly configurable harness" that runs on LangGraph and therefore inherits durable execution and persistence. Its enduring value is the provider abstraction: hundreds of model, vector store and tool integrations behind one interface, so swapping Claude for Gemini is a string change. Python 1.4.0 shipped 2026-09-03 and the JS package tracks separately at 1.5.x. Free and MIT; you pay only if you adopt LangSmith.
| Language | Python 1.4.0, JavaScript/TypeScript 1.5.x |
|---|
| Abstraction level | Mid — configurable agent harness with middleware |
|---|
| Durability / state | Inherited from LangGraph checkpointers |
|---|
| Streaming | Yes, token and event level |
|---|
| Observability hooks | LangSmith native; callbacks; OpenTelemetry |
|---|
| GitHub stars | 145.7k |
|---|
Watch out: The 0.x-to-1.x migration invalidated an enormous amount of tutorial content and Stack Overflow answers, so search results actively mislead. The abstraction tax is real: for a single model and three tools you are wrapping a simple API call in several layers, and debugging pushes you down into LangGraph anyway. Wrong choice if you want to read the whole stack you depend on.
Library $0 (MIT). Optional LangSmith: $0 Developer, $39/seat/mo Plus, Enterprise custom.
· open source
Deep Agents is LangChain's answer to the Claude Code-style harness: create_deep_agent gives you an agent pre-tuned for long-horizon work with todo planning, a pluggable filesystem (local, sandboxed or remote), subagents with isolated context windows, automatic thread summarisation and tool-output offloading to disk, plus human approval gates. It is model-agnostic across any tool-calling LLM and builds on LangGraph, so it gets streaming, persistence and checkpointing for free. There is a matching deepagents.js and a terminal coding agent, Deep Agents Code. MIT and free.
| Language | Python and JavaScript/TypeScript |
|---|
| Abstraction level | High — batteries-included harness |
|---|
| Durability / state | LangGraph checkpointing plus pluggable store backends |
|---|
| Streaming | Yes, via LangGraph |
|---|
| Observability hooks | LangSmith tracing and evals |
|---|
| GitHub stars | 29.0k |
|---|
Watch out: You inherit someone else's system prompt and control-flow opinions; if your task is short or highly structured, the planning and filesystem scaffolding just burns tokens. It is young relative to its star count, the API is still moving, and every debugging session eventually lands you in LangGraph internals. Not a fit if you need deterministic, auditable step order.
$0 (MIT). Optional LangSmith tracing/deployment at $0–$39/seat/mo.
· open source
LlamaIndex began as a RAG indexing library and now positions itself as a framework for agents over your data, with Workflows — an event-driven, step-based execution model where steps emit and consume typed Pydantic events — as the modern orchestration layer. Workflows ship inside llama-index-core and also standalone as llama-index-workflows, and support checkpointing a run's context so it can resume after a restart, plus streaming, concurrency and human-in-the-loop. The framework (0.14.x, MIT) is free; the revenue product is LlamaCloud, whose LlamaParse document parser sells credits at 1,000 credits = $1.25, with 10k credits free monthly and paid plans at $50 and $500/month.
| Language | Python 0.14.24; TypeScript port available |
|---|
| Abstraction level | Mid — event-driven workflow steps plus agent classes |
|---|
| Durability / state | Workflow context checkpoint and resume |
|---|
| Streaming | Yes, event streaming during runs |
|---|
| Observability hooks | Instrumentation callbacks; OpenTelemetry and third-party tracers |
|---|
| GitHub stars | 52.0k |
|---|
Watch out: Event-driven workflows are harder to reason about than a linear graph when the event fan-out grows, and the older index/query-engine abstractions still linger in docs alongside the new agent APIs, so it is easy to follow a stale pattern. The package sprawl (dozens of llama-index-* integration packages) creates real dependency-resolution pain. If you are not doing document work, its RAG heritage buys you nothing over a general agent framework.
Framework $0 (MIT). LlamaCloud/LlamaParse: Free $0 (10K credits/mo), Starter $50/mo (40K credits, PAYG to $500/mo), Pro $500/mo (400K credits, PAYG to $5,000/mo), Enterprise custom; 1,000 credits = $1.25.
· open source
AI SDK 7 splits into three surfaces: Core (unified generateText/streamText, structured output, embeddings, reranking, MCP), UI (framework-agnostic hooks for chat and generative interfaces), and Harnesses, where HarnessAgent wraps established external harnesses such as Claude Code, Codex or Pi and streams their output into the same result and UI primitives. The agent primitive is ToolLoopAgent, which owns the loop, stopping conditions and runtime context, with policy-based tool approvals layered on. It is Apache-2.0 and free, and runs anywhere Node does — you do not have to deploy on Vercel.
| Language | TypeScript/JavaScript (ai 7.0.93) |
|---|
| Abstraction level | Low-to-mid — unified model API plus ToolLoopAgent |
|---|
| Durability / state | None built in; delegate to Workflow/queue |
|---|
| Streaming | Best-in-class; text, tool and UI-part streaming |
|---|
| Observability hooks | OpenTelemetry telemetry option; onStepFinish callbacks |
|---|
| GitHub stars | 26.6k |
|---|
Watch out: Durability is not in the box — there is no checkpointer, so long-running or resumable agents need Vercel Workflow, a queue, or another framework underneath. The UI hooks are strongest in the Next.js/React path and thinner elsewhere. Version churn is aggressive (v7 arrived not long after v5), and each major has broken message and stream shapes. Python teams get nothing here.
$0 (Apache-2.0). Vercel hosting and AI Gateway token markup are separate products; those rates were not verified here (unknown).
· open source
The Claude Agent SDK exposes the same agent loop, built-in tools (file read/write/edit, shell, web search) and context management that power Claude Code, as a library running in your own process. It provides hooks at lifecycle points, subagents for context isolation, MCP servers, a permission system for gating tool calls, resumable and forkable sessions, and loading of .claude/ skills, commands and memory. It was renamed from the Claude Code SDK and ships a migration guide. Python and TypeScript only; other languages must shell out to the CLI with -p and --output-format json.
| Language | Python 0.2.152, TypeScript 0.3.263 |
|---|
| Abstraction level | High — opinionated harness with built-in tools |
|---|
| Durability / state | Sessions: resume and fork; automatic context compaction |
|---|
| Streaming | Yes, streaming message events |
|---|
| Observability hooks | Lifecycle hooks; permission callbacks; OTel via host app |
|---|
| GitHub stars | 8.0k (Python) + 1.7k (TypeScript) |
|---|
Watch out: It is Claude-only — there is no provider abstraction, so you cannot swap in GPT or Gemini. Anthropic restricts third-party developers from offering claude.ai login or subscription rate limits to their users, so you must run on API keys and eat the token bill, and branding rules forbid presenting your product as Claude Code. Versioning is pre-1.0 and moves daily (Python 0.2.152, TypeScript 0.3.263), so pin exactly. Filesystem and shell tools mean sandboxing is your responsibility.
SDK $0; you pay Claude API tokens — Claude Opus 5 $5/MTok in, $25/MTok out; Sonnet 5 $2/$10; Haiku 4.5 $1/$5. Web search $10 per 1,000 searches. Cache hits 0.1x input.
· open source
The production successor to the Swarm experiment, this SDK keeps a deliberately small primitive set: Agents (instructions plus tools), Handoffs (one agent delegating to another), Guardrails (input/output validation), Sessions (memory across turns) and Tracing (runs visualised in the OpenAI dashboard). It also covers realtime voice agents with automatic interruption detection and sandbox agents with resumable isolated workspaces. Despite the name it is not OpenAI-only: LiteLLM and any-llm adapters reach other providers. Python 0.22.0 and a TypeScript port at 0.17.0, both MIT and free.
| Language | Python 0.22.0, TypeScript 0.17.0 |
|---|
| Abstraction level | Low — small primitive set over the raw API |
|---|
| Durability / state | Sessions for conversation memory; resumable sandbox sessions; no run checkpointing |
|---|
| Streaming | Yes, including realtime audio |
|---|
| Observability hooks | Built-in tracing with third-party trace processors |
|---|
| GitHub stars | 29.2k (Python) + 3.8k (JS) |
|---|
Watch out: Still pre-1.0 with breaking changes between minors. Handoff-based multi-agent routing is easy to write and hard to constrain — it can loop or hand off unexpectedly, and guardrails are your only brake. There is no durable execution: sessions persist conversation, not in-flight tool state, so a crash mid-run loses the run. Tracing is best inside OpenAI's dashboard, which is awkward if your models are elsewhere.
SDK $0 (MIT); you pay OpenAI (or your chosen provider) per token. Current OpenAI per-model rates were not verified in this pass (unknown).
· open source
CrewAI's model is teams of role-playing agents (a researcher, a writer, a reviewer) that delegate tasks to each other, with Flows added as the deterministic backbone that handles state management, event-driven execution and control flow around those crews. The framework reached 1.x and now ships releases several times a week (1.15.20 on 2026-09-04). The hosted platform adds a visual editor, an AI copilot and GitHub integration, with a free tier capped at 50 workflow executions per month and an Enterprise tier adding SSO, RBAC, workload identity and PII redaction.
| Language | Python 1.15.20 |
|---|
| Abstraction level | High — role/task/crew plus Flow control |
|---|
| Durability / state | Flow state management; hosted platform persistence |
|---|
| Streaming | Yes, via underlying model clients |
|---|
| Observability hooks | Event listeners; integrations with third-party tracers |
|---|
| GitHub stars | 58.1k |
|---|
Watch out: Role-playing crews are the hardest pattern in this category to debug and cost-control: agents chat to each other, token spend balloons, and failures show up as vague delegation loops rather than stack traces. The 0.x-to-1.x transition broke APIs and much of the tutorial corpus. Enterprise pricing is not public, so you cannot budget without a sales call. Prefer explicit Flows over free-form crews for anything with an SLA.
Framework $0 (MIT). Hosted platform: Basic free with 50 workflow executions/month; Enterprise custom pricing (no public dollar figures, 45-day onboarding stated).
· open source
DSPy replaces prompt strings with Signatures (typed input/output task declarations) and Modules (execution strategies such as Predict, ChainOfThought and ReAct), then uses Optimizers to search for the prompts and few-shot demonstrations that maximise a metric you define. Current optimizers include GEPA (reflective prompt evolution), MIPROv2, SIMBA and BootstrapFewShot. Version 3.3.1 landed 2026-08-21 with faster GEPA and MCP v2 compatibility. It is maintained by Stanford NLP with 450+ contributors and is used in production at Shopify, Databricks, Replit and JetBlue.
| Language | Python 3.3.1 |
|---|
| Abstraction level | High — declarative signatures, prompts compiled not written |
|---|
| Durability / state | None; compiled programs saved to disk |
|---|
| Streaming | Supported for module outputs |
|---|
| Observability hooks | Callbacks; MLflow and OpenTelemetry integrations |
|---|
| GitHub stars | 37.8k |
|---|
Watch out: It is not really an agent framework and does not compete with LangGraph or CrewAI on orchestration, durability or streaming; teams that adopt it expecting that are disappointed. It is useless without an eval set and a metric, which most teams do not have. Optimizer runs can consume a surprising number of tokens, and the resulting prompts are machine-generated and awkward to review or hand-edit. The abstraction leaks whenever you need precise control over the exact prompt sent.
$0 (MIT). Optimizer runs consume model tokens billed by your provider — cost depends entirely on trainset size and optimizer choice.
· open source
Mastra is the most complete TypeScript-native agent framework: agents with tools and model routing, workflows built from typed steps that suspend and resume from checkpoints (restart() and restartAllActiveWorkflowRuns() recover active runs), nested workflow composition, memory, RAG, evals and MCP. Studio gives real-time run monitoring, a graph view and time-travel debugging where you replay individual steps. The core is Apache-2.0 and self-hostable anywhere; Mastra Cloud is free at the Starter tier (100K observability events, 24 CPU hours) and $250/month for Teams.
| Language | TypeScript (@mastra/core 1.64.0), Node 22.18+ |
|---|
| Abstraction level | Mid — agents plus typed workflow steps |
|---|
| Durability / state | Suspend/resume snapshots, restart of active runs, pluggable storage |
|---|
| Streaming | Yes — .stream() with fullStream events and resumeStream() |
|---|
| Observability hooks | Studio tracing, time-travel replay, OpenTelemetry |
|---|
| GitHub stars | 27.7k |
|---|
Watch out: Version numbers move extremely fast (@mastra/core is at 1.64.0 with releases most weeks), so upgrades demand attention. It is a younger and smaller ecosystem than the Python frameworks — fewer integrations, fewer people who have hit your bug. Cloud pricing has many meters (events, CPU hours, storage, egress, a 5.5% gateway markup) that are hard to forecast, and the $100/project persistent server charge surprises people. Not the right pick if your team is Python-first.
Self-hosted $0 (Apache-2.0). Cloud: Starter $0 (100K events then $10/100K, 24 CPU-hrs then $0.35/hr, 15-day retention), Teams $250/mo (1M events then $8/100K, 250 CPU-hrs then $0.25/hr, 6-month retention), Enterprise custom. Add-ons: gateway tokens at market +5.5%, egress $0.10/GB, DB storage $0.75–$1/GB-month, persistent server $100/project.
· open source
Pydantic AI describes itself as "the Python AI SDK: a typed, extensible agent loop with every model a string swap away", and its differentiator is type safety end to end — structured outputs, typed dependency injection and typed tools, so your IDE and type checker know what an agent returns. It has first-party durable-execution integrations with Temporal, DBOS, Prefect and Restate, so agents survive restarts and run for days without you inventing a checkpointer. Version 2.40.0 shipped 2026-09-05; it also brings Pydantic Graph for typed workflows, Pydantic Evals for pytest-style behaviour tests, AG-UI and Vercel AI event streams, and realtime speech. It is OpenTelemetry-native, so Logfire is recommended but any OTLP backend works.
| Language | Python 2.40.0 |
|---|
| Abstraction level | Low-to-mid — typed agent loop plus optional graphs |
|---|
| Durability / state | First-party Temporal, DBOS, Prefect, Restate integrations |
|---|
| Streaming | Yes, including structured-output and realtime speech streaming |
|---|
| Observability hooks | OpenTelemetry-native; Logfire or any OTLP backend |
|---|
| GitHub stars | 19.7k |
|---|
Watch out: Getting real durability means running Temporal, DBOS, Prefect or Restate — that is meaningful operational weight that the framework does not remove. The typing discipline slows you down on throwaway prototypes and fights you when a model returns something off-schema. It is smaller than LangChain in integrations, and the version number moves weekly (2.x with releases most days), so pin. Not a fit if your team resists type annotations.
Library $0 (MIT). Optional Logfire: Personal $0 (10M records/mo, 1 seat, 30-day retention), Team $49/mo (10M records + $20 credit, then $2/M, 5 seats), Growth $249/mo (unlimited seats, up to 90-day retention), Enterprise custom.
· open source
Agno pairs an Apache-2.0 Python SDK — agents with memory, knowledge, guardrails, sessions and 100+ integrations, composed into teams and workflows — with AgentOS, a runtime that serves your agent platform as a stateless, secure API and MCP server you deploy yourself (Docker, Kubernetes, AWS, GCP, Azure, Fly, Railway, Render, Modal). Version 3.0.6 landed 2026-09-04. The SDK and AgentOS are free, including chat, sessions, traces, studio, memory, knowledge, metrics, evaluations, approvals and the scheduler; the paid Pro plan at $150/month buys a live AgentOS connection, three seats and RBAC.
| Language | Python 3.0.6 |
|---|
| Abstraction level | Mid-to-high — agents, teams, workflows, plus a runtime |
|---|
| Durability / state | Sessions and memory persisted to pluggable DB; stateless API layer |
|---|
| Streaming | Yes |
|---|
| Observability hooks | Built-in traces, metrics and evals in AgentOS; OTel export |
|---|
| GitHub stars | 42.1k |
|---|
Watch out: Agno rewrote its API for 3.0, so 2.x material is stale, and the earlier marketing leaned heavily on microsecond instantiation benchmarks that rarely matter next to model latency. Because AgentOS is stateless by design, durability comes from whatever database you attach — there is no built-in workflow engine that survives a mid-tool-call crash. The add-on pricing ($95 per extra connection, $300 for SSO) escalates quickly for a small team. Python only.
SDK and AgentOS $0 (Apache-2.0). Pro $150/mo (1 live AgentOS connection, 3 seats, RBAC, email support); extra seats $30/mo, extra connections $95/mo, SAML SSO $300/mo; Enterprise custom.
· open source
Microsoft Agent Framework is, in Microsoft's own words, "the direct successor" to both Semantic Kernel and AutoGen, built by the same teams: it takes AutoGen's simple single- and multi-agent abstractions and Semantic Kernel's enterprise features (session-based state, type safety, middleware, telemetry) and adds explicit graph-based and functional workflows. It also ships a Harness Agent — an opinionated long-task agent with planning and todo tracking, context compaction, file access and memory, don't-ask-again tool approval and observability. Python is at agent-framework 1.17.0 (2026-09-03); .NET packages are still published with --prerelease; the Go SDK is public preview and lacks declarative agents, RAG, CodeAct and functional workflows.
| Language | .NET (prerelease), Python 1.17.0, Go (public preview) |
|---|
| Abstraction level | Mid — agents, graph/functional workflows, plus a Harness Agent |
|---|
| Durability / state | Agent session state management for long-running and HITL scenarios |
|---|
| Streaming | Yes, streaming and non-streaming run APIs |
|---|
| Observability hooks | Middleware for intercepting agent actions; OpenTelemetry telemetry |
|---|
| GitHub stars | 13.3k |
|---|
Watch out: Language support is uneven — Go is preview with named feature gaps and the .NET packages are still prerelease, so "GA" depends on which SDK you pick. It is a young codebase carrying two migration guides, which means churn. Docs and defaults tilt hard toward Microsoft Foundry and Azure identity; using it with Anthropic or Ollama works but is the less-travelled path, and Microsoft explicitly disclaims responsibility for third-party systems you connect. Overkill outside the Microsoft ecosystem.
$0 (MIT). Model inference billed by whichever provider you use; Microsoft Foundry and Azure OpenAI charges are separate.
· open source
Semantic Kernel (C#-first, with Python and Java ports) and AutoGen (Python, conversation-driven multi-agent) were Microsoft's two agent frameworks before it merged them. Microsoft's documentation now states plainly that Agent Framework "is the next generation of both Semantic Kernel and AutoGen" and publishes migration guides from each. Semantic Kernel still receives releases (1.44.1, 2026-08-06), but AutoGen has effectively stopped: autogen-agentchat's last PyPI release was 0.7.5 in September 2025 and the repository's last push was April 2026. Both remain MIT and free.
| Language | Semantic Kernel: C# 1.44.1, Python, Java. AutoGen: Python 0.7.5 |
|---|
| Abstraction level | SK: mid (kernel, plugins, filters). AutoGen: high (conversational multi-agent) |
|---|
| Durability / state | SK: session state and filters. AutoGen: in-memory conversation only |
|---|
| Streaming | Yes in both |
|---|
| Observability hooks | SK filters and OpenTelemetry; AutoGen basic logging |
|---|
| GitHub stars | AutoGen 60.8k; Semantic Kernel 28.5k |
|---|
Watch out: Do not start new work here. AutoGen has had no PyPI release in roughly a year and no repository activity since April 2026, so treat it as frozen. Semantic Kernel is still patched but is explicitly positioned as the previous generation, meaning new capabilities land in Agent Framework instead. Community answers and plugin ecosystems for both will keep thinning.
$0 (MIT for both). Inference billed separately by your model provider.
· open source · deprecated
ADK is the broadest-language framework in this category, shipping for Python (google-adk 2.8.0), TypeScript (@google/adk, 2.0 GA with graph workflows), Go (v1.x and v2.x), Java and Kotlin. It provides sequential, parallel and loop workflow agents, structured context management with automatic filtering, summarisation and lazy loading, sessions and memory with rewind and migration, an evaluation harness with custom metrics and user simulation, the A2A protocol for agent-to-agent communication, and bidi-streaming live/voice agents. It is model-agnostic — Gemini, Gemma, Claude and OpenAI are built in — and deploys in one command to Vertex AI Agent Engine, Cloud Run or GKE, or to your own containers.
| Language | Python 2.8.0, TypeScript 2.0, Go v1/v2, Java, Kotlin |
|---|
| Abstraction level | Mid — workflow agents and graph workflows |
|---|
| Durability / state | Sessions and memory with rewind and migration; managed on Agent Engine |
|---|
| Streaming | Yes, including bidi-streaming voice |
|---|
| Observability hooks | Callbacks, built-in evaluation, Cloud Trace and OpenTelemetry |
|---|
| GitHub stars | 21.4k (Python) + 1.7k (Java) |
|---|
Watch out: Feature parity across five languages is not guaranteed — Python leads and the others follow, and both Go and TypeScript recently jumped major versions, so cross-language teams should verify per-language support before committing. The deployment story is best on Google Cloud; running it elsewhere works but loses the one-command path and the managed session/memory services. Agent Engine costs are not visible from the ADK docs, which makes budgeting a separate exercise. A2A is still an emerging protocol with limited real interop.
ADK itself $0 (Apache-2.0). Vertex AI Agent Engine runtime, session and memory-bank rates are billed separately by Google Cloud and were not verified in this pass (unknown).
· open source
Haystack is deepset's Python orchestration framework, built around explicitly wired pipelines of typed components — retrievers, routers, memory, tools, evaluators and generators — which makes data flow visible and testable in a way free-form agent frameworks are not. Version 3.0 shipped in 2026 (current release 3.1.1, 2026-09-03) and extends the pipeline model to agents and multimodal applications. Hayhooks deploys any pipeline as a REST API or MCP server. The framework is Apache-2.0 and free; deepset sells Haystack Enterprise Starter (templates and deployment support) and the Haystack Enterprise Platform, both quoted by sales.
| Language | Python 3.1.1 |
|---|
| Abstraction level | Mid — explicitly wired component pipelines |
|---|
| Durability / state | Pipeline state and memory components; no run checkpointing |
|---|
| Streaming | Yes, streaming callbacks on generators |
|---|
| Observability hooks | Tracing and logging integrations, built-in evaluators |
|---|
| GitHub stars | 26.4k |
|---|
Watch out: Its centre of gravity is still retrieval — for open-ended tool-using agents, LangGraph or Pydantic AI give you more. Wiring components by input/output name is verbose and errors surface at pipeline-connect time rather than in your editor. Haystack 3.0 is a second major rewrite (after 1.x to 2.x), so a lot of published material targets a version you are not running. Python only, and enterprise pricing requires a sales conversation.
Framework $0 (Apache-2.0). deepset Haystack Enterprise Starter and Enterprise Platform are custom-priced with no public figures (unknown).
· open source
smolagents keeps its entire agent logic in roughly a thousand lines, and its distinctive idea is CodeAgent: instead of emitting JSON tool calls, the model writes Python that calls tools directly, which gives you loops, conditionals and function nesting for free. Sandboxed execution is supported via Modal, Blaxel, E2B or Docker, and a conventional ToolCallingAgent is available where JSON tool calling is preferred. It is model-agnostic (Hub inference providers, OpenAI, Anthropic, LiteLLM, local Transformers or Ollama), modality-agnostic, and can pull tools from MCP servers, LangChain or Hub Spaces. Apache-2.0 and free.
| Language | Python 1.26.0 |
|---|
| Abstraction level | Very low — minimal abstractions over raw code |
|---|
| Durability / state | None; in-memory run only |
|---|
| Streaming | Yes, step-level streaming |
|---|
| Observability hooks | OpenTelemetry instrumentation, Hub-based sharing |
|---|
| GitHub stars | 29.2k |
|---|
Watch out: Release cadence has slowed noticeably — v1.26.0 landed 2026-05-29 and the repository's last push was August 2026, well behind the weekly cadence of LangChain, Mastra or Pydantic AI — so weigh that before building a product on it. Code-as-action means you are executing model-written Python: without a Modal, E2B, Blaxel or Docker sandbox this is a remote code execution hazard, and sandboxing adds latency and a third-party bill. There is no durable execution, no checkpointing and only minimal state management, so it is the wrong choice for long-running production agents.
$0 (Apache-2.0). Sandbox providers (Modal, E2B, Blaxel) and model inference are billed separately.
· open source
Strands Agents is AWS's open-source SDK for production agents, giving you context management, execution limits and observability before you write any config. It ships conversation managers (sliding window, summarising), MCP tool integration, interrupt and approval workflows for sensitive actions, a hook system for intercepting agent decisions, multi-agent patterns including agent-as-tool and swarms, and guardrail integration including Bedrock Guardrails. It is explicitly any-model, any-cloud rather than Bedrock-only. Python is at strands-agents 1.54.0 and TypeScript at @strands-agents/sdk 1.16.0; the primary repository now lives at strands-agents/harness-sdk, reflecting its repositioning as an agent harness.
| Language | Python 1.54.0, TypeScript 1.16.0 |
|---|
| Abstraction level | Mid-to-high — configurable agent harness |
|---|
| Durability / state | Session and conversation managers; interrupt/approval resume |
|---|
| Streaming | Yes, async streaming of events |
|---|
| Observability hooks | Hook system plus OpenTelemetry tracing on by default |
|---|
| GitHub stars | 7.2k |
|---|
Watch out: Despite the model-agnostic claim, the documentation, examples and guardrail integrations lean toward Bedrock, so the non-AWS path is less well trodden. The repository rename to harness-sdk means older links, blog posts and imports can point at the wrong place. Durability is conversation-level, not run-level — there is no workflow checkpointer that survives a crash mid-tool-call. Smaller community than the star leaders in this category, so you will hit undocumented edges.
$0 (Apache-2.0). Model inference and any AWS services (Bedrock, Guardrails, hosting) billed separately at their own rates.
· open source
The Cloudflare Agents SDK makes each agent instance a Durable Object with its own durable identity and embedded SQLite database, so state lives with the agent rather than in an external store you have to wire up. It provides WebSocket connections for real-time interaction, scheduling for work that must happen later, recoverable execution, and access to browser automation, sandboxed code execution, AI Search, MCP tools and payments. You can use its own opinionated harness or drive a custom loop on the runtime. TypeScript only (agents 0.22.0, MIT), and it runs only on Cloudflare Workers.
| Language | TypeScript (agents 0.22.0) |
|---|
| Abstraction level | Mid — runtime primitives plus an optional harness |
|---|
| Durability / state | Durable Objects with embedded SQLite; alarms and recoverable execution |
|---|
| Streaming | Yes, WebSockets and SSE |
|---|
| Observability hooks | Workers observability and logs; OpenTelemetry via Workers |
|---|
| GitHub stars | 5.5k |
|---|
Watch out: It is not portable: the programming model is Durable Objects, so you cannot lift it onto AWS or your own servers without a rewrite, which is the deepest lock-in of anything in this chapter. TypeScript only. Workers constraints apply — CPU-time limits, no arbitrary native binaries, and a bundling model that rules out many Python-adjacent libraries. The SDK is pre-1.0 (0.22.0) and the surrounding product names change often. Durable Objects billing has several meters (requests, GB-s duration, rows read/written) that are easy to underestimate at scale.
SDK $0 (MIT). Runtime: Workers Free 100k req/day, 10ms CPU per invocation; Workers Paid $5/mo including 10M requests then $0.30/M and 30M CPU-ms then $0.02/M. Durable Objects: 1M requests/mo then $0.15/M, 400,000 GB-s then $12.50/M GB-s, 5 GB-month SQLite then $0.20/GB-month.
· open source
Letta, which grew out of the MemGPT research on virtual context management, treats persistent memory as the primary abstraction rather than an add-on: agents own editable memory blocks that they revise over time, and everything is served through a REST API so agents are addressable, long-lived objects rather than objects in your process. It ships a desktop app, CLI, web UI and an Agent SDK, with connectors for Slack, Discord, Telegram and GitHub. Self-hosting is Apache-2.0 and free; Letta Cloud is $0 for up to 3 agents, $20/month Pro for 20 agents, and an API plan at $20/month base plus $0.10 per active agent per month and $0.00015/second of tool execution.
| Language | Python server 0.16.8; Python/TypeScript client SDKs |
|---|
| Abstraction level | High — stateful agent service with managed memory |
|---|
| Durability / state | Persistent memory blocks and agent state in a database, server-side |
|---|
| Streaming | Yes, streaming responses over the API |
|---|
| Observability hooks | Server-side traces in the Letta UI; OTel export |
|---|
| GitHub stars | 24.6k |
|---|
Watch out: Release cadence on the open-source server has slowed sharply — 0.16.8 shipped 2026-05-14, nearly four months before this writing — while the company's public energy has moved to Cloud and Letta Code, so self-hosters should check activity before committing. The server-plus-database architecture is heavier than importing a library, and it is an opinionated way to build: if you just want a tool loop inside your app, this is far more machinery than you need. Memory-block editing consumes tokens on every turn, so per-agent cost is higher than a stateless agent.
Self-hosted $0 (Apache-2.0). Cloud: Free $0 (3 stateful agents, BYO API keys), Pro $20/mo (20 agents), API $20/mo base + $0.10/active agent/mo + $0.00015/sec tool execution, Teams Pro $20/seat/mo, Enterprise custom.
· open source