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 two years it moved through a single “$60 per active developer” usage credit (2024), three “unlimited” subscription tiers (early 2025), a “user message” metering scheme (mid-2025), a pooled credit model (October 2025), and — as captured 2026-07-28 — a flat $100/month Business plan (up to 50 seats) billed on real LLM token cost plus a 40% service fee, replacing the per-developer Indie/Standard/Max credit tiers entirely. 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 keeps reshaping pricing as inference costs and packaging pressure evolve.

Pricing summary : How Augment Code’s flat-fee-plus-real-cost model works

Augment Code uses a hybrid model that combines one flat monthly team fee with usage billed at real, pass-through cost, so it sits closer to subscription pricing at the entry point than to per-seat billing. The model has two dimensions:

1. Flat team subscription (the floor): Business is $100/month flat for the whole team — up to 50 seats, with no per-seat charge. Enterprise is custom, with bespoke usage limits, custom user pricing, and unlimited users.
2. Usage billed at real cost (the metered layer): The $100/month on Business includes $100 of usage across three components: LLM tokens at the model provider’s public API list price, a flat 40% service fee on LLM usage (no fee on compute), and Cosmos compute at $0.19/hour (billed in 5-minute increments). Once the included $100 is consumed, billing continues automatically on pay-as-you-go at the same rates, with no minimum top-up.

What makes this different: Augment dropped the abstracted “credit” entirely — the docs now publish the exact per-million-token input/output/cache rates for every routed model (e.g. $3/$15 for Claude Sonnet 4.6, $5/$25 for Claude Opus 4.7, $1/$5 for Claude Haiku 4.5), so a customer’s bill is literally the provider’s list price plus Augment’s disclosed 40% markup rather than a converted currency — making usage-based pricing transparency the headline feature of the plan, not just the seat price.

Pricing by product

Augment Code (team plans)

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

Token costs by model (inside the Business usage balance)

Augment dropped its abstracted “credit” unit in mid-2026: usage is now billed directly at each model provider’s public API list price per million tokens, plus a flat 40% service fee on LLM usage (no fee on compute). Rates below are per million tokens; GPT model rates are the standard (default) API tier.

Additional metered items outside the $100 included balance: Cosmos compute at $0.19/hour, billed in 5-minute increments (rounded up), with no service fee; and pay-as-you-go top-ups once the included $100 is used, at the same token, service-fee, and compute rates, with no minimum top-up amount. Prism routing is designed to cost, on average, 20–30% less than frontier-model rates. As of 2026-08-11, Claude Sonnet 5 and Claude Opus 4.5 were added to the routed model roster at the same rate as their siblings ($3.00/$15.00/$0.30/$3.75 and $5.00/$25.00/$0.50/$6.25 respectively), and GPT-5.6 Terra and GPT-5.6 Luna both got cheaper — a ~20% cut on Terra and a ~80% cut on Luna, the largest per-model rate move since the token-pricing table launched (exact before/after figures in Pricing evolution). As of 2026-08-26, two new models joined the roster with no changes to any existing model’s rate: Gemini 3.7 Flash ($0.375/$1.875/$0.0375/$0.375) and Grok 4.6 ($2.00/$6.00/$0.50/$0.00) — the first xAI model Augment has published a rate for.

A typical $100 month, per Augment’s docs: as of 2026-08-26 (unchanged since 2026-08-11), $70 on LLM tokens (input/output at public API list price), $28 service fee (40% of LLM spend), and $2 on Cosmos compute — totaling the full $100 included balance. Docs also publish worked task costs at list rates: a routine bug-fix task runs about $0.25 on Sonnet 5 (or 4.6/4.5) versus $0.43 on Opus 5 (or 4.8/4.7/4.6/4.5) versus $0.08 on Haiku 4.5 versus $0.02 on the newly-discounted GPT-5.6 Luna; a complex multi-tenant billing design runs about $0.85 on Opus 5. Actual mix depends on models chosen, Cosmos usage, and task size.

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 credits to flat-fee, real-token-cost billing

