Letta has the cheapest paid entry plan, at $20 a month, and 7 of the 8 frameworks have a free plan. Claude Agent SDK is metered on usage.
The price jumps with scale. LlamaIndex goes from Starter at $50 a month to Pro at $500 a month, and LangGraph charges $39 a seat a month on Plus, with metered usage on top at $1.50 and $1 a unit.
On 29 October 2026 we listed 201 agents: 16 of them under Agent frameworks and 105 with a free plan.
Free plans are the norm, with 7 of the 8 frameworks offering one.
Letta has the cheapest paid entry plan, at $20 a month, for Pro with up to 20 agents.
LlamaIndex starts paid use at $50 a month on Starter and jumps to $500 a month on Pro, above a free tier of 10,000 credits a month.
LangGraph bills by the seat, at $39 a seat a month on Plus, and its usage units can take a small setup from tens of dollars into the low hundreds a month before model API costs.
LiveKit Agents has a $0 Build tier with 1,000 agent-session minutes, and its $2.50 monthly inference credit covers about 50 minutes of LiveKit-hosted model usage.
Free plans are standard, with 7 of the 8 frameworks offering one, while Claude Agent SDK is metered on usage.
Letta has the cheapest paid entry plan at $20 a month, for up to 20 agents, against a median of $50 a month.
LlamaIndex’s price jumps from Starter at $50 a month to Pro at $500 a month, with a 1.5x credit multiplier in Europe and a free tier capped at 5 indexes of 50 files each.
LangGraph’s bill grows with headcount and usage, at $39 a seat a month on Plus with unlimited seats, plus usage units that take a small setup from tens of dollars into the low hundreds a month.
LiveKit Agents’ free start is generous on minutes and thin on inference, with 1,000 agent-session minutes on the $0 Build tier and a $2.50 monthly inference credit that covers about 50 minutes of LiveKit-hosted model usage, while Letta’s Free tier runs 3 stateful agents on your own keys.
Best for document-heavy agents on a credit budget: LlamaIndex pairs its open-source framework with metered document parsing, and its free tier carries 10,000 credits a month before Starter at $50 a month.
PriceFree, then $50 a month
The Free plan gives 10,000 credits a month with self-serve signup, capped at 5 indexes of 50 files each. Starter is $50 a month, Pro is $500 a month and Enterprise is custom. Free, Starter and Pro each include 100 users, so the bill follows credits rather than headcount.
Credits vary by parse tier and by region, with a 1.5x multiplier in Europe. Unused credits do not roll over, and bonus credits vanish on downgrade. Calling the hosted API with your own model key still bills 1 credit per page.
What it does well
Auto Mode routes each page to the right parse tier and saves up to 80 percent of credits.
A hosted MCP server exposes parse, classify, extract, split and index tools to any MCP client.
LlamaCloud is SOC 2 Type 2 certified and compliant with the Health Insurance Portability and Accountability Act (HIPAA).
Workflows combines several agents in one multi-step run.
Where it falls short
Agentic Plus parsing at scale costs more than the $50 Starter headline suggests.
Virtual private cloud deployment, single sign-on and custom Business Associate Agreements are Enterprise-only, so a regulated team starts with a sales call.
Free-tier indexes take file upload only, so the external data source connectors can’t be tried on the free plan.
Free plan: yes
Who it’s for: Engineers building agents over large document sets who want parsing, extraction and indexing on one credit meter, with one API key for Python, TypeScript, Go or Java.
Skip it if: Teams that want a free start with no credit meter should look at Google Agent Development Kit (ADK), which runs on your own model credentials and has no credits to expire.
Best for stateful agents on a small paid plan: Letta has the cheapest paid entry plan, at $20 a month, and that Pro plan runs up to 20 agents whose memory persists across sessions.
PriceFree, then $20 a month
The Free tier covers 3 stateful agents on your own model keys. Pro is $20 a month for up to 20 agents, Teams Pro is $20 a seat a month, and Enterprise is custom.
The API Plan bills $20 a month base plus $0.10 per active agent per month, with tool execution metered by the second on top. Every plan accepts your own provider keys or coding subscriptions, and that usage bypasses Letta credits.
What it does well
Memory lives in git-backed files you can branch, diff, roll back and sync to your own GitHub repository.
Agents keep reorganizing their own context during idle periods.
A GitHub Action triggers agents from issues, pull request comments or pull request events.
Permission modes run from strict to unrestricted, with allow and deny tool patterns and a cross-agent memory guard.
Where it falls short
Letta publishes no SOC 2 or ISO 27001 attestation, which slows a security review.
The active harness moved from Python to TypeScript, so teams on the original Python repository must migrate.
Letta publishes no MCP server of its own, so other agents can’t call a Letta agent as an MCP tool.
Free plan: yes
Who it’s for: Developers building long-running agents whose memory, skills and configuration must persist as one server-side object across sessions.
Skip it if: Teams that need a SOC 2 attestation should look at LangGraph, which holds SOC 2 Type II.
Best for polyglot teams paying nothing upfront: Google Agent Development Kit (ADK) has a free plan and ships one framework across Python, Go, Java, TypeScript and Kotlin, so a mixed-language team pays only for the models and hosting it picks.
PriceFree
The framework is free, and inference always runs on your own model credentials. One command deploys an agent to Google Cloud, or you containerize it and run it on infrastructure you control.
On Google Cloud, the managed Agent Runtime bills across separate usage meters for compute, memory and session storage, plus model tokens and search grounding, with no flat fee. Sessions save to a plain file on disk or to your own database, and there are no credits to expire.
What it does well
Python, Go, Java and TypeScript are generally available, with Kotlin documented alongside them.
MCP works in both directions: agents consume MCP servers, and ADK tools can be served to any MCP client.
A local debugging UI and a repeatable evaluation framework score an agent’s full trajectory and final output.
Agents run from events, queues or a schedule as background processes.
Where it falls short
Managed hosting spreads across several usage meters with no flat fee, so the cloud bill is hard to forecast.
Kotlin is at 0.8.0, behind the other languages.
Docs and tutorials skew toward Python, with few TypeScript, Go or Java examples.
Free plan: yes
Who it’s for: Polyglot teams building multi-agent systems that must work with agents from other vendors through cross-vendor agent protocols and MCP.
Skip it if: Teams that want managed hosting at a published monthly price should look at Letta, whose Pro plan is $20 a month.
Best for Claude builders paying by usage: Claude Agent SDK is metered on usage and sold per token with no seat price, so a Claude-only team pays for what its agents run.
PriceFrom $0.10 per 1m input tokens
The SDK bills through Anthropic API usage, with no seat price, seat floor or seat ceiling. You run it on your own Anthropic key, your own proxy, or Claude endpoints on Bedrock, Google Cloud or Microsoft Foundry.
It authenticates with API keys or cloud credentials, and single sign-on with directory sync sits on the Anthropic organization that owns those keys. Each running agent is a long-lived subprocess tied to local disk state, so container hosting needs a separate session store.
What it does well
File read and edit, bash and web search tools are available by default, gated per call by allow and deny lists.
Permission modes, allow and deny rules, hooks and a canUseTool callback decide every tool call in a documented order.
Bare mode and exit codes let a build pipeline fail on a bad agent run.
SOC 2 Type 2 and ISO 27001 reports are published through the Trust Center.
Where it falls short
Claude is the only model family, with no supported route to other vendors’ models.
Anthropic changed programmatic-usage billing more than once in 2026, so cost plans need rechecking.
Who it’s for: Developers already building on Claude or Claude Code who want its agent loop and tools as a library in Python or TypeScript.
Skip it if: Teams that need models from several providers should look at LangGraph, which reaches OpenAI models through its first-party integration.
Best for TypeScript teams wanting a free library: AgentsKit is a free TypeScript library that runs on your own provider key or in-browser models, so the only bill is your model provider’s.
PriceFree
The library is free, and each hosted model adapter takes your own provider key, while local or in-browser runtimes skip the network call. There are no credits to forfeit and no vendor-held store.
Audit records, cassettes and traces go to paths and memory backends you own. The core runs with no model or API key for local testing.
What it does well
A signed, hash-chained audit log writes to a file you own, and a verify call throws if any record was altered or removed.
The MCP bridge consumes external MCP servers and publishes your tools or a live runtime to Claude Code, Cursor or Codex.
The eval package fails a pull request check when an agent regresses.
Native adapters cover Claude Opus, Sonnet and Haiku with streaming, tool calls and vision.
Where it falls short
The GitHub repository shows 25 stars and 1 fork, a thin adoption signal.
It requires Node 22+ and TypeScript 5.8+, which excludes teams on older stacks.
Tool limits are opt-in code: you must wrap tools in a sandbox policy or mark them for human confirmation.
Free plan: yes
Who it’s for: JavaScript and TypeScript developers who want a dependency-light agent toolkit they own, with a core that has zero runtime dependencies.
Skip it if: Teams that want a managed cloud behind their agents should look at Letta, whose Free tier hosts 3 stateful agents.
Best for voice agents starting on free minutes: LiveKit Agents starts on a $0 Build tier with 1,000 agent-session minutes and no credit card, enough to run a voice agent before paying $50 a month.
PriceFree, then $50 a month
The Build tier costs $0 a month with 1,000 agent-session minutes included, plus a $2.50 monthly inference credit that covers about 50 minutes of LiveKit-hosted model usage. The paid plan starts at $50 a month.
Plans are priced per project with usage allowances, with no seat count. Speech, model and voice provider costs come on top of the session minutes, and unused inference credits expire monthly.
What it does well
Turn detection, interruption handling, background noise filtering and native telephony ship in the framework.
Deepgram, AssemblyAI, OpenAI, Anthropic, ElevenLabs or Cartesia plug in, or LiveKit’s own Inference gateway serves the models.
Recordings go straight to your own cloud storage bucket, and traces export to any OpenTelemetry backend.
LiveKit holds an active SOC 2 Type II report.
Where it falls short
Claude runs only through the Anthropic plugin on your own key.
Observability data is kept 30 days, and metrics export APIs sit on Scale and above.
Business Associate Agreements for health data are offered only on Scale and Enterprise.
Free plan: yes
Who it’s for: Engineering teams that want to own a voice-agent stack end to end, self-hosted or on LiveKit Cloud.
Skip it if: Teams building text or coding agents with no voice should look at Claude Agent SDK, which ships file, bash and web tools by default.
Best for teams budgeting per seat plus usage: LangGraph bills $39 a seat a month on Plus and meters usage separately in two units at $1.50 and $1 each, so a team budgets headcount and runs as two lines.
PriceFree, then $39 a seat a month
The framework is free, and the Developer plan is free for 1 seat with 5,000 traces a month. Plus is $39 a seat a month with 10,000 traces and one free Serverless Small deployment, and it adds unlimited seats. Enterprise is custom.
Usage is metered on top of seats in two units, at $1.50 and $1 each. The Agent Server runs locally from the command line at no cost, while the managed Assistants API is a Plus and Enterprise feature.
What it does well
State is checkpointed after every node to Postgres, SQLite or Redis, so a run resumes after a restart.
A deployed agent can be exposed as an MCP server on Developer, Plus and Enterprise.
LangSmith holds SOC 2 Type II and covers GDPR and HIPAA with annual third-party audits.
A reference pipeline runs tests and offline evals on each pull request before quality-gated deploys.
Where it falls short
Seat fees plus the two usage units add up before any model API costs.
Reviewers describe a steep learning curve, with docs split across the LangGraph, LangChain and LangSmith sites.
Refactoring an agent often means redrawing its graph.
Free plan: yes
Who it’s for: Engineering teams building production agents that need cyclical graphs, durable state and replayable runs.
Skip it if: Teams that want a first agent running fast with no graph to draw should look at OpenAI Agents SDK (Python), whose runner drives the agent loop for you.
Best for shipping a simple Python agent free: OpenAI Agents SDK (Python) installs free with no account or subscription, so a simple tool-using agent costs only the model calls on your own key.
PriceFree
The package is free to use, but running an agent needs a model provider key. You bring your own credentials and can point it at any OpenAI-compatible endpoint, so OpenAI resells no inference through it.
OpenAI models are the default path through the Responses and Chat Completions APIs. Paused run state serializes to files you store, and sessions can sit on your own SQLite or Redis.
What it does well
Agents hand off a conversation to a specialist or call other agents as tools within one run.
Guardrails validate input and output in parallel with the agent and fail fast.
Tools declare when they need approval, and the run pauses for approve or reject, including shell and MCP tools.
Sandbox agents get a persistent workspace on a local, Docker or hosted sandbox.
Where it falls short
The project is at v0.x, so the API and defaults can shift between releases.
Durable state is a snapshot taken at approval pauses, so you manage checkpoints yourself.
Claude is reached only through compatible endpoints or beta adapters.
Free plan: yes
Who it’s for: Developers shipping a straightforward agent such as support triage or a tool-using assistant, with tracing and guardrails included.
Skip it if: Teams that need automatic step-by-step checkpoints should look at LangGraph, which saves state after every node.
Prices compared
Figure 1 · Entry price, a monthEntry prices in US dollars run from $20 a month to $50 a month; the median is $50 a month
Letta$20 a month
LlamaIndex$50 a month
LiveKit Agents$50 a month
Source: Each vendor’s pricing page, read between 24 October 2026 and 24 October 2026.
Letta’s $20 a month sits well under the $50 a month median, which is what LlamaIndex and LiveKit Agents charge to start. The entry price is the floor. LlamaIndex Pro is $500 a month.
“Yes. All plans support bringing your own API keys (BYOK). When you connect your own keys (via /connect in the Letta CLI), usage goes directly through your provider account”
Entry price is a poor guide here, since paid plans start at $20 a month with a median of $50 a month. The bill comes from what each product meters: LlamaIndex credits by parse tier and region, LangGraph seats and usage units, LiveKit Agents inference past the included credit, and Claude Agent SDK usage.
Bringing your own model keys moves most of the variable spend to your model provider. Letta usage on your own keys bypasses Letta credits, and LangGraph takes provider keys in your code on every plan. Teams that need security certifications have a shorter list: LlamaIndex, Claude Agent SDK and LangGraph.
How we compared
We compared 8 agents on price, free plan and 3 questions a buyer asks, reading each vendor’s pricing page and product pages between 2 September 2026 and 28 October 2026. We did not sign up for or run any of them. The median, the cheapest and the dearest plan are taken over the 3 picks priced in US dollars a month, so their prices compare directly. In all we answered 38 questions about what they do.
Questions buyers ask
Are AI agent frameworks free to use?
Mostly yes: 7 of the 8 frameworks have a free plan. Claude Agent SDK is metered on usage, so its cost follows what your agents consume. The free plans cap different things: LlamaIndex counts credits, LangGraph counts seats and traces, and LiveKit Agents counts session minutes.
Which agent framework has the cheapest paid plan?
Letta, at $20 a month for Pro. Pro covers up to 20 agents, and the Free tier runs 3 stateful agents on your own keys. The API Plan is also $20 a month base, plus $0.10 per active agent per month.
How much does LangGraph cost?
LangGraph is free on Developer for 1 seat with 5,000 traces a month, and Plus is $39 a seat a month with 10,000 traces. Usage is metered separately in two units priced at $1.50 and $1 each. A small setup can run from tens of dollars into the low hundreds a month before model API costs. Enterprise is custom.
What does LlamaIndex cost after the free tier?
Starter is $50 a month and Pro is $500 a month. Enterprise is custom. Credits vary by parse tier and by region, with a 1.5x multiplier in Europe, so heavy parsing costs more than the Starter price suggests. The free tier caps you at 5 indexes of 50 files each with file upload only, so it cannot test the external data source connectors.
How is the Claude Agent SDK billed?
Claude Agent SDK is metered on usage. You can bring your own Anthropic key, your own proxy, or your own cloud through Bedrock, Google Cloud or Microsoft Foundry. Anthropic changed programmatic-usage billing twice in 2026 and reversed a planned move onto a separate Agent SDK credit on the day it was due to take effect, so confirm the current terms with Anthropic before you budget.
What does the LiveKit Agents free tier include?
The Build tier is $0 a month with 1,000 agent-session minutes and no credit card. Its $2.50 monthly inference credit covers about 50 minutes of LiveKit-hosted model usage, so a real deployment needs metered LiveKit Inference credits or your own third-party providers. Paid use starts at $50 a month.
Can I bring my own model API keys?
Yes on LlamaIndex, Letta and LangGraph, and partly on LiveKit Agents. Letta takes your own provider keys on every plan, and that usage bypasses Letta credits. LlamaIndex self-hosted deployments call providers with your keys, and its hosted API bills 1 credit per page for own-key use. LangGraph takes provider keys in your code on every plan, and LiveKit Agents runs provider plugins on your own account, though traffic routed through LiveKit Inference cannot use your key.
Which agent frameworks have security certifications?
Copilot's coding agent is the cloud one: you assign it an issue, it opens a pull request. It is not agent mode in VS Code, and it does not ask before it acts.