Augment Code pricing

About

Augment Code is an AI coding assistant built for large, production-scale codebases. Its core differentiator is a “Context Engine” that indexes a team’s full repository so that chat, IDE agents, the Auggie CLI, and asynchronous cloud agents can reason over real project context rather than a single open file. The product spans VS Code, JetBrains IDEs, Vim/Neovim, a command-line agent, an MCP server, and Augment Code Review for GitHub pull requests, plus “Cosmos” cloud sandboxes that run agent sessions on managed VMs.

The company sells primarily to professional developers and engineering teams — the pricing page leads with “Pricing that scales with you & your team” and is anchored by a per-developer seat. Augment positions itself against other AI-coding incumbents on context depth and production readiness (“AI built for production scale codebases”), and emphasizes that paid plans exclude AI training on customer data, with SOC 2 Type II, CMEK, and ISO 42001 compliance available on enterprise tiers.

Augment is a privately held developer-tools company. Founded in 2022 by Igor Ostrovsky (former chief architect at Pure Storage) and Guy Gur-Ari (an AI researcher from Google), it emerged from stealth on April 24, 2024 with a $227M Series B at a $977M post-money valuation, backed by Sutter Hill Ventures, Index Ventures, Lightspeed, Innovation Endeavors, Meritech and Evolution Equity — bringing total funding to roughly $252M. Public ARR and headcount figures are not disclosed.

Augment’s pricing has been unusually mobile for a company this young. In under 18 months it moved through four distinct models — a single “$60 per active developer” usage credit (2024), three “unlimited” subscription tiers (early 2025), a “user message” metering scheme (mid-2025), and finally a pooled credit model (October 2025). That trajectory, traced below from Wayback snapshots, is the most informative part of this entry: it is a real-time case study in how an AI-coding vendor walks back unlimited usage as inference costs bite.

Pricing summary : How Augment Code’s seat-plus-credit-pool model works

Augment Code uses a hybrid model that combines a per-developer seat with a pooled allotment of usage credits, so it sits between pure per-seat pricing and pure consumption pricing. The model has two dimensions:

1. Per-developer seat (the subscription floor): Indie is $20/month (up to 1 user), Standard is $60/month per developer (up to 20 users), Max is $200/month per developer (up to 20 users), and Enterprise is custom (unlimited users). Each seat bundles a fixed monthly credit allotment — 40,000 / 130,000 / 450,000 respectively, and custom for Enterprise.
2. Usage credits (the metered layer): Every task consumes credits at a per-model rate — 293 credits for a standard task on Claude Sonnet 4.6, 488 on Opus 4.7, 88 on Haiku 4.5, 268 on Gemini 3.1 Pro, 219 on GPT-5.1. Credits are pooled at the team level. When the pool runs out, auto top-up is available at $15 per 24,000 credits, and purchased top-up credits stay valid for 12 months.

What makes this different: the seat price and the credit allotment scale together step-wise (more expensive seats simply bundle proportionally more credits), and because credits are pooled and consumed at model-specific rates, the effective unit cost of a task depends on which model a developer routes it to — making model selection itself a seat-plus-usage cost lever.

Pricing by product

Augment Code (per-developer seat plans)

Sales motions across products: PLG / self-serve for Indie, Standard, and Max (install and pay online); sales-led for Enterprise (contact sales, custom quote).

Per-model credit costs inside the pool

Each plan’s credit allotment is consumed at different rates depending on the model routed to a task. Costs below are for a standard medium-complexity task; actual consumption varies with task complexity, context size, and response length (per the docs credit-based-pricing page).

Additional metered items outside the seat allotment: auto top-up at $15 per 24,000 credits (top-up credits valid 12 months), and Cosmos sandboxes billed separately at 300 credits/hour, prorated in 5-minute increments. Prism routing is designed to cost, on average, 20–30% less than frontier-model rates.

Hidden costs : What heavy teams actually spend on credit top-ups

The headline seat price ($20 / $60 / $200) is a floor, not a ceiling. The real bill is set by how fast a team burns through its bundled credit pool and how much it pays for top-ups — and because credits are consumed at per-model rates, the same workload can cost very differently depending on routing.