In under two years Augment cycled through five billing metrics — usage credits, “unlimited” subscriptions, user messages, a pooled credit pool, and (from mid-2026) flat-fee billing at real token cost — with a further per-model rate adjustment layered on top in August 2026. Few vendors restructure pricing this often, which makes the trajectory worth reading closely.

Cadence

Tracked range: 2024-11-06 to 2026-08-11, sampled from Wayback snapshots of augmentcode.com/pricing, company blog announcements, and direct captures of docs.augmentcode.com/models/token-based-pricing.

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).
• 2026-07-28 — Credits retired: between the 2026-06-02 and 2026-07-28 captures, Augment replaced the per-developer Indie/Standard/Max credit tiers with one flat $100/mo Business plan (up to 50 seats, no per-seat charge) billed at real LLM token cost plus a 40% service fee; Enterprise stayed custom (direct capture, docs.augmentcode.com/models/token-based-pricing).
• 2026-08-11 — Per-model token rate cut on the Business plan’s usage table: GPT-5.6 Terra fell from $2.50/$15.00 to $2.00/$12.00 per million input/output tokens (cache read $0.25→$0.20, cache write $3.125→$2.50), and GPT-5.6 Luna fell from $1.00/$6.00 to $0.20/$1.20 (cache read $0.10→$0.02, cache write $1.25→$0.25) — the largest per-model rate move since the token-pricing table launched. Claude Sonnet 5 and Claude Opus 4.5 joined the routed roster at existing sibling rates; the Prism (GPT) route dropped Kimi K2.6. Augment’s illustrative “typical $100 month” usage mix also shifted from $60 LLM / $24 fee / $16 compute to $70 LLM / $28 fee / $2 compute (docs.augmentcode.com/models/token-based-pricing).

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 : A flat team fee over real, pass-through token cost

1. A flat team fee decoupled from seat count. Business is a single $100/month price for the entire team — up to 50 seats — with no per-seat charge, a sharp departure from the per-developer $20/$60/$200 tiers Augment ran through mid-2026. Most AI-coding competitors price per seat; Augment’s flat floor means a 2-person team and a 45-person team pay the same base price, so unit economics live entirely in the metered usage layer rather than in seat count.

2. Real, pass-through cost pricing instead of an abstracted credit. Augment dropped its “credit” unit entirely by the 2026-07-28 capture: the docs now publish the exact per-million-token input/output/cache rate for every routed model, so a bill is literally the model provider’s list price plus Augment’s disclosed 40% service fee — not a converted currency. Few AI-coding vendors expose this granularity; the credit abstraction is nearly universal because it makes a bill easier to read at the cost of transparency, and Augment has now bet against that convention twice — replacing “user messages” with credits in October 2025, then replacing credits with real token cost in mid-2026.

3. Published rate cuts that move with the market. Because the token table is the real price rather than a fixed credit conversion, Augment can reprice individual models as underlying provider economics shift — on 2026-08-11 it cut GPT-5.6 Luna 80% and GPT-5.6 Terra 20% while adding Claude Sonnet 5 and Claude Opus 4.5 to the roster at existing sibling rates. That kind of granular, model-by-model repricing wasn’t possible under the old flat-credit system, where a rate change meant recomputing an entire credit-to-dollar peg.

4. A pricing model that visibly walked back “unlimited,” then walked back credits too. Augment publicly committed to unlimited usage, openly flagged it as temporary, metered it first by messages then by credits (October 2025) — and by 2026-07-28 had abandoned the credit abstraction altogether for direct token billing. 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 and then further toward real-cost transparency — the same entitlement-to-credits billing shift playing out across LLM products, now inverted.

Strengths & weaknesses

Billing UX : Dollar-denominated usage dashboards, pooled team balance, and auto top-up

• Usage dashboards in dollars — app.augmentcode.com shows total usage by the team in dollars, usage per team member, a breakdown by model, activity, and component (LLM, service fee, compute), usage trends over time, and remaining included usage vs. pay-as-you-go spend.
• Auggie CLI usage monitor — the CLI reports token/dollar usage per session directly as you work.
• Team-pooled usage balance — the included $100/month and any top-ups are pooled across the whole team (up to 50 seats on Business), so heavy and occasional users draw from the same shared balance rather than per-seat budgets.
• Pay-as-you-go top-ups — once the included $100 is consumed, billing continues automatically at the same token, service-fee, and compute rates, with no minimum top-up amount and no plan changes required.
• Usage breakdown by activity — analytics separate session types (CliAgent, Cosmos), optional features (Prompt Enhancer, Code Review, Skills), 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 costs per request.

