Last month, I used 878 million tokens while developing software with a $20-per-month Cursor Pro subscription. I’m curious to see how much useful development I can accomplish while keeping my monthly Cursor spending within that $20 budget.[1] It’s a bit of a game and helps me to understand people if really need expensive models for daily work.
My 878-million-token workload last month would cost about $1,545 using Claude Opus 5.5 through its API, even with 80% of those tokens billed as discounted cache reads. The same assumed mix would cost approximately $4,214 using OpenAI’s GPT-6 Astra API.[2][3][4]
The comparison shows why learning to allocate work among models can matter financially.
The question I keep returning to is this: How will demand for expensive AI models change as people become better at choosing when to use them?
Setting Up Cursor
Go to Cursor settings.
Go to models.
Disable everything except for Composer 2.5 and Grok 4.7. These are the latest as of Oct 1, 2026.
Make sure you have disabled Fast. Cost increasingly dramatically when fast is enabled. Instead of expecting speed per process, use parallel agents for different tasks.
Use Grok 4.7 high when you need to. Set to 256k context window (default) to reduce costs.
In addition to the setup, I also actively try to use the cheap tokens from Composer 2.5.
I use Plan mode aggressively before starting a long-running task. To help with architecture analysis I wrote a bash script to zip up the relevant files and feed it into a ChatGPT Plus ($20/month account) for additional analyzing by GPT Sol, Terra, Luna. My code base has CONTEXT.md, STATUS.md and other docs to help the LLMs read the code faster and hopefully more cheaply.
I’m interested in more actively trying to use Codex against my token allocation from the ChatGPT Plus account. However, since I started with Cursor more than a year ago, I haven’t looked at Codex that much. I’m curious to get feedback.
My effective cost: about 2.28 cents per million tokens
Allocating the entire $20 subscription fee to my reported token usage gives me this calculation:
$20 ÷ 878,000,000 tokens = approximately $0.0000000228 per token.
That is easier to understand as:
| Measure | Effective subscription cost |
|---|---|
| One token | $0.0000000228 |
| One million reported tokens | $0.0228 — about 2.28 cents |
| 878 million reported tokens | $20.00 |
| Reported tokens per dollar | 43.9 million |
This is my effective subscription cost per reported token. Cursor’s underlying model rates and the provider’s cost of supplying compute are separate numbers. The subscription also includes product features beyond token processing.
For a rough workday comparison, dividing 878 million by 22 weekdays gives approximately 39.9 million tokens per working day. That assumes a 22-workday month; it is not a reconstruction of my actual daily activity.[1:1]
My next target is to exceed one billion productive tokens in a billing cycle while staying within the same $20 subscription. At that volume, my effective cost would fall to two cents per million reported tokens.
The word productive matters. A coding agent can accumulate tokens by processing repeated context, rereading files, and retrying work. I care about the application that gets built, tested, and improved.
What would those tokens cost on more expensive models?
API pricing usually distinguishes ordinary input, cached input, and output. Cached input is previously processed context that qualifies for a reduced rate. Consequently, the total token count alone cannot establish an exact bill.
Here are published standard rates checked on October 1, 2026. OpenAI flagship rates below use the short-context tier; Composer uses its standard, non-Fast rate.[5][3:1][2:1]
| Model | Ordinary input / million | Cached input reads / million | Output / million |
|---|---|---|---|
| Cursor Composer 2.5 | $0.50 | $0.20 | $2.50 |
| OpenAI GPT-5.3-Codex | $1.75 | $0.175 | $14.00 |
| OpenAI GPT-6.1 Sol | $2.00 | $0.10 | $10.00 |
| Claude Sonnet 5.5 | $2.00 | $0.20 | $10.00 |
| Claude Opus 5.5 | $4.00 | $0.20 | $20.00 |
| OpenAI GPT-6 Astra | $10.00 | $1.00 | $50.00 |
To make the comparison concrete, consider two hypothetical workloads with the same 878 million total tokens:
- Scenario A: substantial caching. 80% cached input reads, 15% ordinary input, and 5% output.
- Scenario B: no caching. 90% ordinary input and 10% output.
These percentages are assumptions, rather than measured breakdowns from my Cursor account. They illustrate how much the result depends on caching and output volume.[4:1]
| Model or observed plan | Scenario A: substantial caching | Scenario B: no caching |
|---|---|---|
| My observed Cursor subscription cost | $20.00 total | $20.00 total |
| Composer 2.5 at published token rates | $316.08 | $614.60 |
| GPT-5.3-Codex API | $968.00 | $2,612.05 |
| GPT-6.1 Sol API | $772.64 | $2,458.40 |
| Claude Sonnet 5.5 API | $842.88 | $2,458.40 |
| Claude Opus 5.5 API | $1,545.28 | $4,916.80 |
| GPT-6 Astra API | $4,214.40 | $12,292.00 |
The $20 row is my reported monthly spending, repeated as a reference point. It does not imply that I measured either scenario in Cursor or that Cursor promises those workloads for $20.
For example, Scenario A contains 702.4 million cached input tokens, 131.7 million ordinary input tokens, and 43.9 million output tokens. At Opus 5.5’s published rates, the arithmetic is:
(702.4 × $0.20) + (131.7 × $4.00) + (43.9 × $20.00) = $1,545.28.
That is $1,525.28 more than my $20 subscription cost, or approximately 77 times as much. For GPT-6 Astra, the corresponding difference is $4,194.40, or approximately 211 times the subscription cost.
The Composer row reveals something equally important: my result depends on subscription packaging as well as model selection. Even Composer’s published token rates produce a hypothetical total well above $20. My effective rate cannot be explained by the cheaper model alone.
These calculations exclude cache-write premiums, tool charges, taxes, and infrastructure costs. They use standard rates without Batch or Flex discounts. Different models also tokenize text differently and may require different numbers of steps to complete a task. The table compares a fixed assumed token volume; it does not establish the cost of obtaining identical engineering results.[4:2]
What if I had left Codex or Claude on an expensive model?
The answer depends on how I was paying.
With metered API access, a high-volume workflow could produce bills like those above, subject to the actual token mix, applicable rates, and account limits. OpenAI explicitly distinguishes API-key usage, which follows API pricing, from included ChatGPT plan usage.[6]
With Codex through a ChatGPT subscription, the first consequence could instead be faster consumption of my included allowance. OpenAI documents plan usage limits and options to purchase additional credits. Selecting an expensive model does not automatically turn a subscription into an unrestricted API bill.[6:1]
Claude also offers subscriptions separately from its API pricing.[2:2] Likewise, Cursor separates its Cursor Models allowance from its Other Models allowance.[5:1] Leaving a more expensive model selected could consume the relevant allowance faster; additional spending would depend on the product’s billing settings and whether I enabled or purchased more usage.
So the defensible claim is: I used 878 million reported tokens within a $20 Cursor budget; an assumed API workload of that size can cost over $1,000 on a more expensive model. Demonstrating an exact savings figure for the same completed work would require a measured comparison.
Most of my work starts with the economical model
I am building Oppvera, an application for learning about AI search. My coding workflow includes inspecting files, implementing features, debugging, running tests, and coordinating changes across a growing codebase.
For much of that work, I use Composer 2.5 in its slower mode. As the code becomes more complex, I encounter tasks where it struggles. Those are the situations where I turn to Grok 4.7 with High effort, then return to Composer for routine follow-up.
That experience has changed the question I ask when selecting a model:
Which model can reliably complete this job at the lowest total cost?
The total cost includes my time. A more capable model that resolves a difficult bug immediately can be more economical than repeated unsuccessful attempts with a cheaper model. I am learning to recognize those escalation points.
Human experience could change the demand mix
My hypothesis is that many people are still learning the practical differences among models: their costs, their strengths, their failure modes, and the value of additional reasoning effort.
I learned by watching my own usage. After an upgrade, I believe my setup had switched to Auto and enabled additional models. Seeing my Other Models allowance fall faster than my Cursor Models allowance prompted me to select models more deliberately. That observation changed my behavior; it did not establish which setting caused every charge.
As workers gain experience, they may become better at recognizing that one task fits an economical model while another needs a more capable model. Organizations may also automate these decisions.
That could change the share of work going to expensive models, even if overall AI adoption keeps growing.
I suspect the incentives differ when a company pays the bill. Imagine an employee with a $500 monthly AI budget who rarely sees the cost of individual tasks. That is an illustrative example, rather than a claim about typical corporate spending. For that employee, choosing the strongest available model may be easier than investigating whether a cheaper one would work.
If employers introduce meaningful cost visibility and evaluate completed work alongside spending, behavior may change. They also need to account for employee time: saving a few dollars of inference can be a poor trade if it creates hours of rework.
Model allocation may become a basic part of AI literacy.
Expensive models could become specialists
My workflow suggests a possible pattern: economical models handle much of the routine work, and expensive models handle difficult decisions or resolve problems that block progress.
The expensive model can remain extremely valuable while processing a smaller share of the tokens. A short intervention that fixes an architectural problem may be worth more than millions of tokens spent on routine edits.
This is a hypothesis based on one person’s experience. Some workloads may consistently benefit from a stronger model. Others may require so little inference that model pricing barely matters compared with the worker’s time.
What interests me is whether forecasts of future AI demand adequately account for users becoming more skilled at these choices.
What this means for AI infrastructure
Large AI infrastructure investments depend partly on expectations of future demand. My experiment raises a question about the composition of that demand: how much will come from expensive inference, and how much from enormous quantities of inexpensive inference?
It also illustrates why cheaper models can expand usage. An affordable subscription lets me experiment, delegate more work, and keep agents operating longer. Lower cost may create demand for activities I would otherwise skip.
Whether that added usage outweighs efficiency gains is an open question. One subscription experiment cannot establish an industry-wide rebound effect or the profitability of a data center investment. My $20 spending also tells us little about the provider’s underlying compute costs or margins.
Nevertheless, two changes could happen together: users allocate a smaller fraction of their work to expensive models, while total AI workload grows substantially.
That would create a future in which frontier models remain valuable and economical models process much of the volume.
The next billion tokens
I find this experiment satisfying because the constraint is concrete: build useful software while keeping my Cursor bill within $20 a month.
Last month, that meant 878 million reported tokens at an effective cost of about 2.28 cents per million. My next target is one billion, accompanied by working features, useful tests, and a better application.
The skill I am developing is knowing when to keep working with Composer, when to escalate, and when to switch back. As more people learn that skill, the market for expensive models could look different from today’s usage patterns.
Sources and calculation notes
Personal figures reported by Craig Oda in this experiment: 878 million Cursor tokens in the preceding month and a $20 monthly subscription budget. The article assumes no additional usage charges. These are user-reported observations, rather than independently audited account exports. The 39.9-million-token daily figure divides the total by an assumed 22 weekdays; a billing cycle can have a different weekday count. ↩︎ ↩︎
Anthropic, Plans & Pricing, checked October 1, 2026. Source for Claude Sonnet 5.5 and Opus 5.5 input, cache-read, and output API rates, and for the distinction between subscription plans and API pricing. Cache writes have separate prices. ↩︎ ↩︎ ↩︎
OpenAI, API Pricing, checked October 1, 2026. Source for standard short-context GPT-6.1 Sol and GPT-6 Astra rates, and standard GPT-5.3-Codex rates. Other processing modes, long-context tiers, and applicable cache-write charges can change costs. ↩︎ ↩︎
Author’s illustrative calculations, using the published rates above. If token quantities are expressed in millions, token cost equals
(ordinary input × input rate) + (cached input reads × cache-read rate) + (output × output rate). Scenario A allocates 878 million tokens as 80% cached reads, 15% ordinary input, and 5% output. Scenario B allocates them as 90% ordinary input and 10% output. Neither mix is measured account data. Cache-write premiums, tool fees, taxes, hosting, processing discounts, and model-specific changes in token volume are excluded. Values are rounded to cents. These are pricing scenarios, rather than measured savings for equivalent completed work. ↩︎ ↩︎ ↩︎Cursor, Models & Pricing, checked October 1, 2026. Source for Composer 2.5 standard token rates and the separation of Cursor Models and Other Models usage pools. Published model rates are distinct from the effective cost of included subscription usage. ↩︎ ↩︎
OpenAI, ChatGPT and Codex Pricing, checked October 1, 2026. Documents included plan usage, usage limits, additional credits, and API-key usage billed at API rates. An API-equivalent estimate should not be presented as an automatic ChatGPT subscription charge. ↩︎ ↩︎