AI Coding Product Pricing: Examples & Companies

What is it

AI Coding Product Pricing is pricing for products whose primary surface is AI-assisted coding — IDEs, completion engines, and review agents.

The category overlaps with the broader AI-coding use case but is narrower: it captures companies whose main offering is AI coding, not just companies that bolt AI coding on as one feature. Twenty-two companies in the corpus now span the category across four layers. The IDE/assistant core includes Cursor (an AI code editor), Codeium (the free Codeium extension plus a Windsurf-branded IDE), Windsurf (the Cognition-owned agentic Devin Desktop IDE), GitHub Copilot (an AI pair programmer embedded across IDEs), Augment Code (a context-engine coding assistant), Qodo (a code-integrity platform built around PR review), Tabnine (an enterprise completion engine), Sourcegraph Cody (a codebase-aware assistant), and Bito (AI code review). The open-source/BYOK layer includes Aider and Continue.dev, both free tools that route through the developer’s own API key. The agentic/autonomous layer covers Cognition (Devin), Factory, Sweep AI, Imbue, Magic AI, and Poolside. The app builder layer adds Bolt.new, Lovable, Replit AI, V0 by Vercel, and Claude Code.

What unites the IDE/assistant layer is a pricing problem rather than a product shape. The seat is the historical billing unit for developer tools, but the marginal cost of an AI coding product is dominated by frontier-model inference — and that cost varies wildly between a developer who lives in autocomplete and one who runs multi-file Claude Opus refactors all day. So that layer has converged on a hybrid: a per-developer seat that includes a credit (or dollar) allowance, with metered usage beyond it. Cursor, GitHub Copilot, Augment Code, Codeium, Tabnine, and Sourcegraph Cody all carry seat-plus-usage or hybrid in their taxonomy. The agentic and app-builder tiers above them solve the same cost-variability problem at a different scale — a single autonomous task can consume what an editor user spends in a week, so those products require a different denomination entirely.

Several IDE products began with flat seats or “unlimited” promises and retreated to credit metering once the model bill arrived — a dynamic explored in the AI coding: seats to credits trend.

How it works

The dominant mechanic is seat + metered credit pool. A developer buys a seat at a fixed monthly price; that seat includes a bundled credit (or dollar) allowance; usage beyond the allowance is either metered, topped up, or simply blocked. The credit abstraction exists to absorb per-model token-rate differences without exposing raw token prices to the buyer.

The credits are consumed at per-model rates, which is the core of the unit math. On Augment Code, a standard task on Claude Haiku 4.5 costs 88 credits while Claude Opus 4.7 costs 488 — so a heavy Opus user burns ~5.5x the pool per task. On Cursor, a $20 API pool covers roughly 65 Claude Opus 4.8 requests or 325 Composer 2.5 requests. The seat price is identical; the effective cost diverges entirely on model mix. On Qodo, most requests cost 1 credit but Claude Opus costs 5 and Grok 4 costs 4, so a premium-heavy review team drains a 2,500-credit pack in roughly 500 requests.

Unit math: Total bill = (seats × seat_price) + (credits_consumed − bundled_allowance) × per_credit_rate, where credits_consumed depends on the model routed to each task. For a heavy Cursor Pro developer the real number is roughly $20 base + ~$66 Opus overage + ~$16 Codex overage ≈ $102/mo — about 5x the headline seat.

This is why the team tier matters more than the individual sticker. A 10-person Cursor Teams workspace runs ~$400 in seats ($40/user) plus pooled overage plus Bugbot, easily landing north of $600/mo — and one engineer running long-context Opus can spike that in a week. Windsurf prices its team tier differently still: an $80/mo team base plus $40/seat, so the platform fee alone is $480/mo before any agent overage on a 10-person team. See the usage-based pricing thresholds and alerting guide for how to govern that variance, and model your own spend with the Cursor pricing calculator or Augment Code pricing calculator.

Companies using this

Twenty-two companies in the current corpus sell a product whose primary surface is AI coding. The IDE/assistant core with seat-plus-credits includes Cursor, Codeium, Windsurf, GitHub Copilot, Augment Code, Qodo, Tabnine, Sourcegraph Cody, and Bito. The open-source/BYOK tier includes Aider and Continue.dev. The agentic tier covers Cognition (Devin), Factory, Sweep AI, Imbue, Magic AI, and Poolside. The app builder tier includes Bolt.new, Lovable, Replit AI, V0 by Vercel, and Claude Code. The table below lists structural choices — seat price, billing units, free tier, and pricing model — for each.

Patterns observed

