Intent Pricing: Credits, Models & True Cost per Dev

Intent uses the same credit-based pricing as other Augment Code features, with no separate charge. Standard costs $60 per developer per month with 130,000 pooled credits per seat, and Max costs $200 per developer per month with 450,000 pooled credits per seat. Published examples put a small task with roughly 10-11 tool calls at around 300 credits and a complex task with around 60 tool calls at around 4,300 credits, depending on model selection and task complexity.

How to Budget for Intent Without Surprises

Credit-based pricing trips up teams in a few predictable ways. Most teams budget by seat count when the real driver is tool-call volume, which scales roughly 14.5x between small and complex tasks. Teams also default to Opus for every task when Haiku handles the majority of Implementor work at about 30% of the cost. A third pattern catches teams by surprise: a single Intent spec execution runs a Coordinator plus parallel Implementors plus a Verifier, so credit burn compounds across three or four agents at once.

The rest of this guide maps each failure mode to a concrete lever. Plan selection, pooling behavior, per-agent model routing, BYOA economics, and the break-even math between Standard-plus-top-ups and Max each get their own section. Pricing and product figures come from the linked pricing pages, product pages, and documentation cited throughout.

Intent Pricing Tiers: Standard ($60/mo) vs. Max ($200/mo)

Intent does not carry separate pricing. Credits consumed in Intent work the same way as credits consumed in the CLI or IDE agents. During the public beta period, Intent uses regular Augment credits at the same rate as the CLI or IDE extensions.

Five plans are available: Trial, Indie, Standard, Max, and Enterprise. The table below maps monthly price to credit allocation and seat limits.

Matching Usage Profile to Plan

The plan guide maps usage to plans. The practical version for Intent-focused teams looks like this:

Two tradeoffs worth flagging up front. First, monthly plan credits do not roll over, so a team that underuses Standard effectively overpays each cycle. Purchased top-up credits roll over and expire 12 months from the purchase date, which makes front-loading via top-ups more flexible than upgrading to Max for teams with spiky usage. Second, Standard and Max share a hard 20-user ceiling. Growing teams should plan the Enterprise migration before hitting that cap, because contract negotiation adds weeks of lead time.

How Credits Work: Pooled Across Up to 20 Users

Credit pooling aggregates every seat's monthly allocation into one shared bucket that all members draw from simultaneously. The pricing page publishes a 20-developer Standard team example showing how the pool absorbs variance across power users, regular users, and occasional users:

Three power users each consume roughly 2.5x their individual seat allocation, ten regular users consume about 60% of theirs, and seven occasional users use roughly a quarter of theirs. The team still has about 22.5% of credits remaining at month end.

The Pooling Tradeoff Teams Miss

Pooling absorbs variance, and it also removes guardrails. Standard and Max have no per-user caps, so one engineer running Opus-heavy Intent sessions on a greenfield exploration can drain a significant chunk of the shared pool before anyone notices. Per-user credit caps exist only on Enterprise.

Three practical mitigations keep this from biting:

• Set a team-wide model default (Sonnet or Gemini 3.1 Pro) and reserve Opus for explicit opt-in tasks.
• Enforce spec discipline. A tight living spec reduces Implementor retries, which is where tool-call credits accumulate fastest.
• Watch the dashboard weekly. Credit usage dashboards surface consumption per user in the Intent workspace and the web console, so drift shows up early rather than at the end of the cycle.

The platform runs at full quality and speed until the pool is empty. Once credits are exhausted, teams are prompted to purchase top-ups or wait for the next billing cycle to reset, so treat the pool as a hard stop rather than a soft budget.

Cost per Developer at Various Team Sizes

Per-developer cost depends on team size, plan tier, and whether the team purchases top-ups. The tables below walk through Standard, Max, and the break-even between them.

Standard Plan ($60/seat): Base Cost by Team Size

The Standard plan scales linearly by seat count, and credits accumulate into a shared pool.

Max Plan ($200/seat): Base Cost by Team Size

The Max plan keeps the same per-seat pricing pattern and gives each seat a much larger monthly credit allocation for teams running Intent-driven multi-agent sessions at higher volume.

When Max Becomes Cheaper Than Standard Plus Top-Ups

Max provides 3.46x more credits per seat for 3.33x the price. At the top-up rate of $15 per 24,000 credits, each top-up credit costs about $0.000625, while Max credits work out to about $0.000444 each.

