Usage-based pricing on tools like Cursor, GitHub Copilot and Devin looks simple on the landing page and turns expensive once your team actually starts shipping code with them.
- Cursor switched from unlimited "fast requests" to raw token-based billing in June 2025 after founders reported bills far above the advertised $20 Pro plan
- GitHub Copilot's Business and Enterprise tiers include a fixed quota of "premium requests" and then charge roughly $0.04 per request once you're over it
- Devin prices work in Agent Compute Units, where one ACU runs about $2.25 and a single autonomous task can burn several ACUs without you seeing the meter move in real time
- The core squeeze isn't the sticker price, it's that every vendor defines its own unit (a request, a token, an ACU) so tools can't be compared on cost without doing the conversion math yourself
You sign up for a $20-a-month plan, you tell your team to go build, and three weeks later finance is asking why the bill says $340. That's not a hypothetical. It's what happened to Cursor customers in the summer of 2025, and it's the clearest public example of how does AI coding agent pricing work in practice once you look past the homepage number. The short version: almost every AI coding tool now sells you two things bundled into one price. A subscription that buys you a seat and a bucket of usage, and a metered layer underneath that kicks in the moment you empty the bucket. The subscription is the part vendors market. The metered layer is the part that shows up on your card.
Every agent call, whether it's autocomplete, a chat response, or an autonomous multi-step task, gets converted into some unit of consumption. That unit is where the real pricing model lives, and it's different at every vendor.
Cursor bills on tokens. Every prompt you send and every response the model generates gets counted, and the cost depends on which underlying model handled the request, since Claude, GPT and Gemini all have different per-token rates that Cursor passes through with a markup. GitHub Copilot bills on "premium requests," a Microsoft-defined unit where a single agentic request to a more expensive model can consume multiple premium requests at once, not just one. Devin, built by Cognition, bills on Agent Compute Units, its own internal measure of how much compute a task actually used, and a single ACU currently runs about $2.25.
Best AI Agent Platforms for Founders in 2026: A No-Nonsense Comparison Best AI agent platforms for founders in 2026 means separating real task-executing agents from chatbots in disguise. This hands-on comparison tests Lindy, n8n, Gumloop, Zapier Agents, and Devin against actual founder workflows like lead triage and inbox management, and names which one is worth your money. - best AI agent platforms for founders - AI agents that automate tasks for
None of these units convert cleanly into each other. A "request" on Copilot is not a "token" on Cursor is not an "ACU" on Devin. That's not an accident. It means you cannot look at three pricing pages side by side and know which tool is actually cheaper for your workload, and the vendors have very little incentive to fix that.
Where the overage actually comes from #
The squeeze usually isn't in the plan you picked. It's in three places founders don't think to check until the invoice arrives.
First, model routing. Most of these tools let you pick between a fast, cheap model and a slower, more capable one, and the expensive model burns through your included quota far faster. Cursor's Pro plan technically includes a fixed dollar amount of API usage per month, but if your team defaults to Claude Opus or GPT-5-class models for everyday tasks instead of a cheaper model, that included balance disappears in days instead of weeks.
Second, agentic tasks are not single requests. When Devin or a Copilot agent goes off to plan, write code, run tests, read error output and retry, that whole loop can consume five, ten, sometimes dozens of underlying model calls before it hands you a result. You see one task. The billing system sees a chain of requests, and each one counts.
Third, context length compounds the bill invisibly. Every additional file the agent reads to understand your codebase gets re-sent as part of the prompt on each turn, so a long-running session in a large repo can cost several times more per exchange than the same session in a small one, purely because of how much context gets re-transmitted each time. None of that shows up as a separate line item. It just shows up as a bigger number.
The Cursor backlash was the loudest public case #
In June 2025, Cursor quietly moved away from its old model of unlimited "fast" requests on paid plans and replaced it with direct, usage-based token billing, even for existing Pro subscribers. Users on developer forums and social media posted screenshots of bills that came in well above the $20 subscription price, some reporting hundreds of dollars in a single month for what they assumed was a flat-rate product. Cursor's team responded publicly, apologized for how unclear the change was communicated, and issued refunds to affected users, according to reporting on the incident that circulated widely across developer communities at the time.
That episode matters because it wasn't a scam or a bug. It was the plan working as designed. The $20 tier always had a usage ceiling behind it. The company just hadn't made that ceiling visible enough for users to plan around it, and the moment it enforced the metering more strictly, the gap between the marketed price and the real cost became impossible to ignore.
What Is an AI Wrapper Startup and Why VCs Are Suddenly Skeptical What is an AI wrapper startup? It's a product built by calling someone else's foundation model, like GPT or Claude, and repackaging the output for a narrower use case, and VCs have grown wary of funding them without a real moat. This piece breaks down when a wrapper is a fatal flaw and when it's a legitimate starting point, using Jasper AI... - AI wrapper startup definition - why VCs reject wrapper companies
Why founders specifically get caught out #
A solo developer notices a spike fast. A ten-person engineering team doesn't, because usage is spread across seats and nobody owns the bill until it lands. You're the one who signed up for the plan, but you're rarely the one running the agent all day, so the first signal you get that something changed is the invoice, not the usage.
Founders also tend to roll these tools out fast, because the upside is real. Teams using agentic coding tools ship faster and iterate quicker, and that's exactly why adoption spreads through a team before anyone sets a budget alert. The tool proves itself useful in week one, usage climbs in week two, and the bill catches up in week three. By then the habit is already set, and cutting usage feels like taking a tool away from a team that's relying on it.
Usage based pricing AI tools models actually reward vendors for ambiguity #
Here's the part vendors won't put in their marketing copy. A metered pricing model with an opaque unit of account is not a mistake, it's a design choice that benefits the seller. If Cursor priced in flat dollars per month with a hard cap, users would know exactly what they're getting and switch the second a competitor undercuts them. Pricing in tokens, premium requests, or compute units instead means the effective price per unit of real work can drift, get more expensive as models get pricier, or vary by which model handles your request, all without the vendor ever touching the sticker price on the landing page.
That's not unique to coding agents. It's the same playbook cloud compute has run for two decades, where the headline number is low and the real spend lives in the metering. What's new is that a five-person startup, not a procurement team at a Fortune 500 company, is now the one expected to model that spend correctly.
What actually controls the bill #
Model choice is the single biggest lever. Defaulting your team to a cheaper model for routine completions and reserving the expensive model for genuinely hard problems can cut token spend dramatically, since the price gap between a frontier model and a lighter one is often five to ten times per token, not a marginal difference.
Set per-seat usage caps if the vendor offers them. GitHub Copilot Business lets admins cap premium request overage per user, which turns an open-ended bill into a known maximum. Cursor and Devin both expose usage dashboards, but they're opt-in to check, not something that alerts you by default, so someone on the team needs to own checking them weekly, not monthly.
And read the plan's fine print on what "included" actually means before you roll a tool out past one or two engineers. A number like "$20 includes $20 of usage" sounds like a wash, but it means your effective free tier shrinks the moment you use a pricier model, and most teams don't find that out until the first real bill lands.
The tools are genuinely good. Devin can carry a multi-step engineering task end to end, and Copilot's agent mode has changed how fast small teams move. Frankly, the problem was never whether these products work. It's that nobody selling them wants you to be able to price your usage in advance, and until that changes, the founders who read the metering model before rollout are the ones who won't be surprised in month two.
Also read: How to Price SaaS When AI Agents Replace Seats • How Does AI Agent Sandboxing Actually Work, and Why Founders Skip It • How Do Advisor Shares Actually Vest at a Startup, and What Gets Left Out