Every product in the IDE/assistant core pairs a per-developer seat with a metered credit pool. Cursor, GitHub Copilot, Augment Code, Codeium, Tabnine, and Sourcegraph Cody all carry seat-plus-usage or hybrid in their taxonomy — the headline price ($10–$39) advertises access; the meter sets the real ceiling. Individual paid tiers cluster tightly: GitHub Copilot Pro at $10, Codeium’s Windsurf IDE Pro at $15, Cursor Pro and Augment Indie at $20, Tabnine’s Code Assistant at $39/user. Team tiers then step to $35–$60/seat, where operational features (SSO, pooled credits, admin) justify the jump — Codeium Windsurf Teams at $35/seat, Augment Standard and Tabnine Agentic at $59–$60. Nine distinct commercial products plus the BYOK-open-source tier (Aider, Continue.dev) carry the shape — the settled architecture for the IDE/assistant layer, not one company’s experiment.

The defining move in the category is a retreat from flat or “unlimited” billing to credits, and that retreat is now essentially complete across the commercial cluster. Augment Code retired unlimited for a pooled credit model in October 2025; Cursor switched from request counts to a dollar-denominated API pool in June 2025; Qodo renamed “messages” to “credits,” doubled its Teams seat from $15 to $30, then in June 2026 dropped per-seat pricing entirely for a pooled $.012/credit model; GitHub Copilot replaced premium-request quotas with AI Credits in June 2026. Sourcegraph Cody moved to org-pooled AI credits for frontier-model access, and Tabnine split its rate card into a $39 Code Assistant seat and a $59 Agentic Platform tier during 2025. The pattern is now so consistent that a new entrant launching with a flat or unlimited plan is making an explicit contrarian bet, not just a default product decision.

Credits are priced per model, which exposes routing as the primary cost lever rather than usage volume alone. Augment Code publishes a per-model credit table; Cursor draws its API pool at each model’s posted per-token rate (Claude Opus 4.8 at $5/$25 per 1M vs Composer 2.5 at $0.50/$2.50); Qodo charges 1 credit for standard models but 5 for Claude Opus. The buyer’s model mix, not their seat count, drives the variable bill. Org-pooled credits are the standard fix at the team tier: GitHub Copilot pools credits across the billing entity (Business seats share 1,900 credits/user pooled org-wide); Augment Code and Cursor pool team credits so heavy users draw from light users automatically — a feature absent at the individual tier and the primary reason the team sticker price is worth more than a simple multiple of the individual tier.

Above the IDE/assistant layer, Cognition (Devin), Factory, Sweep AI, Imbue, Magic AI, and Poolside occupy a separate pricing tier where the seat-and-credit-pool model does not fully fit. These are agentic or autonomous systems where a single “task” — a complete feature branch, an end-to-end PR review, a refactor of an entire service — can consume what an IDE user spends in a week. Cognition meters ACUs (Agent Compute Units) that bundle compute and model cost into a task-level denomination, layered over a $20 Pro seat and an $80 + $40/seat Teams floor; Factory uses seat-tier inflation ($20 Pro → $100 Plus → $200 Max) with no per-token meter, throttling by rate limit rather than charging overage; Poolside and Magic AI publish no pricing at all. The app-builder tier — Bolt.new, Lovable, Replit AI, V0 by Vercel, and Claude Code — prices differently still, bundling compute, generation credits, and sometimes deployment together under a monthly token or credit package where the unit is “application generated” rather than “coding session attended.” Bolt.new meters raw tokens ($20 per 10M-token reload); Lovable meters complexity-weighted credits (100/mo on Pro, top-ups at ~$15 per 50); V0 spends $30/seat of monthly credits against per-model token rates.

Counterexamples & variants

The cleanest variant inside the cluster is the free-extension-as-Trojan-horse model. Codeium gives its editor extension away free forever — no seat, no completion cap — and monetizes only the standalone Windsurf IDE and the Enterprise extension. That model funded a $3B outcome, validating free-to-enterprise as a viable path that the seat-first members never tried. The open-source tier — Aider and Continue.dev — takes the same free-distribution logic further: zero vendor revenue from the tool itself, with all costs flowing directly to the model provider via the developer’s own API key. Continue’s case is especially instructive since its acquisition by Cursor pulled its hosted paid tiers off the public pricing page while the Apache-2.0 extension stayed free. These camps (freemium-then-monetize and pure-BYOK) show that the seat-plus-credits structure is a choice, not a requirement.

The starkest counterexample to “metered overage” used to be Qodo, which historically shipped no purchasable overage and let heavy users hit a productivity wall until the 30-day reset. As of its June 2026 repricing, Qodo inverted that: it now ships overage at the same $.012/credit rate, accruing against a monthly spending cap the buyer sets — so the productivity-wall risk became a controlled bill-shock risk instead. The remaining true no-overage design lives in the app-builder tier, where products like Bolt.new meter tokens so aggressively (a single complex prompt can burn ~200K tokens, and users report exhausting the 10M Pro allotment in ~3 days) that “error-loop tax” — paying tokens to fix the AI’s own mistakes — becomes the dominant unpredictable cost, not a clean overage line.

