• 7 min read

AI Coding Tool Pricing 2026: 16 Tools, 119 Plans, Cost/Dev

tl;dr

Actual agentic workload spend lands at $100 to $250 per developer monthly regardless of which AI coding tool you choose. Team seat fees range from $19 to $125 per seat before metered overage is added.

Featured image for "AI Coding Tool Pricing 2026: 16 Tools, 119 Plans, Cost/Dev"

The industry has converged on metered usage layered over seat pricing, so the sticker price is a floor not the bill. Under sustained agentic workloads actual spend converges around $100–$250 per developer per month regardless of which vendor you pick.

What does the 2026 AI coding tool pricing landscape actually look like?

Researchers documented 119 plans across 16 AI coding tools, each linked to the vendor’s pricing page and checked November 1, 2026 with re-verification on November 14 119 plans across 16 tools. That’s a lot of rows to parse, but the pattern is consistent: every major vendor now runs a hybrid model where a seat fee buys an allowance, and anything beyond that gets metered at model API rates. GitHub Copilot made this shift on June 1, 2026, moving Business seats to $19/month with $19 of included AI credits and overage billed at each model’s API rate industry converged on metered usage.

The cheapest paid individual plans cluster at $8–$10/month: Cursor Plus at $8 (Grok models only), ChatGPT Go at $8, GitHub Copilot Pro at $10, Zed Pro at $10, and JetBrains AI Pro at $10 cheapest paid plans cluster. At the other end, top individual tiers cluster at $100–$200/month: Claude Max $100 and Ultra $200, Copilot Max $100, ChatGPT Pro at $100/$200/$500, Devin Max $200, Replit Pro $100, and v0 Business $100 top tiers cluster. The spread looks wide on paper, but the real bill tells a different story.

How do individual plans compare across the major tools?

GitHub Copilot’s individual lineup runs Free $0, Pro $10/month, Pro+ $39/month, and Max $100/month. AI credits cost $0.01 each; Pro includes $15/month of credits, Pro+ $70/month, Max $200/month. Completions are unlimited on paid plans, while the Free tier includes 2,000 completions per month plus limited chat and agent usage GitHub Copilot individual plans. Cursor’s plans under The X Subscription (launched October 12, 2026) run Free $0, Plus $8/month (Grok models only), Premium $30/month, Super $100/month, Ultra $200/month, and Teams from $30/seat/month. Third-party models are billed separately at API prices Cursor plans.

Claude Code is included with Claude Pro ($20/month, or $17/month billed annually), Max ($100/month), and Ultra ($200/month); it’s not included in the Free Claude plan. Team seats are $25/month standard and $125/month premium ($20/$100 billed annually), with pay-as-you-go available via API Claude Code plans. OpenAI Codex is included in ChatGPT Free, Go ($8/month), Plus ($20/month), Pro ($100/$200/$500/month), Business, Edu, and Enterprise; extra usage is billed via ChatGPT credits OpenAI Codex plans. Devin Desktop plans: Free $0, Pro $20/month, Max $200/month, Teams $80/month plus $40/month per full developer seat, Enterprise custom. Free tier includes light agent quota with unlimited Tab completions. As of November 13, 2026, Teams is capped at 100 users (down from 200) and quota seats are retiring in 30 days; every Teams user gets two concurrent free SWE-2 sessions Devin Desktop plans.

ToolFree TierEntry PaidTop IndividualTeam Starting PriceUsage Model
GitHub Copilot2,000 completions/moPro $10/moMax $100/moBusiness $19/seat/moAI Credits ($0.01 each)
CursorLimited agent/chatPlus $8/mo (Grok only)Ultra $200/moTeams $30/seat/moWeekly pool + API overage
Claude CodeNot includedPro $20/mo ($17 annual)Ultra $200/moTeam $25–$125/seat/moRolling 5-hr windows
OpenAI CodexLimited via ChatGPT FreeGo $8/moPro $100–$500/moBusiness $20–$25/user/moChatGPT credits
Devin DesktopLight agent quotaPro $20/moMax $200/mo$80/mo + $40/seat/moQuotas + API overage

The table above captures the headline numbers, but the usage model column is where the bill actually lives. Cursor’s weekly allowance resets every seven days; Claude Code shares a rolling five-hour window with Claude chat; Copilot draws down dollar-denominated credits; Codex uses ChatGPT credit windows. They’re not interchangeable.

What happens when you scale to team pricing?

Team pricing is where the divergence gets expensive. For a 5-person team, the monthly seat-fee gap between GitHub Copilot Business ($19/seat) and Claude Code Team Premium ($125/seat) is $530/month 5-person team gap.

