CrewAI Pricing: What the $0 Tier Actually Costs to Run

CrewAI pricing has exactly two public numbers as of July 30, 2026: $0 for the Basic plan, which includes 50 workflow executions a month, and "Custom" for Enterprise, which means a sales call. Everything else on the CrewAI pricing page is a feature tick, not a price. So the honest answer to "what will CrewAI cost me" is not a plan number at all. It is the cost of the runs themselves, and that lands on your model provider's invoice, not CrewAI's.

That gap is the whole story, and it is where we think the buying conversation should start. A framework's sticker price tells you almost nothing about what an agent workload costs to operate, because the dominant line is tokens burned per execution, and a multi-agent design burns them at a rate most budgets are not built for. Anthropic's own engineering team measured this on its research product: agents typically use about 4x more tokens than chat interactions, and multi-agent systems use about 15x more tokens. One HN commenter building an investment-research pipeline described the same wall from the other side. Writing on 2026-03-11, wintersweet001 said a bull/bear/judge debate architecture pushed "token costs passed 500K per run with no quality gain" before they tore it out and replaced it with a decomposed pipeline. Fifty free executions did not save them anything, because the free executions were never the expensive part.

The short answer: CrewAI's plan price is $0 or "call us" — so price the run, not the plan: at July 2026 model rates a realistic four-agent run costs roughly $0.40 in tokens, which means the 50 free monthly executions carry a $2 to $76 bill you pay to someone else.

Last updated: July 30, 2026.

We have not run a paid CrewAI Enterprise contract ourselves and we do not quote one. Every figure below is either fetched from a named vendor page on July 30, 2026, or derived in the open from stated assumptions you can change.

The plan price is one line. The run price is five.

What CrewAI pricing actually is in July 2026

There are two CrewAI pricing plans and one of them has no number. Fetched on July 30, 2026, the pricing page shows a Basic plan at Free with 50 workflow executions per month, and an Enterprise plan priced "Custom" behind a "Request trial" button. There is no mid-tier, no per-seat list price, and no published overage rate. Enterprise executions are described as "Sized to workflow" with "Flexible overage."

Both tiers include what CrewAI calls Studio (the visual editor), standard tools and triggers, GitHub integration, tracing, OpenTelemetry export, guardrails, human-in-the-loop input, hallucination scores, token counting and cron scheduling. The Enterprise-only column is short and specific: enterprise connectors, dedicated VPC and customer-infrastructure deployment, NAT, SAM certification, FedRAMP High, SSO with Microsoft Entra or Okta, role-based access control, and every category of paid support, from a dedicated contact and a Slack or Teams channel through to on-site work, training, onboarding and development. CrewAI also states on the same page that the platform is "Used by 65% of the Fortune 500," which is a vendor claim on a vendor page and should be treated as one.

The hosted product has a name worth knowing when you read the docs: CrewAI AMP, the Agent Management Platform, described in CrewAI's own documentation as the layer that deploys, monitors and scales crews in production. The open-source framework underneath it is a separate thing entirely. crewAIInc/crewAI on GitHub is MIT-licensed, actively pushed to, and carried 56,391 stars when we checked the GitHub API on July 30, 2026. You can run it forever without paying CrewAI a cent. That is the honest headline and also the trap, because "the framework is free" and "the workload is free" are not the same sentence.

One limitation to state plainly rather than hide: we tried to retrieve archived snapshots of the CrewAI pricing page to show how the plan ladder has changed over time, and web.archive.org timed out repeatedly from our environment. So we cannot show you the history. Every figure in this article is as-fetched on the date named beside it, and if you are reading this months later, re-fetch before you quote it.

Executions are the meter, tokens are the bill

CrewAI meters the platform in workflow executions, not seats. That is a genuinely good design for a buyer, because it means adding readers, reviewers and stakeholders to a project costs nothing. It is also the thing that makes CrewAI pricing hard to forecast, because an execution is not a fixed-size unit of work. One execution can be a two-agent triage that touches a model twice, or a six-agent research crew that loops for four minutes and calls a model thirty times.

The meter counts one. The invoice does not.

This is why the useful question is never "how many executions do I get." It is "what does one execution cost me across every party I pay." For a workload running on CrewAI's free tier, you pay CrewAI nothing and you pay your model provider whatever the run consumed. For a workload running on Enterprise, you pay a negotiated platform fee plus the same model bill. The model bill does not shrink when the platform fee grows.

