AI Coding Tools Pricing: Examples & Companies

What is it

AI Coding Tools Pricing is the pricing approach used by AI-native developer tools — code editors, completion engines, and agent platforms that write or modify code — and by the models that power them.

The corpus tags 28 in-corpus companies under this use case, and they cluster into five layers. The editor/IDE-assistant layer — Cursor, GitHub Copilot, Windsurf, Codeium, Tabnine, Sourcegraph Cody, Qodo, Bito, and Augment Code — sells a developer-facing product and has largely converged on hybrid pricing: a per-seat fee plus metered or credit-based AI usage. The open-source BYOK layer — Aider and Continue.dev — ships the tool free and passes raw model cost straight through to the developer’s own API key. The agentic/autonomous coding layer — Cognition (Devin), Factory, Sweep AI, Imbue, Magic AI, and Poolside — runs longer autonomous jobs whose pricing shape is still forming. The app-builder layer — Bolt.new, Lovable, Replit AI, and V0 — meters generated applications rather than editing sessions. And the model / infrastructure layer — Anthropic, OpenAI, DeepSeek, Claude Code, plus E2B (sandbox execution) and GitLab (DevSecOps AI) — sells coding-capable models and execution compute on pure per-token or per-runtime meters.

The user-level cost spread is wider here than in almost any other category. A casual developer on a $10-$20/month editor plan sits on the same product surface as a power user running $150-$200/month of agentic refactors. That spread is exactly what drove the editor layer to hybrid pricing — a fixed seat to anchor revenue, plus a usage meter to recover the variable model cost that a heavy user generates. Underneath it all, the model layer keeps getting cheaper per token, which is why the seat, not the inference, is where editor products capture margin.

How it works

Pricing mechanics differ sharply by layer. The editor layer charges a seat and meters AI on top of it; the agentic layer prices a unit of work; app builders price a generated artifact; and the model layer prices raw tokens.

The most legible version of the editor model is Cursor’s dollar-denominated credit pool: its $20 Pro plan includes $20 of credits, and $1 of credits equals $1 of underlying API cost, so a buyer can compare “what GPT-5 actually costs me” against the raw API. GitHub Copilot uses the same dollar-denominated idea — 1 AI Credit equals $0.01, and a $19 Business seat brings 1,900 pooled credits, with completions unlimited and never billed while chat, agents, and code review draw down the pool.

Unit math (typical heavy editor user): Cursor Pro $20 + ~$80 of premium-model usage ≈ $100/mo. The same work billed straight against a discounted coding model — e.g. DeepSeek V4-Flash cache-hit input near $0.0028/1M tokens — costs a small fraction per token. You are paying the editor for product, not just inference.

The agentic tier abandons the seat as the primary meter. Cognition bills enterprise Devin in ACUs (Agent Compute Units) at a contracted rate, bundling model and compute cost into a task-level unit; its self-serve tiers run Free / Pro $20 / Max $200 with on-demand credits on top. Factory takes a different route — a per-seat subscription ($20/mo up to $2,000/mo tiers) where usage is gated by rolling rate limits rather than a token meter. App builders shift the denominator again: Bolt.new sells a seat plus a monthly token allotment, and Lovable sells flat monthly credit tiers with on-demand top-ups, both pricing a generated application rather than an editing session.

Companies using this

Twenty-eight in-corpus companies serve the AI coding use case, spanning editor assistants like Cursor and GitHub Copilot, agentic platforms like Cognition’s Devin, app builders like Lovable, and the frontier model APIs — Anthropic, OpenAI, and DeepSeek — that power the rest of the stack. The table below lists each company’s structural pricing choices, billing units, and free-tier status.

Patterns observed

The editor layer has converged on seat-plus-credits. Cursor, GitHub Copilot, Windsurf, Tabnine, Sourcegraph Cody, Qodo, and Bito all ship a per-developer seat that includes a bundled credit or usage allowance, with metered consumption beyond it. Tabnine added AI Chat credits on top of its $39-$59 seats, and Sourcegraph Cody moved to pooled AI credits for Claude access — both signs the pattern is still spreading inside the cluster. The multi-tier individual ladders exist because developer demand stratifies steeply: Cursor ships six plans from $0 to $200 because a student trialing completions and a senior engineer running multi-file agentic refactors are not the same buyer, even on the same product surface.

Dollar-denominated credits are becoming the transparency standard. The shared move is to make one credit map cleanly to money — Cursor’s dollar-for-dollar pool and GitHub Copilot’s AI Credits both let a buyer read the meter in dollars — a deliberate break from opaque “premium request” counters developers could not translate into cost. When the credit unit maps to dollars, a buyer can reason about model choice, because routing a task to a cheaper model visibly lowers the credit draw. That legibility, not the raw price, is the point of exposing the meter.

The agentic tier is still hunting for its denominator, and that uncertainty is structural. Cognition, Factory, Sweep AI, Imbue, Magic AI, and Poolside run longer jobs — writing a feature, reviewing a PR end to end — where per-request metering breaks because one task spans hours and many model calls. Cognition answers with the ACU; Factory gates a flat seat with rolling rate limits and no token meter; Imbue ships free in beta on a BYOK basis; and Magic AI and Poolside are frontier labs with no public rate card at all. The opacity here is genuine uncertainty about the right unit of autonomous coding work, not concealment.

App builders meter the artifact, not the session. Bolt.new, Lovable, Replit AI, and V0 price a generated application or UI. Bolt.new sells a seat plus a monthly token allotment; Lovable sells flat credit tiers shared across unlimited users with on-demand top-ups; Replit AI combines seat, effort-based Agent billing, and pay-as-you-go deployment compute. The denominator has shifted from “coding session” to “application produced” — a developer generating ten revisions in a day is producing ten deployable artifacts, and the pricing reflects that.