Take a 10-developer Standard team with a 1,300,000 credit pool that regularly consumes 3,000,000 credits. The top-up for the extra 1,700,000 credits runs about $1,062 per month, bringing the total to $1,662. A 10-developer team on Max pays about $2,000 per month for 4,500,000 credits, so roughly 50% more headroom costs about 20% more.

Rule of thumb: if a Standard team regularly consumes more than ~2.3x its monthly pool, Max works out cheaper than Standard plus top-ups. Below that threshold, top-ups win because they roll over for 12 months while unused Max credits expire each cycle.

Credit Consumption by Model: Opus, Sonnet, Haiku, GPT

Credit consumption depends on the selected model, the size of the context being analyzed, and the length of the response generated. Intent lets developers mix and match models per task, and since Coordinator, Implementor, and Verifier agents can each run a different model, model routing is the largest controllable cost lever in a multi-agent session.

Credits per Medium-Complexity Task by Model

The model table shows how the same medium-complexity task scales in cost from Haiku at the low end to Opus at the high end.

Claude Opus 4.7 ships with a 50% launch discount through April 30, 2026, which brings its cost to roughly 244 credits per medium task during the promotional window. The Gemini 3.1 Pro announcement notes that Gemini 3.1 Pro runs at 2.6x cheaper per message in real usage compared to Opus 4.6, which gives teams another cost-efficient default outside the Opus 4.7 promo window.

Recommended Model Routing by Agent Role

Intent's default three-agent setup (Coordinator, Implementor, Verifier) makes per-agent model selection a concrete design decision. A reasonable starting configuration:

• Coordinator: Sonnet 4.6 or Gemini 3.1 Pro. Planning benefits from quality reasoning, and the Coordinator rarely needs Opus-level depth for task decomposition and delegation.
• Implementor (parallel wave): Haiku 4.5 for well-scoped tasks with clear acceptance criteria, Sonnet 4.6 when the spec leaves room for interpretation.
• Verifier: GPT-5.2 for deep code analysis and review-style work, or Sonnet 4.6 for teams standardizing on the Anthropic stack.
• Reserve Opus 4.7 for long-running tasks, deep reasoning, complex multi-step work, and architectural decisions where getting it right once costs less than iterating. The 50% launch discount through April 2026 makes it particularly attractive for these workloads during this window.

A typical Coordinator-plus-three-Implementor session on Sonnet with this routing lands around 1,200-1,500 credits, compared to 2,500-3,000+ when every agent runs Opus at full price.

How Task Complexity Multiplies Cost

Most credit consumption comes from tool calls rather than model inference. Credit consumption scales approximately 14.5x between small and complex tasks, and tool calls account for the large majority of total consumption in documented examples:

A named example from the pricing docs: "Fix a 500 error in an API endpoint" runs 293 credits on Sonnet as the baseline reference, 88 credits on Haiku, and 488 credits when routed to Opus. "Design and implement a multi-tenant billing system" costs 976 credits with Opus.

Agentic tasks that retry or explore multiple paths multiply tool calls, which is where complex-task credit consumption comes from. Tight living specs that narrow agent scope reduce retries. Intent's Coordinator, Implementors, and Verifier also share a single living spec powered by the Context Engine across 400,000+ files, so agents avoid repeated re-exploration of the codebase during coordinated workflows.

How BYOA Agents Affect Credit Usage

BYOA (Bring Your Own Agent) in Intent means bringing entire agent subscriptions rather than individual API keys. Intent's orchestration layer, including the Coordinator, Verifier, and living specs, works with Auggie natively and also supports Claude Code, Codex, and OpenCode as agent providers.

What BYOA Bypasses vs. What Requires Augment Credits

The table below separates orchestration features that remain free from features that still draw from a paid Augment plan.

Developers with an existing Claude Code, Codex, or OpenCode subscription can use them directly in Intent and run the full workspace experience without an Augment subscription.

When BYOA Costs More Than It Saves

BYOA works well for teams already paying for Claude Code or Codex on small-to-medium repos where the agent doesn't need deep codebase awareness. The math gets more complicated at scale. BYOA agents without the Context Engine MCP installed don't inherit codebase-wide semantic awareness, so every session starts by re-reading files to build context. On large repositories, that inflates provider token bills quickly and can outweigh the savings from bypassing Augment credits.

Most teams that run BYOA at scale adopt a hybrid pattern: BYOA for inference, plus the Context Engine MCP at approximately 40-70 credits per query (treat the figure as directional). The hybrid pattern pays off when:

• The repository exceeds ~50,000 files, where re-reading on every session becomes expensive.
• The workflow involves cross-service refactors that require dependency-graph awareness.
• The team already pays for Claude Code or Codex seats and wants orchestration without duplicating inference cost.

For teams without Claude Code or Codex, native Auggie on a Standard or Max plan usually costs less than buying a BYOA subscription specifically to pair with Intent.

Enterprise Pricing: What to Expect

Enterprise pricing requires direct contact with sales because the plan combines custom contract terms, features, and credit allocations. Contracts are annual with volume-based discounts.

When to Move to Enterprise

Four concrete triggers push teams from Max to Enterprise:

• Team size. More than 20 engineers on Intent, or multi-org GitHub setups that Standard and Max don't support.
• Regulated industry requirements. ISO/IEC 42001 certification, CMEK, data residency, or HIPAA/SOX posture needs that procurement won't waive.
• Per-user cost controls. Enterprise is the only plan with per-user credit caps, which matters for teams where one engineer's Opus habit can otherwise drain the shared pool.
• Security integration. SIEM integration, audit trails, SSO/OIDC/SCIM, and user allowlists for engineering orgs with mature security review.

Enterprise Capability Summary

Enterprise includes everything in Max, plus the additions below.

Cost Comparison: Augment Code vs. Cursor, Kiro, Devin

Each competitor uses a different pricing model, which makes direct comparison difficult. The table below normalizes costs across entry pricing, 20-developer team pricing, and metering model.

Consolidated Comparison

Augment Code Standard at $720/developer/year costs more than Cursor Teams ($480) and GitHub Copilot Business ($228). The premium buys two things that matter for Intent workflows specifically: team-level credit pooling that absorbs variance across mixed-usage teams, and the Context Engine processing entire codebases across 400,000+ files so every agent in a multi-agent session works from the same architectural awareness.

Structural Differences That Affect Total Cost

Headline subscription prices do not capture how each tool meters usage. Four differences drive real-world total cost:

• Cursor Teams bills $40/user/month but only includes $20 of model usage per seat, the same pool as the individual Pro plan. Cursor switched from fast-request quotas to credit-based billing in June 2025, so anything beyond that $20 pool runs on pay-as-you-go at published API rates. Community estimates from public user reports put daily agent users in the $60-$100/month range in combined subscription plus overage, though these figures are not confirmed by official Cursor documentation.
• Kiro charges per prompt rather than per tool call, with separate metering for "vibe requests" and "spec requests." Overage rates differ sharply: roughly $0.04 per credit for vibe requests and roughly $0.20 per credit for spec requests, so heavy spec-driven use gets billed at about 5x the vibe rate. Overage billing is disabled by default.
• Devin charges per compute unit rather than per seat. ACUs cost $2.25 each on the current Team plan (the legacy $500/month plan priced ACUs at about $2). At $9 per hour of active work, heavy usage of 2-3 hours per day costs roughly $480-$810 per month. Zero per-seat cost means cost scales with task volume rather than headcount.
• Augment Code credits reset monthly and don't roll over. Teams that underuse Standard effectively overpay each cycle. Top-ups roll for 12 months, so front-loading via top-ups gives more flexibility than upgrading to Max for teams with spiky or seasonal usage.

Choose the Right Model and Plan Before Your Next Intent Session

Three control points matter most for Intent budgeting. Route Implementors to Haiku or Sonnet and reserve Opus for long-running and architecturally complex work. Tighten living specs so agents retry less, since tool calls drive the majority of credit consumption on complex tasks. Use BYOA plus the Context Engine MCP when the team already pays for Claude Code or Codex on large repos.

A reasonable default for a 10-person team starting with Intent: Standard plan ($600/mo pool), Sonnet 4.6 as the Coordinator default, Haiku 4.5 for Implementors, and Opus 4.7 reserved for deep-reasoning and multi-step architectural work. The 50% launch discount on Opus 4.7 through April 30, 2026 is worth leaning into for that work during the window. Revisit Max if the team exceeds ~2.3x pool consumption for two consecutive months, or Enterprise if headcount crosses 20 or compliance review surfaces ISO/IEC 42001, CMEK, or per-user cap requirements.

FAQ

Related

• What Is Spec-Driven Development? A Practitioner's Guide for AI Coding
• Spec-Driven AI Code Generation With Multi-Agent Systems
• How to Write Living Specs for AI Agent Development
• Single-Agent vs Multi-Agent AI: When to Scale Your Dev Workflow
• How Do Enterprise Teams Build Agentic Workflows?