Anthropic's research-system write-up is the clearest public data we found on the multiplier. Their engineers report that token usage by itself explains 80% of the performance variance on the BrowseComp evaluation, and that multi-agent architectures "burn through tokens fast" at roughly 15x chat usage. Read as a cost statement rather than a capability statement, that says the architectural choice you make in week one sets your operating cost for the life of the workload, before you have written a line of business logic.

Our earlier analysis of what a multi-agent handoff actually commits you to makes the same point from the permission side: each additional agent is an edge, and edges multiply. Here the multiplication is financial. Every extra agent adds its own context window, its own system prompt, and its own share of the conversation history that gets recopied on each turn.

The Run Cost Ledger: five lines you price per execution

Here is the procedure we use, and we have given it a short name so it travels: the Run Cost Ledger. It has five lines, it is priced per execution rather than per month, and it takes about twenty minutes with a spreadsheet.

Line 1: model tokens. Count the LLM calls in one run, estimate average input and output tokens per call, and multiply by your provider's published rate. Input dominates in agent workloads because context accumulates. As of July 30, 2026, Anthropic's published API pricing lists Claude Sonnet 5 at $2 per million input tokens and $10 per million output tokens through August 31, 2026, rising to $3 and $15 after that date; Claude Haiku 4.5 sits at $1 and $5. OpenAI's pricing page lists gpt-5.6-terra at $2.50 input and $15.00 output per million tokens, and gpt-5.6-luna at $1.00 and $6.00. Pick the model you will actually route to, not the cheapest one on the page.

Line 2: retries and failures. Agent runs fail in ways deterministic pipelines do not, and a failed run costs the same tokens as a successful one. The Berkeley-led study Why Do Multi-Agent LLM Systems Fail? built a taxonomy from more than 1,600 annotated traces across seven multi-agent frameworks and identified 14 distinct failure modes clustered into system design issues, inter-agent misalignment and task verification. You do not need their exact numbers to budget; you need a retry multiplier that is not 1.0. We use 1.15 as a starting assumption and tell people to replace it with their own measurement after two weeks of real traffic.

Line 3: tools, retrieval and egress. Every search API, vector-store query, document fetch and third-party connector call inside a run has its own price. These are usually small individually and they are the line teams most often forget entirely. Count them per run, not per month.

Line 4: observability. You cannot govern what you cannot see, and traces are metered too. Langfuse's pricing page, fetched July 30, 2026, gives a concrete shape: a free Hobby plan with 50,000 units a month, Core at $29 a month with 100,000 units and $8 per additional 100,000, Pro at $199, and Enterprise at $2,499. A unit is roughly an ingested observation, so a twelve-call run produces on the order of thirteen units. CrewAI includes tracing and OpenTelemetry export on both tiers, which is genuinely useful. But if your security team requires traces in your own tooling, you are paying that tooling's meter as well.

Line 5: human review. If the workflow has a human-in-the-loop gate, someone's minutes are a cost line. Two minutes of review per run at a fully loaded $75 an hour is $2.50 — which, as the tables below show, is frequently larger than every machine cost in the run combined. Teams that skip this line usually skip the gate too, and that is a governance failure dressed as a cost saving.

Add the five and you get the number the diagram above shows: for one run of the four-agent research crew priced later in this article, $0.396 of tokens, plus 15% for retries, plus about $0.006 of trace ingestion, plus $2.50 of review time, is roughly $2.96 per execution before tool calls. Multiply by monthly volume and you have a figure you can defend in a budget meeting. Notice what is not on the list: the CrewAI plan fee. On Basic it is zero, and on Enterprise it is a negotiated constant that sits beside the ledger rather than replacing it.

Three workload profiles, priced end to end

The abstraction is only useful once it has numbers in it, so here are three profiles priced against the July 2026 rates above. Assumptions are stated in full and the arithmetic is reproducible: total input tokens times the input rate, plus total output tokens times the output rate.

Read the next three tables as worked examples, not as benchmarks. The call counts and token sizes are ours, chosen to be representative of shapes we see described publicly; nobody metered a real CrewAI deployment to produce them. What is measured is the price per million tokens, taken from the provider pages named above on July 30, 2026. Swap our assumptions for yours and the structure still holds.

