Skip to content
The Agents Index
Sign inSubmit an agent

Buyer's guide Agent frameworks

What AI agent frameworks cost to start and scale

Most AI agent frameworks are free to start, and the bill arrives with the hosted layer, priced by plan, seat, credits or usage.

The Agents Index EditorialPublished 22 min readEditorial policy
See the comparison tableMarkdown
Logos of LlamaIndex, Letta, Google Agent Development Kit (ADK), Claude Agent SDK, AgentsKit, LiveKit Agents, LangGraph, OpenAI Agents SDK (Python). 8 agents compared, from $20 a month.
On this page
  1. The short answer
  2. Pick by what you need
  3. All 8 picks at a glance
  4. What the prices show
  5. What each one costs
  6. Prices compared
  7. What it means for a buyer
  8. How we compared
  9. Questions buyers ask
  10. Sources

The short answer

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.

Pick by what you need

All 8 picks at a glance

Table 1 Price, free plan and the questions that separate them, checked 28 October 2026
ProductFromFree planAgent permissionsMCP serverCertifications
LlamaIndex
Free, then $50 a month
Yes
Partly
Yes
Yes
Letta
Free, then $20 a month
Yes
Yes
No
Partly
Google Agent Development Kit (ADK)
On quote
Yes
Yes
Yes
–
Claude Agent SDK
$0.10 per 1m input tokens
–
Yes
Partly
Yes
AgentsKit
Free
Yes
Partly
Yes
Partly
LiveKit Agents
Free, then $50 a month
Yes
Partly
Partly
Partly
LangGraph
Free, then $39 a seat a month
Yes
Partly
Yes
Yes
OpenAI Agents SDK (Python)
Free
Yes
Yes
Partly
–

How we check

AdvertisementYour company across The Agents IndexAdvertise here

What the prices show

  • 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.

What each one costs

LlamaIndex

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.

Price Free, 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.

Letta

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.

Price Free, 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.

Google Agent Development Kit (ADK)

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.

Price On quote

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.

Claude Agent SDK

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.

Price From $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.

AgentsKit

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.

Price Free

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.

LiveKit 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.

Price Free, 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.

LangGraph

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.

Price Free, 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.

OpenAI Agents SDK (Python)

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.

Price Free

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 month Entry prices in US dollars run from $20 a month to $50 a month; the median is $50 a month
  1. Letta$20 a month
  2. LlamaIndex$50 a month
  3. LiveKit Agents$50 a month

Source: Each vendor’s pricing page, read between 24 October 2026 and 24 October 2026.

How we check

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”

From Letta’s own page, read on 2 September 2026

What it means for a buyer

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?

3 of the 8 hold security certifications: LlamaIndex, Claude Agent SDK and LangGraph. Letta, AgentsKit and LiveKit Agents partly do. For Google Agent Development Kit (ADK) and OpenAI Agents SDK (Python) the answer is unknown, so ask the vendor.

Sources

Top of agent frameworks

The category page
Show the whole category

What changed in the index

Agents we’ve just listed and every plan whose price changed.

Privacy policy

More of our research