Where the bill actually grows:

Worked example — a 10-developer Standard team. The pool is 10 × 130,000 = 1,300,000 credits/month for $600. At ~293 credits per standard Sonnet task, that’s roughly 4,400 tasks — but a small task can be ~300 credits and a complex 60-tool-call task ~4,300 credits, so a team doing heavy agentic work hits the pool fast. Three power users averaging 4,300-credit tasks several times a day can consume hundreds of thousands of credits alone, after which every additional 24,000 credits costs $15 on top of the seat fee. The marginal cost is what surprises buyers, not the sticker.

This is the trade Augment made when it left “unlimited” behind in October 2025 (see Pricing evolution): the floor got cheaper-looking, but heavy usage is now metered.

Want to estimate your own Augment Code bill? Use the Augment Code pricing calculator to model your monthly cost based on seat count, credit allotment, and per-model task volume.

Pricing evolution : From seat licenses toward a pooled credit model

In under two years Augment cycled through four billing metrics — usage credits, “unlimited” subscriptions, user messages, and finally a pooled credit pool. Few vendors restructure pricing this often, which makes the trajectory worth reading closely.

Cadence

Tracked range: 2024-11-06 to 2026-06-02, sampled from Wayback snapshots of augmentcode.com/pricing and company blog announcements.

Notable changes

• 2024-11-06 — Launch model: $60 per active developer, no named seats, unlimited usage per active dev, 12-month credit rollover (Wayback).
• 2025-02-20 — Three “unlimited” tiers: Community $0 (3,000 chat messages, AI training permitted), Professional $30/user/mo, Enterprise $60/active user/mo (Wayback).
• 2025-05-05 — “Unlimited Agent for now”: Developer $30/mo (550 agent requests); FAQ openly warns limits are 30 days out (Wayback).
• 2025-06-04 — Move to user-message metering: Developer $50 (600), Pro $100 (1,500), Max $250 (4,500); messages pooled at team level, extra $30/300, valid 12 months (Wayback + blog).
• 2025-09-14 — Entry tier renamed Indie at $20 (125 messages, extra $15/100); $20 anchor first appears (Wayback).
• 2025-10-20 — Pivot to credits: Indie $20 (40k), Standard $60 (130k), Max $200 (450k); top self-serve tier drops from $250 to $200 (blog).
• 2025-11-16 — Credit tiers live and stable through the 2026-06-02 capture (Wayback).

The October 2025 unlimited-to-credits pivot in detail

This is the inflection that defines Augment’s pricing story. Through early 2025 the product leaned hard on “unlimited” — the 2025-02 page advertised unlimited chats, completions, instructions and Next Edit on every paid tier, and when agents shipped the 2025-05 page promised “Unlimited Agent for now” while candidly warning a pricing model was 30 days out.

The economics didn’t hold — a recurring problem we cover in pricing an AI product with unpredictable costs. In the October announcement, Augment said the user-message metric had become “unfair to Augment Code customers” because it priced a trivial message the same as a massive agentic task, and disclosed that one user ran “335 requests per hour, every hour, for 30 days” — approaching “$15,000 per month in cost to Augment Code.” Effective 2025-10-20, plans moved to a pooled credit model and the top self-serve tier dropped from $250 (Max, 4,500 messages) to $200 (Max, 450,000 credits).

The community reaction was sharp. On r/AugmentCodeAI users described the migration as a “bait-and-switch”; legacy customers complained their grandfathered allotments converted to fewer credits than expected, and individual reports surfaced of large credit drawdowns (one user citing tens of thousands of credits consumed in a day before cancelling). An accompanying HN thread, “Augment Code: 22.5% of our users are consuming 20x what they’re currently paying” (11 points, 2025-10-14), captured the core tension: commenters argued the prior unlimited pricing was always an “inference game” that forced an eventual reckoning, while others felt grandfathering promises were broken. Augment posted a public “Addressing community feedback on our new pricing” response — a vendor walk-back that itself functions as a trust event. See Areas to improve for the unresolved gaps.

What’s unique : Pooled credits and per-model routing as cost levers

