Every coding agent plans page in 2026 says roughly the same thing: twenty dollars gets you started, a higher tier gets you more, and the details sit behind an asterisk. However, the asterisk is the part that matters. For example, some vendors meter you in five-hour windows with a weekly ceiling. Others, in contrast, hand you a monthly dollar balance and then bill the rest at API rates. Moreover, only one of them publishes the exact dollar value of what you get.
This post is for the developer or engineering lead choosing between Claude Code, OpenAI Codex, Cursor, GitHub Copilot, Devin (the product formerly sold as Windsurf) and Google Antigravity, whether for one seat or for a team. Every price below was read from the vendor’s own page on one stated day. In addition, every team total is computed in the open, and the post names what each vendor does not disclose, because a missing number is part of what you are buying.
The short version is this. At $20 a month the six plans cost the same, so they differ almost entirely in how the cap works. Meanwhile, at $100 to $200, three vendors have converged on the same 1x, 5x and 20x ladder. Finally, for a team of five, GitHub Copilot Business is the cheapest by a wide margin, and it is also the only plan whose included usage has a published dollar value.
Where These Coding Agent Plan Prices Came From
Each figure comes from the vendor’s pricing page, plan documentation or help center, and all of them were read on the same day. As a rule, nothing is taken from a comparison site or a reseller.
Prices read 2026-09-24
US list pricing, before tax, monthly billing unless stated
Anthropic: claude.com/pricing, Max plan and extra usage help articles
OpenAI: learn.chatgpt.com/docs/pricing, Pro plan and credits help articles
Cursor: cursor.com/pricing, cursor.com/docs/account/pricing
GitHub: github.com/features/copilot/plans, Copilot plans documentation
Cognition: devin.ai/pricing (windsurf.com/pricing redirects here, HTTP 308)
Google: gemini.google/subscriptions, antigravity.google/docs/plans
Excluded: enterprise contracts, regional plans (Cursor Start in India),
student and open-source discounts, tax, promotional credits
The primary sources are Claude pricing, Codex pricing, Cursor models and pricing, GitHub Copilot plans, Devin pricing and Google AI subscriptions. Therefore, check any number against them before you put it in a budget, especially since OpenAI closed its top tier to new buyers in September alone.
Coding Agent Plans at a Glance
This is the table most readers came for. Specifically, it lists every self-serve tier that includes an agent, together with how its cap works.
| Vendor | Tiers and monthly price | How the cap works |
|---|---|---|
| Anthropic | Pro $20 ($17 annual), Max 5x $100, Max 20x $200 | 5-hour sessions, while a weekly limit also applies |
| OpenAI | Go $8, Plus $20, Pro $100 (5x), Pro $200 (20x, paused) | 5-hour windows, while weekly limits may also apply |
| Cursor | Pro $20, Pro+ $60, Ultra $200 | Monthly pools, then on-demand billing at API rates |
| GitHub | Copilot Pro $10, Pro+ $39, Max $100 | Monthly credits, then paid credits at $0.01 each |
| Cognition | Devin Pro $20, Max $200 | Daily quota, while a weekly quota also applies |
| AI Pro $19.99, Ultra $99.99 (5x) or $199.99 (20x) | 5-hour refresh until a weekly limit, then AI credits |
In practice, the price column mostly converges. By contrast, the cap column splits the market into two camps, so which camp suits you depends on how your working week is shaped.
Two Ways to Meter an Agent
Every plan above uses one of two models, and consequently they fail in opposite ways.
Rolling windows with a weekly ceiling
Anthropic, OpenAI, Google and Cognition all meter in time windows. For instance, Claude, Codex and Antigravity refresh every five hours, while Devin refreshes daily. Each also layers a weekly limit on top. As a result, a heavy Monday cannot borrow from a quiet Thursday, and a long refactor that burns through the window stops mid-task until the timer resets. Indeed, Anthropic’s page states that paid plans “add weekly limits on top” and that it may also apply “weekly and monthly caps” at its discretion.
The upside, therefore, is a predictable bill. You pay the plan price, and nothing more unless you explicitly turn on extra usage. Consequently, the risk moves from your invoice to your calendar.
Monthly balances billed like an API
Cursor and GitHub Copilot, on the other hand, give you a monthly balance and bill overage in arrears. For example, Cursor draws third-party models from an “Other Models” pool at each model’s API price, whereas its own Grok and Composer models come from a separate, larger pool. Similarly, GitHub converts everything into AI credits worth $0.01 each. Unlike the window model, this one lets you spend a whole month’s allowance in one afternoon, so nothing stops you except a budget you set yourself.
As a result, work never stalls. Still, the bill now depends on model choice, context size and how long the agent runs, which is exactly the variable developers are worst at estimating.
Claude Code Plans: Pro, Max and Team
Claude Code is included on every paid Claude plan, but not on the free one. Pro costs $20 monthly, or $17 a month on an annual subscription ($200 billed up front). Meanwhile, Max costs $100 for 5x Pro’s per-session usage and $200 for 20x, according to the Max plan help article.
Notably, the pool is shared. Chat on the web, the desktop app and Claude Code all draw from the same allowance, so a long research conversation in the morning leaves less for the terminal in the afternoon. Furthermore, Anthropic publishes no fixed message count, because usage depends on conversation length, model and features.
Model access also has its own rule worth reading closely. Fable, the most expensive model, is available on Pro only through usage credits, while on both Max tiers it is capped at 50% of weekly limits. Opus, in contrast, is included on all paid tiers. For context, Fable 5.1 lists at $10 input and $50 output per million tokens on the API, against $4 and $20 for Opus 5.5, which explains the fence. Additionally, the Opus 5.5 breaking changes post covers what changed in that model.
Beyond the cap, extra usage is prepaid and billed at standard API rates, with a monthly spending cap you set and a $2,000 daily redemption limit. For teams, a standard seat costs $25 monthly ($20 annual), whereas a premium seat costs $125 monthly ($100 annual) and gets 5x the usage of standard. Finally, Enterprise is $20 per seat per month billed annually, plus all usage at API rates.
OpenAI Codex Plans: Plus, Pro and Business
Codex ships with every ChatGPT plan, including Free and the $8 Go tier, although those two get only GPT-6 Luna in the desktop app. By comparison, Plus at $20 unlocks the CLI, the IDE extension, cloud tasks and GitHub code review. Pro then starts at $100 for 5x Plus usage, with a $200 tier at 20x.
However, that $200 tier comes with an important caveat. According to OpenAI’s Pro plan help article, new sign-ups and upgrades to Pro $200 have been paused since 10 September 2026. Existing subscribers keep it, and the $100 tier is also unaffected. In other words, the top Codex tier is not for sale today to anyone who does not already have it.
OpenAI is also the one vendor that publishes per-model estimates, so its tiers are comparable in a way the others are not. The ranges below are local messages per five-hour window.
| Model | Plus ($20) | Pro 5x ($100) | Pro 20x ($200) |
|---|---|---|---|
| GPT-6 Astra | 5-45 | 25-225 | 100-900 |
| GPT-6 Sol | 15-150 | 70-700 | 300-3,000 |
| GPT-6 Luna | 350-3,000 | 1,750-14,000 | 7,000-56,000 |
Notice the spread inside each cell. Because the range is tenfold on the same model and tier, task size dominates everything, so treat the low end as the planning number. Furthermore, cloud tasks use GPT-5.6 Sol and share the same allowance. In addition, GPT-5.5 retires from Codex on all plans on 14 October 2026.
For teams, Business costs $20 per user per month billed annually for two or more users, or $25 monthly. The docs also reference a $100 Business seat that receives Pro 5x limits. Past the cap, Plus and Pro users can buy credits, which then stay valid for 12 months. However, OpenAI does not publish the dollar price of personal credits, saying amounts and prices vary by account, region and plan. Instead, its Business rate card offers one blunt planning figure: Codex “costs approximately $100–$200 per developer per month” on usage-based billing.
Cursor Plans: Pro, Pro+, Ultra and Teams
Cursor sells Pro at $20, Pro+ at $60 and Ultra at $200, while a free Hobby tier includes limited agent requests. Each paid plan also includes two separate monthly pools. First, the Cursor Models pool covers Grok 4.7, 4.6, 4.5 and Composer 2.5, and Cursor describes it as “significantly more included usage.” Meanwhile, the Other Models pool covers Claude, GPT and Gemini at each model’s API price.
What Cursor does not publish, though, is the size of either pool in dollars or tokens. Instead, the pricing documentation offers a usage guide: daily agent users “typically” spend $60 to $100 a month in total usage, while power users running multiple agents “often” spend $200 or more. Read plainly, therefore, a daily agent user on the $20 plan should expect on-demand charges.
After the included amount runs out, on-demand usage continues at the same API rates, billed monthly, and requests are “never downgraded in quality or speed.” For teams, a standard seat costs $40 per user, whereas a premium seat costs $120 and gets 5x the agent limits. Notably, one team-only charge tends to go unnoticed: third-party model requests on Teams and Enterprise carry a Cursor Token Rate of $0.25 per million tokens, on top of API pricing, even for included usage and bring-your-own-key.
If you are choosing between the tools themselves rather than their plans, then the Cursor vs Claude Code comparison covers the workflow differences.
GitHub Copilot Plans: Credits With a Published Value
Copilot is the only vendor here that states exactly what its included usage is worth. Specifically, one GitHub AI credit equals $0.01, and every paid individual plan includes a base allotment plus a “flex allotment” on top. The Free tier, by contrast, offers limited chat and agent use along with 2,000 completions a month.
| Plan | Price | Included credits | Included per $1 paid |
|---|---|---|---|
| Pro | $10 | $15 ($10 base plus $5 flex) | $1.50 |
| Pro+ | $39 | $70 ($39 base plus $31 flex) | $1.79 |
| Max | $100 | $200 ($100 base plus $100 flex) | $2.00 |
| Business | $19 per seat | $19, also pooled org-wide | $1.00 |
| Enterprise | $39 per seat | $39, also pooled org-wide | $1.00 |
The last column is plain arithmetic, since it divides the included credits by the price. Two caveats apply, however. First, GitHub states that “flex allotments may change over time,” so the extra 50% to 100% on individual plans is not contractual. Second, the Max FAQ on the same page says the plan “includes $100/month in GitHub AI Credits,” which matches the base allotment and ignores the flex one. Therefore, budget against the base.
Code completions and next edit suggestions, meanwhile, do not use credits and stay unlimited on every paid plan. In contrast, chat, agent mode, the cloud agent, code review and the CLI all consume credits at a rate that depends on the model. Moreover, Business and Enterprise pool credits across the organization, so admins decide whether paid overage is allowed at all. The Copilot plans documentation also lists the per-seat figures, and for setup, see integrating GitHub Copilot into your workflow.
Devin and Google Antigravity Plans
Both of these use the window model, and both publish the least detail about it.
Devin, formerly Windsurf
Windsurf’s pricing URL now returns a permanent redirect to Devin’s. There, Devin Pro costs $20 and Max costs $200, while a free tier offers a “light quota.” Allowances refresh daily and weekly, and extra usage is then bought at API pricing. In addition, Cognition’s own SWE-2 model is free in Devin Desktop and the CLI through 10 October 2026. Finally, Teams costs $80 a month for the team plan plus $40 per full developer seat, for up to 200 users.
Google Antigravity
Antigravity is free on an individual account, although that quota refreshes only weekly. Google AI Pro at $19.99 moves it to a five-hour refresh with a weekly limit, while Ultra costs $99.99 for 5x or $199.99 for 20x. When quota runs out, Pro and Ultra users can opt into AI credit overages, consumed at Gemini Enterprise consumption pricing, according to the Antigravity plans documentation. Also, the CLI and scheduled tasks are included on every tier.
The 1x, 5x and 20x Ladder
When you put Anthropic, OpenAI and Google side by side, the same shape appears three times.
| Tier | Anthropic | OpenAI | |
|---|---|---|---|
| 1x | Pro, $20 | Plus, $20 | AI Pro, $19.99 |
| 5x | Max 5x, $100 | Pro, $100 | Ultra, $99.99 |
| 20x | Max 20x, $200 | Pro, $200 (paused) | Ultra, $199.99 |
This pattern has a practical consequence. The 5x tier costs exactly five times the base, so it buys capacity at the same unit price of $20 per 1x. By contrast, the 20x tier costs ten times the base for twenty times the usage, which halves the unit price to $10. As a result, for anyone who regularly hits a 5x ceiling, the jump to 20x is the only step on these ladders that is actually a discount.
Similarly, GitHub runs the same logic through credits instead of multiples, rising from $1.50 to $2.00 of usage per dollar paid. Cursor and Devin, however, do not publish enough to compute a unit price at all.
What a Team of Five Pays Each Month
Team pricing is where the gaps get large, because seats multiply. For that reason, this table prices five developers on each vendor’s standard team seat, billed monthly, with the annual rate where one is published.
| Vendor and seat | Monthly for five | Annual billing |
|---|---|---|
| GitHub Copilot Business | $95 (5 x $19) | Not listed |
| Anthropic Team standard | $125 (5 x $25) | $100 (5 x $20) |
| OpenAI Business | $125 (5 x $25) | $100 (5 x $20) |
| Cursor Teams standard | $200 (5 x $40) | Not listed |
| Devin Teams | $280 ($80 + 5 x $40) | Not listed |
Premium seats, however, change the picture sharply. For example, five Claude premium seats cost $625 monthly, and five Cursor premium seats cost $600. Since both buy 5x the standard allowance, a team where only two people run agents all day should mix seat types rather than upgrading everyone.
Google is absent because its team and enterprise pricing sits on separate enterprise pages outside the consumer plans priced here. Furthermore, Copilot’s $95 is the only figure with a known dollar value of included usage, namely $95 of pooled credits. Every other row, in contrast, buys an undisclosed allowance.
How to Choose Among Coding Agent Plans
The numbers narrow the choice, and then these rules finish it.
Start with Copilot when cost predictability matters most
If a finance team needs to know what a seat is worth, then Copilot is the only answer with a number attached. Moreover, Business pools credits across the organization, so light users subsidize heavy ones instead of wasting allowance. Admins can also switch overage off entirely.
Pick a windowed plan when your work comes in bursts
Claude, Codex and Antigravity suit developers who run agents hard for a few hours and then review. In that pattern, the bill never moves, and the five-hour reset matches a work session. Conversely, if your day is one continuous eight-hour agent run, the window will interrupt you.
Choose Cursor when you switch models constantly
Cursor is the only plan here that gives first-class access to Claude, GPT, Gemini and Grok in one editor, billed at API prices. Nevertheless, that flexibility costs predictability, since the included amount is unpublished and overage arrives after the fact.
Buy the top tier only after hitting the middle one
The 20x tiers offer the best unit price on the market. Even so, at $200 a month they only pay off for someone who has already outgrown 5x. Besides, Codex’s top tier is closed to new buyers anyway.
When NOT to Rely on a Subscription Plan
- For CI pipelines and shared automation, because Codex’s own docs recommend API keys there and consumer plans are per person
- When one engineer regularly exceeds the 20x tier, since API billing with a hard budget is then more honest than repeated top-ups
- When compliance requires data residency or audit logs, because those sit on enterprise tiers priced by contract
- When your team already pays for one vendor’s chat product, since Claude and ChatGPT plans share one pool between chat and coding
Common Mistakes When Comparing Coding Agent Plans
- Comparing $20 plans on price alone, when the cap model differs completely between a monthly balance and a five-hour window
- Treating Copilot’s flex allotment as guaranteed, although GitHub says it may change over time
- Forgetting that chat also drains the same pool as Claude Code or Codex on Anthropic and OpenAI plans
- Budgeting Cursor at $20 per seat for daily agent users, even though Cursor’s own guide places them at $60 to $100 a month
- Missing Cursor’s $0.25 per million token rate on Teams, especially since it applies even to bring-your-own-key usage
- Planning a Codex rollout around the $200 tier, since it has been closed to new sign-ups since 10 September 2026
- Upgrading every seat to premium when only a few developers run agents all day
A Realistic Scenario: A Five-Person Team Picks a Plan
Consider a small product team of five, where two people run agents for most of the day while three use them for review and occasional refactors. Meanwhile, the team lead has to choose a plan for the next quarter.
First, pricing everyone on Copilot Business costs $95 a month and yields $95 of pooled credits. Because the pool is shared, the two heavy users can draw on what the three light users leave behind. Then, if the heavy users still exhaust it, the admin can allow paid overage at $0.01 per credit with a budget, so the worst case is a known number.
Alternatively, mixing Claude Team seats puts the two heavy users on premium and the rest on standard. That costs 2 x $125 plus 3 x $25, which comes to $325 monthly, or $260 on annual billing. As a result, the heavy users get 5x the standard allowance in fixed windows and never produce a surprise invoice, although they can still stall mid-task when a window runs out.
Neither choice is wrong, because the trade is money against interruptions. For instance, a team that ships in long uninterrupted sessions tends to value the Copilot model’s continuity, whereas a team with a strict budget line tends to value the flat bill. What the numbers rule out, however, is the third option many teams drift into: five individual $20 subscriptions spread across different tools. That costs $100 a month, yet it buys no shared pool and no admin controls, and it also leaves the two heavy users capped at 1x.
What to Do Next
Coding agent plans converged on price in 2026 but diverged on everything else. At $20 the difference is the cap model, while at $100 to $200 three vendors share the same ladder. For teams, meanwhile, GitHub Copilot Business is the cheapest seat and the only one with a published allowance. Therefore, the recommendation for most teams is to start there, measure where usage actually lands, and then move heavy users onto a windowed plan if they keep hitting the pool.
The concrete next step, then, is to pull one week of your team’s real agent usage before buying anything. For example, check the usage dashboard in whatever tool you use today, count how often anyone hit a limit, and compare that against the tables above. To turn token counts into dollars, the LLM cost per task tables also price the same workloads across models at API rates, which is exactly what every overage on this page is billed at.
Finally, set a reminder for three months. Since OpenAI closed a tier to new buyers within the past month, a plan comparison older than a quarter is a wrong answer that looks like an old one.
Last Updated: September 2026