Profile C is deliberately calibrated to the HN report quoted at the top: 499,800 tokens per run, essentially the 500K figure that developer measured before abandoning the architecture. It is not a strawman. It is what a debate-style crew on a non-trivial task actually consumes.

Now the monthly view, including a 15% retry multiplier from Line 2:

And annualised, because that is the unit a budget owner signs:

Three things fall out of these tables that a plan-comparison table can never show you.

The free tier is not free. Fifty executions a month costs between $2.41 and $76.24 in tokens depending on how you designed the crew. That is a 32x spread inside the same plan, driven entirely by architecture. No pricing page can tell you which end you are on.

Architecture beats negotiation. Moving Profile C to Profile B's shape saves about $5,350 a month at 5,000 runs. There is no platform discount of that size available to a mid-market buyer. The cheapest lever in agent economics is deleting an agent, and the second cheapest is routing each step to the smallest model that passes — a triage step on Haiku-class pricing costs about a tenth of the same step on a frontier model.

The human line dominates at low volume. At 1,000 runs a month with a two-minute review gate at $75 an hour, human review costs $2,500. That is more than Profile B's entire token bill and more than Profile C's at 1,000 runs. If your business case rests on removing that gate, say so out loud in the case, because that is a risk decision and not a cost optimisation.

Where the money is not: compute is a rounding error

One number in the ledger consistently surprises people, so it is worth isolating. If you self-host the open-source framework rather than using CrewAI's hosted platform, the container compute is almost free.

AWS Fargate's published pricing for Linux on x86 in US East (N. Virginia), fetched July 30, 2026, is $0.000011244 per vCPU-second and $0.000001235 per GB-second. A run on one vCPU and 2 GB of memory works out like this:

Six dollars a month of compute against $2,277 of tokens. The practical implication is that "self-host to save money" is almost never true as a compute argument — you self-host for data residency, for network isolation, or to avoid a platform contract, and the compute saving is noise. Anyone quoting infrastructure savings as the reason to run your own agent runtime is quoting the smallest line on the invoice. Our earlier work on self-hosted AI deployment treats that trade as a sequence of control decisions rather than a cost decision, and the arithmetic here is why.

It also reframes what CrewAI's hosted tier is selling. It is not selling you compute. It is selling deployment, connectors, identity, support and the operational surface around the runtime, which is exactly the set of things that sits behind "Custom."

The governance tax: what moves to "Contact sales"

Read the CrewAI pricing matrix column by column and a pattern appears that has nothing to do with agents. Almost everything a builder wants is on the free tier. Almost everything a security team requires is not.

This is not unique to CrewAI, and that is the point. The SSO Wall of Shame has catalogued the pattern across the software industry for years, arguing that gating single sign-on behind an enterprise paywall "can inflate the cost by 3x, 5x, 10x, or more" and calling SSO a core security requirement for any company with more than five employees. You can watch the same tax operate inside the observability layer of your own stack. On Langfuse's published tiers, the Core plan for production projects costs $29 a month and does not carry enterprise SSO, SSO enforcement or project-level role-based access control. The cheapest path to those is the Pro plan at $199 plus the Teams add-on at $300, so $499 a month; they are also bundled into Enterprise at $2,499. Same product, same 100,000-unit ingestion quota, roughly 17x the price for the identity controls. That is one of the more transparent examples, because at least the numbers are published.

For a CrewAI buyer, the practical consequence is a decision fork that arrives earlier than most teams expect:

• If nobody outside a two-person team will ever touch the platform, the free tier's lack of RBAC is a non-issue and you should stay on it.
• The moment a third person joins, or the moment an agent touches a system with customer data in it, the absence of SSO and role-based access control becomes an audit finding rather than an inconvenience. Centralised authentication, least-privilege authorisation and a reviewable record of who changed what are ordinary expectations under SOC 2 and ISO/IEC 42001, and a shared login on a free tier satisfies none of them. The only remedy CrewAI publishes is a sales conversation.

There is a third path that most pricing articles skip, and it is the one we see working in practice: keep the framework free and put the identity and policy controls in a layer that sits in front of every model call, rather than inside any one framework. That is a real architectural option, not a vendor slogan, and we cost it in the next-but-one section.