1. Pooled team credits. Credits are pooled at the team level — a 20-seat Standard team gets 20 × 130,000 = 2,600,000 credits/month shared across developers, so heavy users draw on lighter users’ unused allotments. This pooling mechanic predates the credit model: it first appeared in the June 2025 “user message” scheme (pooled messages, extra valid 12 months) and carried straight over to credits, making it the one constant across Augment’s pricing churn.

2. Routing as a published cost lever. Augment is unusually explicit that model choice is a pricing decision. The docs list per-task credit costs across the whole model family — 88 for Haiku 4.5 up to 488 for Opus 4.7 — so the same prompt can be 5.5× more expensive depending on routing, and the Prism router is sold as landing 20–30% under frontier rates. Few competitors expose this granularity; most bury model-cost differences inside an opaque credit.

3. A pricing model that visibly walked back “unlimited.” What’s genuinely distinctive is the trajectory itself. Augment publicly committed to unlimited usage, openly flagged it as temporary, and then metered it — first by messages, then by credits — within a single year. That makes its pricing page a live document of the AI-coding industry’s broader retreat from flat-rate unlimited toward seat-plus-usage metering — the same entitlement-to-credits billing shift playing out across LLM products.

Strengths & weaknesses

Billing UX : Credit dashboards, pooled allotments, and auto top-up

• Credit usage in the IDE — VS Code shows credit usage in the Augment panel; JetBrains surfaces usage stats in the Augment tool window; the Auggie CLI reports credits used per session.
• Web usage dashboards — app.augmentcode.com shows total credits used by the team, per-team-member usage, breakdown by model and activity, usage trends over time, and remaining credits in the plan.
• Team-pooled credit allotment — credits are pooled at the team level (seat allowance × seat count), so administrators manage one shared pool rather than per-seat budgets.
• Auto top-up — opt-in top-up at $15 per 24,000 credits when the pooled allotment runs low; purchased top-up credits remain valid for 12 months.
• Usage breakdown by activity — analytics separate Chat, Agent, RemoteAgent, and CliAgent sessions plus optional features (Prompt Enhancer, Code Review) and background activities (Context Compression, System).
• Prism routing control — selecting a Prism family hands model choice to Augment’s router, which is designed to land 20–30% under frontier-model credit costs per request.

Strategic wins : Decisions that strengthened the model

1. Publishing a per-model credit table

Augment exposes the exact per-task credit cost of every model in its docs — 88 credits for Haiku 4.5 up to 488 for Opus 4.7 — turning model selection into a transparent cost lever. This was a direct response to the prior model’s flaw: under “user messages,” a trivial message and a 60-tool-call agentic task cost the same, which Augment itself called “unfair.” Pricing per model realigns the bill with the cost Augment actually incurs. See our coverage of usage-based pricing fundamentals.

2. Tying each seat to a proportional credit pool

Each higher-priced seat bundles a larger allotment (40k → 130k → 450k), so the headline stays a simple per-developer price while usage is still metered underneath — a clean seat-plus-usage packaging choice. It preserves the buyer-friendly “pick a seat” mental model that the 2025-02 unlimited tiers had, while restoring the metering the business needs.

3. Carrying the pooling mechanic across every pricing model

Team-level pooling (seat allowance × seat count) lets power users draw on lighter users’ unused credits, smoothing uneven usage without per-seat overages. Notably, Augment kept this mechanic constant from the June 2025 “user message” scheme through the October credit pivot — a rare point of continuity that softened buyer friction around credit-based billing during an otherwise disruptive change.

4. Owning the pivot with a candid rationale

Rather than quietly changing prices, Augment published the specific outlier that broke the old model — a user driving “335 requests per hour… approaching $15,000 per month in cost” — and shipped one month of bonus credits plus personalized usage forecasts. Transparency about the why, even when the change is unpopular, is a defensible pricing-communication move worth emulating.

Areas to improve : Gaps worth closing

1. Rebuilding trust after the credit pivot

