Freemium economics
What Free Users Actually Cost AI Dev Tools
In early 2026, three AI providers raised prices within weeks of each other. One killed its free tier outright and published the receipts: specific users consuming 100-300x their subscription value in API calls. GitHub's own pricing update was just as blunt about the cause: agentic workflows have changed compute demands so much that a handful of requests can now exceed the price of the plan. Cursor, Augment, and Windsurf all replaced flat plans with credit and quota models within a year.
None of this is mismanagement. It's the same structural fact hitting everyone at once: the freemium playbook was written for products where free users cost approximately nothing, and AI dev tools are not that product. In classic SaaS, the ~95% of users who never pay are cheap marketing: they file bugs, spread the word, and cost cents to serve. In an AI tool, every one of them burns real inference on every session, forever.
Most advice on this topic tells you to "balance value and limits" and A/B test your paywall. This post does something different. It treats the problem as three steps you can work through in an afternoon: compute your real cost per free user, price out every lever you have against that number, including the one the standard playbook doesn't mention, and match the levers to your cost structure. All assumptions are labeled so you can swap in your own numbers.
Step 1: Know your cost per free user
The number that matters is monthly cost-to-serve per free user, and most teams discover they've never actually computed it. The model is short:
monthly cost per free user =
sessions/month
× AI actions per session
× avg tokens per action (in + out)
× blended $/token
+ fixed overhead per user (storage, infra, support amortization)Let's make it concrete with an illustrative profile: call it a coding assistant with a free tier. Assumptions labeled, deliberately conservative:
| Assumption | Value | Note |
|---|---|---|
| Active free users | 20,000 | |
| Sessions/month per active user | 12 | ~3/week |
| AI actions per session | 15 | completions, chats, agent steps |
| Avg tokens per action | 6,000 | includes context re-sent per call |
| Blended inference cost | $2.50 / 1M tokens | mid-tier model mix; frontier models are multiples of this |
| Fixed overhead per user | $0.10/mo |
That works out to roughly $2.80 per free user per month, about $56,000/month across the free base. Push any assumption toward realistic heavy usage (agentic workflows multiply actions per session; frontier models multiply $/token by 5-10x) and you're at $10-30+ per heavy free user. This is why providers publish stories about individual users consuming hundreds of times their plan value: the distribution has a brutal tail. Analysts estimate that genuinely heavy assistant usage costs $100-200+/month to deliver, which is the entire explanation for why every flat "unlimited" plan in this market has died or grown asterisks.
Two implications before we get to the levers. The first: your median free user is not your problem; your P95 is. Cost is concentrated in a small slice of heavy users, so any fix that only addresses the median misses most of the spend.
The second is the one that breaks the freemium playbook, and it's worth reading twice:
Conversion doesn't rescue this on its own. At typical freemium conversion of 2-5%, each paying user must carry 20-50 free users. At $20/month revenue and ~$2.80/month free-user cost, a converted user's entire margin can be consumed subsidizing the cohort behind them. The classic model where free users are nearly-free marketing simply doesn't transfer.
Step 2: Price out every lever
You have six levers. Each has a real value and a real cost, both of which you can now price against the number from step 1. The mistake is treating any one of them as the answer rather than pricing them against each other.
1. Quota tightening (smaller allowances). Directly proportional savings: halve the free actions, roughly halve the variable cost. The hidden price is paid in funnel: the free tier exists to build habit before the paywall, and users who hit a wall on day two don't build habits: they churn to whichever competitor is currently flooding the market with generous free access. Best used surgically against the P95 tail (rate limits, burst caps) rather than against the median user, since that's where the money is anyway. GitHub Copilot's free tier is the visible example: fixed monthly allowances for completions and chat instead of an open tap.
2. Model downgrading (cheaper models for free users). The highest-leverage cost cut available: swapping frontier for distilled/mid-tier models cuts $/token by 5-10x, taking our illustrative $2.80 toward $0.40-0.60. The risk is strategic: your free tier is your product demo, and if the free experience runs on a visibly weaker model, you're demoing a worse product than the one you sell. Works best when the free tier's core tasks genuinely don't need frontier capability (autocomplete, simple edits), with frontier reserved as an explicit taste of paid.
3. Credit systems (metered free allowance). This is the market's consensus move (Cursor, Windsurf, and Augment all landed here within a year of each other), and it's really lever 1 with better packaging: it converts unbounded cost risk into a bounded, predictable number per user, and it makes the cost of heavy usage legible to the user. It doesn't recover anything: it caps bleeding. Users tolerate it better than hard walls, but watching credits drain is a known experience tax, and every credit model quietly teaches users to ration their engagement with your product. Rationed engagement is the opposite of habit formation.
4. BYOK (bring your own key). Shifts inference cost to the user's own API account entirely: your variable cost drops to ~zero for those users. Honest and increasingly common for open-source and prosumer tools; Aider and Cline run this way by default. The trade: setup friction filters out exactly the casual majority a free tier is supposed to capture, and you surrender the pricing relationship (their spend goes to the model provider, not to you). A good escape valve for power users; a poor foundation for a growth funnel.
5. Reverse trials (premium taste, then downgrade). New users get full premium for 14-30 days, then land on the free tier rather than being locked out (Cursor's Pro trial is the familiar dev-tool example). Doesn't cut cost per user, but concentrates your expensive frontier-model spend on the window where it has the highest conversion value, and keeps a long-tail conversion relationship alive afterward. A sequencing optimization, not a cost fix: combine it with 2 or 3.
6. Attention monetization (the lever the playbook skips). Everything above either restricts the free tier or shifts its cost. There's one lever that makes free users produce revenue directly, without converting: monetizing the attention they already give the product. Dev tools are unusually rich in watched moments: a build streaming output, a test runner printing its summary, an agent working through a task while the developer watches the console, a statusline that sits in view all day. Streaming and consumer apps settled this decades ago: Spotify and Duolingo both run ad-supported free tiers with paid ad-free upgrades, and nobody considers those products cheapened by it.
Levers 1-5 make the free tier smaller, cheaper, or someone else's problem. Attention monetization is the only one of the six that makes the free tier pay for itself while giving up nothing free users care about.
What's the lever actually worth? Same format as step 1, assumptions labeled, for two engagement profiles:
| Assumption | Casual free user | Daily-driver free user |
|---|---|---|
| Watched moments with a sponsor line | ~60/month (12 sessions × ~5 lines) | ~600/month (~20/day) |
| Illustrative CPM (developer audience) | $8-15 | $8-15 |
| Publisher revenue share | 50% | 50% |
| Attention value per free user | $0.24-0.45/month | $2.40-4.50/month |
For the casual user, that offsets a slice of the $2.80/month cost from step 1. A daily-driver earns several times more, though its cost scales with that usage too, so the honest read isn't that attention fully covers a heavy user: it's that this is the only lever whose revenue grows with the same usage that drives the cost, instead of fighting it. Fill and demand aren't guaranteed, so treat these as ceilings rather than promises. It also does a second job free: "paid plans are sponsor-free" is an upgrade incentive that doesn't require degrading anyone's experience to create. And it isn't only for funded products: the same lever works for open source projects with users but no sponsors.
Step 3: The decision framework
Match levers to your actual cost structure:
- Cost concentrated in a heavy tail: burst limits / credit caps on the P95 (lever 1/3), leave the median alone.
- Free tasks don't need frontier models: model tiering (lever 2) is your biggest single cut. Take it.
- Prosumer/technical audience with API accounts: offer BYOK (4) as the pressure valve for power users.
- High engagement, watched surfaces (CLI, IDE panel, agent console, dashboard): attention monetization (6) is the only lever that turns that engagement from pure cost into revenue, and it stacks with all of the above.
- Low engagement, no surface: 6 does little for you; your answer is 2 + 3 and honest quota design.
Two examples of the framework in use. A coding agent CLI whose free users run it daily has both a brutal P95 tail and a console people actually watch: it should stack burst caps on the tail (1/3), mid-tier models for routine steps (2), and a sponsor line in the run summary (6). A GUI client that free users open twice a month has neither the tail nor the engagement: its answer is model tiering plus honest quotas, and lever 6 would recover pennies.
The pattern worth noticing: levers 1-5 all manage cost by reducing or redirecting what free users get. Lever 6 is the only one that improves the economics while leaving the free experience intact, arguably improving the funnel, since a sustainable free tier is one you can afford to keep generous. The strongest configurations in practice stack a cost cut (model tiering), a tail cap (burst limits), and a revenue offset (attention), rather than betting everything on restriction.
Where the sponsored-line option comes from
We're not a neutral party on lever 6: it's the product we build. ADtention renders one clearly labeled sponsor line in a watched moment you control (a status bar, a run summary, an agent console), placed and styled by you, sending only a broad category and pseudonymous delivery metadata (never prompts, code, files, or identity), with a kill switch on your side and 50% of billable impression revenue to you. It's a small HTTP integration, and it only makes sense if your tool actually has watched surfaces and real engagement: the decision framework above tells you whether that's you before you spend an hour on it. If it is, send a GitHub repo or product URL and get a product example for your tool: one safe placement, a sample sponsor message, and the economics, with no code and no call.
Whatever you do about lever 6, do step 1 this week: compute your actual cost per free user and find your P95. Every pricing decision downstream gets easier once that number stops being a guess.