Whatever you choose, budget the governance line explicitly. An agent that can read a CRM is a non-human identity with standing access, and treating it as one — owner, scope, expiry — is cheaper before the workload ships than after.

Open source is free; operating it is a salary line

CrewAI's framework is MIT-licensed and costs nothing to download. It never appears in a CrewAI pricing comparison, but the engineering time to build, tune and keep an agent workload alive is the largest number in most real business cases, and it is the one nobody publishes.

Two pieces of evidence are worth putting in front of anyone who is about to write "two weeks of engineering" into a plan.

First, AI assistance does not reliably shrink that estimate. METR's randomised controlled trial, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, had 16 experienced developers complete 246 tasks in mature repositories with AI tools randomly allowed or disallowed. The developers forecast a 24% speed-up and estimated afterwards that they had got a 20% speed-up. Measured, allowing AI tools increased completion time by 19%. The study is narrow. Experienced developers, mature open-source projects, early-2025 tooling, and its authors say so themselves. But it is the strongest available caution against booking an AI-assisted delivery discount before you have measured your own.

Second, agent systems fail in categories that need engineering attention rather than prompt tweaking. The MAST taxonomy sorts its 14 failure modes into system design, inter-agent misalignment and task verification, which maps almost exactly onto three ongoing workstreams: designing the crew, keeping agents from talking past each other, and building the checks that catch a plausible-but-wrong output. None of those is a one-off cost.

Put a number on it the boring way. Pick a fully loaded hourly rate for your team — substitute your own; we use $100 an hour in worked examples and label it as an assumption, not a finding — and estimate:

The ranges are ours and they are estimates, not measurements — treat them as a template to overwrite rather than a benchmark to cite. The structural claim underneath them is the one that holds: for a single production agent workload at moderate volume, the recurring engineering line is usually larger than the token line, and the token line is usually larger than everything else combined. A pricing page that shows you neither is not lying to you. It is just answering a smaller question than the one you asked.

Free tier, enterprise contract, or the costed middle

Most articles on CrewAI pricing present two options. There are three, and the third is the one most mid-market teams should model first.

Option 1: stay on Basic. Cost: $0 platform, plus your Run Cost Ledger. Fits a single team, under 50 runs a month, no data that would embarrass you in an audit, and a tolerance for community-only support. The ceiling is hard: 50 executions is a maximum on Basic, not a soft allowance, so the plan ends abruptly rather than degrading.

Option 2: sign Enterprise. Cost: unpublished, plus your Run Cost Ledger, plus onboarding. You get SSO, RBAC, deployment into your own VPC or infrastructure, enterprise connectors, and named support. CrewAI's page describes a 45-day onboarding and optional forward-deployed engineering, which tells you the shape of the engagement even without the number: this is a contract sale with a services component, not a credit-card SaaS purchase.

Option 3: the costed middle, a free framework with your own control plane. Run the MIT-licensed framework on your own compute, and buy identity, policy and audit as a separate layer that every model call passes through. Costed honestly at 5,000 Profile-B runs a month:

The number that matters in that table is not the total. It is that the platform line is $0 and the two lines you would have signed an Enterprise contract to obtain — identity and audit — are the ones still marked "varies." That is the honest state of the option: it is real, it is cheap on paper, and it moves work onto your team. Whether that trade is good depends on whether you already have an identity layer, or whether you would be building one for this workload alone.

One agent workload, year one, all lines

Budget owners want a single defensible annual figure, so here is one: a Profile B research-brief crew at 1,000 runs a month, on the free CrewAI tier, self-hosted, with a two-minute human review gate. Engineering rates and hours are our assumptions; token, compute and observability rates are fetched.

The platform is zero percent of that. Tokens are nine percent. People are ninety. If a business case for an agent workload does not have those three proportions roughly right, it is not a business case for an agent workload. It is a licence comparison with a hopeful ending.

A useful tiebreaker: if the answer to "who owns this agent when its author leaves" is a shrug, buy the governed option, whichever vendor supplies it. That question, not the price, is what turns a pilot into a production system, and it is the one we have seen stall the most pilots.

Nine questions to send before you price anything

Because half of CrewAI pricing is quoted rather than published, your only lever is the questions you ask before the quote is written. Send these in writing and price the answers, not the plan.