The October 2025 migration was the clearest improvement opportunity Augment created for itself. r/AugmentCodeAI threads used “bait-and-switch” language, legacy users reported grandfathered allotments converting to fewer credits than promised, and an HN thread surfaced the perception that migration commitments were broken. The bonus credits helped, but a clearer, individually-verifiable conversion guarantee (old plan X → exactly Y credits) would have blunted the worst of the backlash. Frequent pricing changes are themselves a tax on trust.

2. Opaque credit-to-task mapping

The per-model table gives task-level estimates, but real consumption “varies based on task complexity, context size, and response length,” so buyers cannot reliably forecast a monthly bill before running workloads — exactly the complaint that surfaced when users reported “31 messages = ~41,000 credits.” A published budgeting calculator or worked monthly examples would close the gap. See our usage-based pricing guide on forecasting metered spend.

3. The lost free tier and the 20-user ceiling

Augment ran a free Community plan through most of 2025 and removed it in the credit transition, so the entry point is now a paid $20/mo Indie seat with only trials below it (community support, no SLA). Reinstating a small evergreen free allotment would lower the funnel barrier for the individual-developer audience the product courts. Separately, both self-serve team plans cap at 20 users, pushing growing teams into a sales-led Enterprise quote earlier than necessary; a documented per-seat overage path would smooth that cliff — compare how other credit-based billing vendors handle seat expansion.

Key takeaways

1. Unlimited was a phase, not the plan. Augment moved from “$60 per active developer” credits (2024) to three unlimited tiers (early 2025) to user messages (mid-2025) to a pooled credit pool (October 2025) — four metrics in under 18 months. The current model is the endpoint of a visible retreat from flat-rate unlimited.
2. The pivot was driven by real cost outliers. Augment disclosed a single user running “335 requests per hour, every hour, for 30 days,” approaching “$15,000 per month in cost” — the concrete justification for abandoning message-based pricing.
3. Per-model rates make routing a pricing decision. Publishing 88 credits for Haiku versus 488 for Opus 4.7 (a 5.5× spread) lets buyers manage spend through model choice rather than burying model cost in an opaque credit.
4. Pooling was the constant that softened the change. Team-level pooling carried over unchanged from the message model to the credit model, letting power users borrow lighter users’ allotments and giving buyers one stable mechanic amid the churn.
5. Frequent repricing carries a trust cost. The October migration drew “bait-and-switch” backlash on r/AugmentCodeAI and a public vendor response; bonus credits and forecasts helped but did not fully offset the perception of broken grandfathering promises.

UBP implications

1. Flat-rate “unlimited” is structurally unstable for agentic AI. When the underlying cost is variable inference and a power user can drive $15k/month, an unlimited promise becomes a liability. Augment’s trajectory is a worked example of why seat-plus-usage metering tends to win out.
2. Per-model unit economics belong in the open. Exposing task-level credit costs (88 vs 488) aligns vendor margin with customer model choice and makes routing a legitimate cost lever rather than a hidden one — a pattern other usage-priced AI vendors should copy.
3. How you migrate matters as much as where you land. Augment’s destination model is defensible, but the “bait-and-switch” reaction shows that grandfathering clarity, individually-verifiable conversions, and over-communication during a pricing change are what protect retention — the change mechanics, not just the new prices. Our guide to usage-based pricing migration for SaaS details the playbook Augment partly skipped.

Sources

• Augment Code pricing page (accessed 2026-06-02)
• Augment Code credit-based pricing docs (accessed 2026-06-02)
• Augment Code available models docs (accessed 2026-06-02)
• Augment Code “Our pricing is changing” announcement (accessed 2026-06-02)
• Augment Code blog (accessed 2026-06-02)
• Augment Code changelog (accessed 2026-06-02)

Browse the full pricing blueprint to compare Augment Code with other AI-coding pricing models.

Bottom line

Augment Code prices AI coding as a per-developer seat that bundles a pooled, model-metered credit allotment — $20/$60/$200 a month for 40k/130k/450k credits, topped up at $15 per 24,000 — so the bill stays predictable at the seat level while real cost flexes with how heavily a team works and which models it routes to.

Want to compare Augment Code against other AI-coding pricing? Browse the pricing blueprint.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Credit-based seat plans with published per-model rates

Jun 2026