Per-seat business plans range from Copilot Business $19/seat to Claude Team Premium $125/seat and ChatGPT Business Premium $125/seat. That’s a 6.5x spread on the seat fee alone, before a single token gets metered. If your team runs heavy agentic workloads, the seat fee becomes a rounding error — vendor-reported usage lands at $100 to $250 per developer monthly, no matter which one you pick actual spend $100-250/dev/month.

Vercel’s Token Pass adds another dimension: $30 per team per month includes $150 in monthly model credit (raised from $80 on November 13, 2026) for featured open-weight models through AI Gateway. It’s an early-access add-on for Pro teams, the credit covers models like Kimi K3.1 Pro, GLM 5.3, and DeepSeek V4.1 Flash, expires at the end of each billing period with no rollover, and unused credit is not refunded Vercel Token Pass. This is the kind of program that can shift the effective rate for teams willing to standardize on open-weight models.

Why does the sticker price not match the real bill?

The industry has converged on metered usage layered over seat pricing. GitHub Copilot moved to AI credits on June 1, 2026, so a Business seat at $19/month includes $19 of credits with overage billed at each model’s API rate industry converged on metered usage. Cursor bills third-party models separately at API prices. Claude Code and Codex meter usage in rolling windows. App builders like Lovable and Bolt count credits or tokens. The sticker price is a floor, not your bill.

Under sustained agentic workloads, actual usage-based spend lands at $100 to $250 per developer per month regardless of which vendor is chosen actual spend $100-250/dev/month. This is the pattern I’ve observed: the Usage Floor. Paying for the most expensive individual plan does not reduce your bill under load — every vendor’s usage model funnels heavy agent users into the same $100–$250 per developer monthly range, so the priciest subscription buys a higher allowance, not a lower effective rate.

The contradiction is stark: the cheapest entry point is $8–$10 per month versus the real cost at $100–$250 per developer per month. Cursor Plus at $8, ChatGPT Go at $8, and GitHub Copilot Pro at $10 are the cheapest paid individual plans cheapest paid plans cluster. Once agents run all day, vendor-reported usage lands at $100 to $250 per developer monthly, no matter which tool you pick actual spend $100-250/dev/month. Stop comparing list prices; forecast agent-session minutes and overage rates instead.

Which free tiers are actually usable versus demo-only?

Free tiers exist but are limited demos: they carry restricted agent requests, daily credit caps, or “bring your own model key” requirements, making them evaluation tiers rather than full working tools free tiers are limited demos. Free plans with a $0 price include Cursor, GitHub Copilot, JetBrains AI Free, Zed Personal, Devin Free, Bolt, Lovable, v0, Base44, Codex (ChatGPT Free), and OpenCode / Cline as open-source tools where you bring your own model key. The catch is always in the limitations: limited agent requests, daily credit caps, or “you pay the model provider.”

GitHub Copilot Free includes 2,000 completions per month plus limited chat and agent usage (includes CLI and agent mode) GitHub Copilot individual plans. Cursor Free includes limited agent and chat requests Cursor plans. Claude Code is not included in the Free Claude plan at all Claude Code plans. Devin Free includes light agent quota with unlimited Tab completions Devin Desktop plans. OpenCode offers free models with daily request limits OpenCode free models. If you need sustained agent work, the free tier is a demo — not a workflow.

How should you choose given the convergence on hybrid billing?

The decision framework is simpler than the pricing pages suggest. Pick the job first (editor? terminal agent? prompt-to-app?), then compare the 2–3 tools for that job at the tier you’ll actually hit. If you run one editor plus one agent, entry-level list prices add up to roughly $30–$40/month (e.g., a $10 editor plan plus a $20 agent plan). But budget for the Usage Floor: $100–$250 per developer monthly under load.

For teams already in GitHub, Copilot Business at $19/seat with included credits is the lowest-friction start. For terminal-first autonomous work, Claude Code through Claude Team ($25–$125/seat) or pay-as-you-go API makes sense. For an AI-native editor with parallel agents, Cursor Teams from $30/seat. For open-source BYOK control, OpenCode or Cline with your own API keys. The AI Coding Playbooks: The Real Cost of Going Agentic in 2026 guide breaks down how to build a cost-governed playbook before promotional credits expire, and the AI Coding Tool ROI: Avoid the $200/Engineer/Month Cost Trap analysis shows why measuring actual throughput matters more than chasing vendor benchmarks.

The pricing page is a floor, not a price. Your bill will be determined by how many agent minutes your team runs, not which logo sits on the subscription.