1. What exactly counts as one execution? Does a retry count? A run that fails on step two? A cron-triggered run that finds nothing to do? A sub-crew invoked by a parent crew?
2. What is the overage rate per execution above the committed allowance, in dollars? "Flexible overage" is a negotiating position, not a rate.
3. Is the commitment monthly or annual, and does unused allowance roll over?
4. Which model providers are billed to you, and which to us? If any inference is resold through the platform, ask for the per-token markup in writing.
5. What is the price of SSO and RBAC specifically? Ask for it as a line item, even if the answer is that it is bundled. If it cannot be separated, the bundle is the tax.
6. What does the 45-day onboarding include, what does it cost, and what happens on day 46?
7. Can we export every trace to our own OpenTelemetry collector, and does that export include the refusals and blocked actions or only successful runs?
8. On termination, what do we keep? Agent definitions, prompts, evaluation sets and trace history each need a separate answer.
9. What is the price at 3x our forecast volume? Agent workloads grow through architecture changes, not headcount, so the volume curve is steeper than a seat-based one.

Question 1 is the one to insist on, and you should know what a good answer looks like before you hear one. A good answer to question 1 is a written definition with the edge cases enumerated; a bad answer is "a run is a run." A good answer to question 2 is a dollar figure per execution; a bad answer is "we'll work with you on that." A definition of "execution" that quietly includes retries changes your bill by the retry rate. Call it 15% on our assumption, and more on a workload nobody has tuned yet. Ask for both answers in the same email, because a vendor that will define the unit but not price the overage has told you which one they expect to grow.

Where LeapForce fits, and where it does not

We do not sell an agent framework and we are not an alternative to CrewAI — CrewAI is where you build and run crews, and nothing in this article should be read as a suggestion to swap it out. What we build is the layer underneath the question this whole article circles: once the run is an agent rather than a person, who owns it, what may it touch, what did it do, and what did it cost. LeapForce puts one governed endpoint in front of every model call so spend, policy and audit are attributes of the platform rather than of whichever framework happened to make the call, and our published rollout order for it is deliberately unglamorous — observe first, enforce second, optimize third — because a team that enforces before it can see its own traffic breaks work it did not know existed. Our honesty convention applies here too: gateway endpoints, tracing and SSO are live today, while dollar-denominated budgets and inline data-loss prevention are in active development and we will not describe them as shipping. If you want the mechanics rather than the pitch, our AI gateway analysis and the model routing page go into both.

Honest limits and open questions

This analysis has real boundaries and we would rather name them than have you find them.

We have not bought CrewAI Enterprise. No first-hand test, no negotiated quote, no benchmark run on our side. Everything about the Enterprise tier here comes from CrewAI's own published page and documentation, read carefully. If you have a real quote, it beats our reasoning.

The token model is an estimate with stated assumptions, not a measurement. Calls per run, tokens per call and the 15% retry multiplier are inputs we chose to be representative, and a real workload will differ, probably by a lot, and possibly in either direction. The value of the Run Cost Ledger is the structure, not our numbers. Replace every cell with your own after two weeks of traces.

Model prices are moving and some are dated. Anthropic's own page states Sonnet 5's introductory $2/$10 rate runs through August 31, 2026, after which it becomes $3/$15. That is a 50% increase on the line that dominates the ledger. Any annual figure in this article computed at the introductory rate understates a full year at the standard rate. Re-derive rather than re-quote.

Archived pricing was unreachable. We could not retrieve historical snapshots of the CrewAI pricing page to show how the tiers have changed, because web.archive.org timed out from our environment. Readers who have seen older articles describing a multi-tier CrewAI ladder should treat the two-plan structure we fetched on July 30, 2026 as current and verify it themselves rather than assuming either version is stale.

The evidence on multi-agent efficiency cuts both ways. The Anthropic figures come from a vendor engineering blog about its own product, and the MAST work is a preprint. Both are the best public material we found, and neither is an independent audit of CrewAI specifically. We found no independent, reproducible benchmark of CrewAI execution costs at production volume, which is a genuine gap in the public record.

We searched for a credible video on this topic and shipped none. The YouTube Data API returned a quota error rather than results on the day of writing, and we do not guess video IDs.

Ready to Govern Your AI?

Talk to LeapForce — one controlled layer for every AI tool, connector, model, and agent.