Strategic wins : Decisions that strengthened the model

1. Publishing a per-model token-rate table

Augment exposes the exact per-million-token input/output/cache rate for every routed model in its docs — from $0.20/$1.20 for GPT-5.6 Luna (after an 80% cut on 2026-08-11) up to $5.00/$25.00 for Claude Opus 4.5 — turning model selection into a transparent, dollar-denominated cost lever. This is a direct response to two prior model flaws: under “user messages,” a trivial message and a 60-tool-call agentic task cost the same, which Augment itself called “unfair”; under credits, the credit-to-dollar conversion was an added layer of abstraction. Pricing directly in tokens realigns the bill with the cost Augment actually incurs. See our coverage of usage-based pricing fundamentals.

2. Replacing the credit pool with a flat team price and real-cost billing

Rather than incrementally raising credit allotments, Augment cut over entirely by the 2026-07-28 capture: Business is now one flat $100/month price for up to 50 seats, with usage billed at real LLM token cost plus a disclosed 40% fee instead of a credit abstraction. It preserves the buyer-friendly “pick a plan” simplicity the 2025-02 unlimited tiers had, while making the metering underneath fully legible — a buyer can see exactly what a Sonnet 5 task costs versus an Opus 4.5 task, not just how many credits it burns. This plan structure superseded the per-seat credit pools (40k/130k/450k) that defined Augment’s pricing through mid-2026, covered in Pricing evolution.

3. Carrying the pooling mechanic across every pricing model

Team-level pooling has now survived three different metering units — messages (mid-2025), credits (October 2025), and a single dollar-denominated usage balance (the 2026 Business plan) — letting the whole team draw from one shared allotment rather than per-seat overages. It’s a rare point of continuity that has softened buyer friction through two disruptive repricings, most recently the move from per-seat credit pools to one flat team balance.

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.

5. Passing model-cost deflation straight through to customers

When GPT-5.6’s underlying provider economics improved, Augment cut its own Luna and Terra rates 80% and 20% respectively on 2026-08-11 rather than holding rates steady and keeping the difference — a natural consequence of pricing at real cost plus a fixed 40% fee. Because the markup is a percentage of cost, not a fixed spread, provider-side price cuts flow through to the published table automatically, which is the clearest evidence yet that the disclosed-cost-plus-fee model isn’t just a transparency gesture.

Areas to improve : Gaps worth closing

1. Rebuilding trust after repeated repricing

The October 2025 credit 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. Augment then repriced again by 2026-07-28 (dropping credits for a flat $100/mo Business plan billed at real token cost) and again on 2026-08-11 (cutting individual model rates) — three structural pricing changes in under two years. Each change may be individually defensible, but the cumulative cadence is itself a tax on trust that a dedicated public pricing changelog (not just docs updates) would help offset.

2. Opaque token-cost forecasting

The per-model table gives task-level dollar estimates, but real consumption “depends on the model you choose, how much repo context the request loads, and whether the task uses Cosmos compute,” so buyers cannot reliably forecast a monthly bill before running workloads. The table itself is explicitly a “snapshot” that “changes over time” — as the 2026-08-11 rate cuts show — with no published history of prior rates, so a team can’t see how much cheaper (or more expensive) a model got without comparing captures side by side. A published rate-change changelog alongside a budgeting calculator would close both gaps. See our usage-based pricing guide on forecasting metered spend.

3. The lost free tier and the 50-seat ceiling

Augment ran a free Community plan through most of 2025 and removed it in the credit transition, so the entry point is now the $100/mo flat Business plan with only trials below it (community support, no SLA) — a materially higher floor than the $20/mo Indie seat it replaced. Reinstating a small evergreen free allotment would lower the funnel barrier for the individual-developer audience the product courts. Separately, Business caps at 50 seats, pushing growing teams into a sales-led Enterprise quote; a documented self-serve path past 50 seats would smooth that cliff — compare how other token-based vendors handle team growth.