Current page (captured 2026-06-02): Indie $20/mo (40,000 credits), Standard $60/mo (130,000 credits), Max $200/mo (450,000 credits), Enterprise Custom. Auto top-up $15 per 24,000 credits (valid 12 months); per-task credit costs are now published per model (293 Sonnet 4.6, 488 Opus 4.7, 88 Haiku 4.5), and Cosmos sandboxes meter at 300 credits/hour outside the seat allotment.

Credit tiers live: Indie / Standard / Max / Enterprise

Nov 2025

The 2025-11 page (Wayback 2025-11-16) shows the credit structure that holds today: Indie $20/mo (40,000 credits), Standard $60/mo (130,000 credits), Max $200/mo (450,000 credits), Enterprise Custom. Auto top-up is $15 per 24,000 credits. The Developer and Pro message tiers were dropped, and the top self-serve tier fell from $250 (Max, messages) to $200 (Max, credits). Source: web.archive.org/web/20251116034900/https://www.augmentcode.com/pricing.

Pivot to credit-based pricing (effective 2025-10-20)

Oct 2025

Augment announced (blog/augment-codes-pricing-is-changing) that on 2025-10-20 plans move from 'user messages per month' to a pooled credit model, citing the old metric as 'unfair' — one user ran '335 requests per hour, every hour, for 30 days,' approaching '$15,000 per month in cost to Augment Code.' Existing customers got one month of bonus credits (valid 3 months). The change drew community pushback on r/AugmentCodeAI ('bait-and-switch') and an HN thread; Augment posted a public 'Addressing community feedback on our new pricing' response.

Entry tier renamed Indie ($20); message tiers retained

Sep 2025

The 2025-09 page (Wayback 2025-09-14) kept the message model but reshaped the entry: Indie $20/mo (125 user messages, additional $15/100), Developer $50/mo (600), Pro $100/mo (1,500), Max $250/mo (4,500), Enterprise Custom. 'Indie' and the $20 price point that anchor today's pricing first appear here. Source: web.archive.org/web/20250914075451/https://www.augmentcode.com/pricing.

Switch to a 'user message' metering model

Jun 2025

By 2025-06 (Wayback 2025-06-04, announced via blog/new-simpler-pricing-with-user-messages) Augment metered by 'user messages': Community $0 (50 messages), Developer $50/mo (600), Pro $100/mo (1,500), Max $250/mo (4,500); additional messages $30/300. Messages were pooled at the team level (a 20-dev Pro team = 30,000 messages/mo) and extra messages stayed valid 12 months — the pooling and 12-month-expiry mechanics that survive to today. Source: web.archive.org/web/20250604231818/https://www.augmentcode.com/pricing.

'Unlimited agent for now' — the first caveat

May 2025

After launching agents, the 2025-05 page (Wayback 2025-05-05) listed Community $0 (50 requests/mo), Developer $30/mo (550 agent requests, 'Unlimited Agent for now'), and Enterprise Custom. An FAQ openly warned: 'These advanced models do come with real costs... We'll share our plans with you in the next 30 days,' and noted month-to-month billing so users could opt out 'when changes occur.' First explicit signal that unlimited was temporary. Source: web.archive.org/web/20250505121514/https://www.augmentcode.com/pricing.

Three named tiers, everything unlimited

Feb 2025

By 2025-02 (Wayback 2025-02-20) Augment had three published tiers, all with unlimited completions/chats/instructions/Next Edit: Community $0/mo (3,000 chat messages, AI training permitted), Professional $30/user/mo (no AI training), and Enterprise $60/active user/mo. This was the high-water mark of the 'unlimited' positioning. Source: web.archive.org/web/20250220091228/https://www.augmentcode.com/pricing.

Launch model: $60 per active developer, no named seats

Nov 2024

Earliest archived pricing (Wayback 2024-11-06) shows a single usage-based plan: $60 per active developer per month with a minimum purchase of 120 credits. Credits were 'prepaid monthly developer usage units' with no named seats — any team member could draw a monthly credit, and a developer could 'use Augment Code as much as they want. No overages or extra fees.' Unused credits rolled over for 12 months. Source: web.archive.org/web/20241106035542/https://www.augmentcode.com/pricing.