Augment Code is the variant that dropped the free tier entirely, starting at a $20 Indie seat with a 20-user ceiling on its self-serve plans. The missing free tier and the hard 20-seat cliff make Augment the least PLG-friendly member of the IDE cluster — a bet that a context-engine differentiator can pull buyers across a paywall the rest of the category keeps free. Tabnine makes an even sharper enterprise-first bet: no public free tier, quote-gated $39/$59 seats, plus a capacity-tiered Headless Agents add-on at $1,200/mo (5B tokens) or $5,000/mo (50B tokens) licensed by processing capacity rather than per seat — the only product in the corpus that meters agents by raw token throughput at the platform level.

The agentic tier introduces a fourth set of variants with no analog in the IDE cluster. Cognition’s ACU model is a task-level denomination that bundles compute and model cost rather than exposing token rates or credit tables — it is designed for workflows where the buyer thinks in features shipped, not requests made. Factory rejects overage metering entirely, pricing rate-limit headroom in flat $20/$100/$200 seat steps. Poolside and Magic AI represent the opacity variant: frontier labs with no published pricing, where the cost structure is still being calibrated and early customers negotiate bespoke, often multi-year, terms. Sweep AI offers yet another twist — unlimited autocomplete on every seat ($10 Basic / $20 Pro / $60 Ultra) with only chat and codegen drawing from a bundled API-credit allotment and optional auto-top-up, so the heavy autocomplete user never pays overage at all.

What this means for buyers vs vendors

For buyers

Model the credit pool, not the seat. The headline $10–$39 sticker is a floor; the real bill depends on how much agentic and frontier-model work your developers do beyond the bundled allowance. Ask three procurement questions: what is the per-model credit cost (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 — a dollar-denominated API pool (Cursor), metered overage (GitHub Copilot at $0.01/credit), auto top-up (Augment Code at $15/24,000 credits), or a spending cap you set (Qodo)? Use the Cursor pricing calculator or the Augment Code pricing calculator to model real spend before standardizing a team.

For teams evaluating agentic tools like Cognition Devin or Factory, the procurement model shifts entirely. Per-seat reasoning does not apply when the system runs autonomously for minutes to hours on a single task. Instead, benchmark per-task cost: ask the vendor how many compute units a typical feature ticket consumes, and build a task-volume forecast before committing. Watch for the tier-inflation trap on Factory — the only lever past a rate limit is a 5x or 10x per-seat jump ($20 → $100 → $200), not a metered top-up. For app builders like Bolt.new, Lovable, or Replit AI, estimate generation frequency and factor the “stack tax” — a shipping app usually needs a real database (Supabase Pro ~$25/mo on top of Bolt), and error-loop retries re-read the whole project and burn tokens fast.

For enterprise-first products with no public pricing — Tabnine, Poolside, Magic AI, Sourcegraph Cody (from $16K) — expect to negotiate seats plus a committed credit or compute pool, and price in forward-deployed engineering and multi-year commitments rather than a month-to-month card charge. See the introduction to usage-based pricing for the framework that makes these quotes comparable.

For vendors

Price on the unit your model bill scales with, which is usage, not headcount — but keep the seat as the legible anchor. The category’s history is unambiguous: flat and “unlimited” plans broke once frontier-model costs arrived, and the credit retreat (Cursor June 2025, Augment Code October 2025, Qodo and GitHub Copilot June 2026) carries trust cost when communicated poorly. Bundle a credit allowance into the seat, publish per-model credit costs for transparency, pool credits at the team tier, and decide your cap behavior deliberately — a hard wall reads as budget safety to a finance buyer but as a productivity risk to an engineer, while open-ended metered overage reads the opposite way. See the understanding prepaid credits models guide for how to design a credit unit that survives model-price churn, and the AI coding: seats to credits trend for the category’s evolution.

For vendors building agentic coding systems above the IDE layer, the design challenge is to find a denomination that is legible to buyers before they have experience with the product. Per-hour compute billing is too coarse and too unfamiliar — developers do not think in compute-hours for coding tasks. Per-task ACU or credit metering (Cognition) works better because it maps to a unit of work the buyer already understands (a PR, a feature, a review), but requires enough calibration data to publish a reference benchmark before the first enterprise negotiation. Factory’s rate-limited flat-seat model is the low-friction alternative: it sacrifices metered revenue capture for predictability, betting that buyers prefer a knowable $100/seat to a variable overage line.

The products on a longer-term trajectory toward outcome-based pricing — charging per merged PR or per resolved ticket — will face the additional challenge of attribution: not every autonomous coding attempt produces a shippable result, and the pricing model needs to handle partial-success cases without creating perverse incentives. The frontier labs that publish nothing today (Poolside, Magic AI) are effectively deferring this decision until they have enough deployment data to price a unit that will not immediately be re-negotiated — a defensible stance while the model economics are still moving, but one that keeps them out of the self-serve funnel the rest of the category depends on.

Explore this theme in the knowledge graph →