Key takeaways

1. Unlimited was a phase, credits were too. 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) to a flat $100/mo team plan billed at real token cost (by 2026-07-28) — five pricing metrics in under 22 months, with the credit abstraction itself later discarded for direct pass-through billing.
2. The credit 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 in October 2025.
3. Publishing real per-token rates makes routing a transparent pricing decision. The docs list exact dollar rates per model — from $0.20/$1.20 for GPT-5.6 Luna (after an 80% cut on 2026-08-11) up to $5.00/$25.00 for Claude Opus 4.5 — letting buyers manage spend through model choice with the actual cost visible, not an opaque credit conversion.
4. Pooling was the one constant across three different meters. Team-level pooling carried unchanged from the message model through the credit model and into the current flat team balance, giving buyers one stable mechanic amid three structural repricings.
5. Frequent, compounding repricing carries a trust cost. The October 2025 credit migration drew “bait-and-switch” backlash on r/AugmentCodeAI; Augment then repriced twice more within a year (the mid-2026 flat-fee pivot and the 2026-08-11 per-model rate cuts), meaning even well-justified individual changes accumulate into a pattern buyers now expect to continue.

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 — unlimited to messages to credits to real token cost — is a worked example of why usage-anchored metering keeps winning out over flat promises.
2. Real per-token unit economics beat an abstracted credit. Augment’s move from credits to publishing exact per-million-token rates — and cutting GPT-5.6 Luna 80% on 2026-08-11 as soon as it could — shows that pricing directly at cost-plus-fee, rather than through a converted credit, both builds trust and lets provider-side discounts pass straight through to customers, a pattern other usage-priced AI vendors should copy.
3. How you migrate matters as much as where you land. Augment’s current model is defensible, but three structural pricing changes in under two years (messages → credits → real token cost, plus routine rate adjustments) show that grandfathering clarity, individually-verifiable conversions, and over-communication during each 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-08-15)
• Augment Code token-based pricing docs (accessed 2026-08-15)
• Augment Code available models docs (accessed 2026-08-15)
• 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 one flat $100/month team plan — up to 50 seats, no per-seat charge — with usage billed at real LLM token cost plus a disclosed 40% service fee, having retired its earlier per-developer credit tiers entirely; because the markup is a fixed percentage of real cost, provider-side price cuts, like the 80% drop on GPT-5.6 Luna on 2026-08-11, flow straight through to the published rate table.

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.

GPT-5.6 Terra and Luna token rates cut; Sonnet 5 and Opus 4.5 added to the roster

Aug 2026

Business/Enterprise plan prices unchanged ($100/mo flat, up to 50 seats), but the published per-model token table (docs.augmentcode.com/models/token-based-pricing) dropped GPT-5.6 Terra from $2.50/$15.00 to $2.00/$12.00 per million input/output tokens (-20%) and GPT-5.6 Luna from $1.00/$6.00 to $0.20/$1.20 (-80%). Claude Sonnet 5 and Claude Opus 4.5 were added to the roster at existing sibling rates, and the Prism (GPT) route (formerly 'Prism (GPT + Kimi)') dropped Kimi K2.6 in favor of GPT-5.6 Sol/Luna. Augment's illustrative 'typical $100 month' usage mix also shifted from $60 LLM/$24 fee/$16 compute to $70 LLM/$28 fee/$2 compute.

Credits retired: one flat $100/mo Business plan billed at real token cost

Jul 2026

Sometime between the 2026-06-02 and 2026-07-28 captures, Augment retired the per-developer Indie/Standard/Max credit tiers entirely and replaced them with a single Business plan: $100/month flat for the whole team (up to 50 seats, no per-seat charge), with usage billed at the model provider's public API list price plus a flat 40% service fee — dropping the abstracted 'credit' unit altogether. Enterprise stayed custom. The docs' per-model credit table was replaced by a per-model token-rate table (docs.augmentcode.com/models/token-based-pricing), and Cosmos compute continued metering separately at $0.19/hour.

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.