Coding tokens are deflating, and the deflation propagates upward. DeepSeek reset the floor with its ~98% cache-hit discount on reused context, and Anthropic and OpenAI have each cut per-token prices across model generations. Because open-weight models are anchored to self-hosting cost, that pressure does not stop at the API boundary; it compresses the inference margin editor products embed in their credit denominations. E2B sandbox runtime and GitLab CI/CD compute add a second cost dimension, so the true cost of an AI coding workflow now spans raw tokens, editor seat, sandbox execution, and DevOps compute. See the token-price-deflation trend for how this dynamic is evolving.

Counterexamples & variants

The pure model layer is the clean counterexample to hybrid. DeepSeek is a coding-capable model sold on a pure per-token API with no seat and no editor product, competing on raw price alone. It has no paid consumer subscription — the entire business is token consumption — which shows that “seat plus credits” is a property of the editor, not of coding itself. Strip the product layer away and you are back to commodity inference, and DeepSeek’s repeated price resets keep pulling that floor down for everyone above it. Anthropic and OpenAI sit in the same layer with their coding models, though they retain subscription businesses on top.

BYOK is the most transparent variant, with the tradeoff moved onto the developer. Aider (a free, Apache-licensed terminal pair programmer) and Continue.dev (an open-source IDE agent, though it also sells a token-metered PAYG Starter and $20/seat Team tier) route model calls through the developer’s own API key. The vendor takes zero inference margin and the buyer pays the provider at published rates — maximal cost control, but the burden of key management, rate limits, and model selection lands on the developer. The commercial editors exist precisely because most teams would rather not carry that burden.

Not every metric survives contact with power users. Augment Code is the corpus’s sharpest cautionary tale: it changed its pricing metric four times in under 18 months — usage credits, then “unlimited” subscriptions, then user-message metering, then a pooled credit pool in October 2025. When it dropped “unlimited,” it disclosed the outlier that broke the model: a single user running 335 requests per hour, every hour, for 30 days, approaching $15,000/month in inference cost. The pivot drew “bait-and-switch” pushback on Reddit and HN. It is a concrete demonstration that “unlimited” and flat metering are unstable in a category where one heavy user can generate two orders of magnitude more cost than the median.

And the category has real mortality. Phind, an AI developer search engine and coding assistant with a Free / Pro ~$20/mo / Business ~$40 structure, shut down on January 16, 2026 — just six weeks after raising a $10.4M round. Its post-mortem is a reminder that healthy-looking freemium coding pricing does not guarantee a viable business when the model layer underneath is commoditizing and distribution is dominated by editors bundled into IDEs. Being a coding tool is not the same as having a defensible price.

The frontier tier’s variants have no editor analog. Sweep AI targets JetBrains IDEs with unlimited-autocomplete seats plus metered API credits only for chat and generation, while Poolside and Magic AI publish no rate card at all, with early customers effectively co-designing pricing alongside the product. These are the experiments that will decide whether autonomous coding lands on outcome-based, compute-based, or seat-based billing.

What this means for buyers vs vendors

For buyers

Don’t pick the cheapest plan on paper — compare cost per real workflow. Use a Cursor pricing calculator or equivalent to model your actual editing and refactor volume, because a low-headline seat plus typical metered usage can quietly cost more than a higher flat plan. If you mostly want raw capability, calling a discounted coding model like DeepSeek directly can undercut any editor seat. When evaluating the editor layer, ask three procurement questions: what does each model cost in credits (so you can route to cheaper models where quality allows), are credits pooled across the team so heavy users draw from light ones, and what happens at the cap — metered overage, auto-top-up, or a hard wall? Grounding those answers in the fundamentals of usage-based pricing models makes the comparison far cleaner.

For agentic tools like Cognition’s Devin or Factory, the model is different: per-seat reasoning does not apply when the system runs autonomously for hours on one task. Model per-task cost instead — estimate task duration, model calls per task, and the vendor’s compute-unit rate (ask “how many ACUs does a typical feature ticket consume?”). Building a task-level cost model before signing is the only way to avoid surprises in a metered system with no clear ceiling. For app builders like Bolt.new, Lovable, or Replit AI, estimate app-revision frequency — teams that iterate through many design passes exhaust monthly token packages faster than teams that generate once and deploy. And heed the Augment Code lesson: any “unlimited” plan in this category is a candidate for repricing, so read the fair-use terms before you standardize a team on it.

For vendors

If you sell an editor, hybrid is structurally correct once per-user cost variance exceeds roughly 3× — but invest equally in the in-product spending dashboard, because hybrid pricing without spend visibility reads as hostile. Cursor’s dollar-denominated pool and GitHub Copilot’s $0.01 AI Credit both work because the buyer can see the meter in dollars and reason about model choice; opaque “premium request” counters generate bill-shock and churn. Choosing the right value metric is the whole game — our guides on choosing the right usage metric and prepaid credits models cover the tradeoffs credit-based coding tools keep re-learning. If you sell the model, you are in a deflationary per-token race against DeepSeek and must compete on price-performance and coding-specific quality, not on margin.

For vendors building agentic systems, the pricing design problem is harder than the editor layer faced. Per-hour compute billing is too coarse to reflect delivered value; per-task ACU or credit metering (as Cognition uses) maps better to a meaningful unit of work but requires calibrating the denomination so buyers can forecast before committing. Outcome-based pricing — per merged PR, per completed feature, per resolved ticket — is the natural next horizon, because it aligns vendor revenue directly with buyer value. Early movers like Sweep AI and Factory are experimenting at the edges, but as agentic systems become more reliable, their pricing will migrate toward the output, not the compute.

Explore this theme in the knowledge graph →