$1,257 Worth of AI Inference on $20 Plans

Over the past few weeks, I've been going back to some of my older projects.

Most of these were projects I built while learning different technologies. Some were built for hackathons, some were experiments, and others were applications I had deployed but never properly revisited.

The problem with old projects is that they tend to age quickly.

Dependencies become outdated, architectures that made sense initially start showing their limitations, and things that worked during development don't always hold up in production.

So I started revisiting them.

The idea was simple: fix existing issues, improve the architecture where necessary, clean up older implementations, and get some of these projects into a better state.

At the same time, I wanted to experiment with different AI coding agents.

I've been using Cursor, OpenAI Codex, and Google Antigravity across these projects, switching between models depending on the task.

I wasn't trying to benchmark them under controlled conditions. I was using them for actual development work and seeing how they handled existing codebases.

Some tasks involved understanding old implementations. Others involved debugging, refactoring, reviewing dependencies, and working through issues across multiple files.

And apparently, that consumed quite a lot of tokens.

The Numbers

I recently checked my usage dashboard in T3 Code.

Over a 30-day period, it reported:

That $1,257 figure caught my attention.

At roughly ₹95 per dollar, it represents close to ₹1.2 lakh in estimated API-equivalent inference.

For context, the standard monthly subscriptions I've been using are around $20 each.

Some of these subscriptions came through promotional offers, so my actual spending was lower.

Still, comparing roughly $60 in standard subscription prices against $1,257 in estimated API usage is interesting.

Not because I necessarily saved $1,200, but because it shows the amount of inference accessible through consumer AI subscriptions.

How the Usage Was Distributed

The usage wasn't evenly distributed across the three platforms.

One thing immediately stands out.

Antigravity processed approximately 3 billion tokens but had a much lower estimated cost than Cursor, which processed 772 million.

This comes down to differences in model pricing, caching, and the type of inference involved.

It also explains why comparing AI subscriptions purely through token counts isn't particularly useful.

A billion tokens on one model can have a completely different cost from a billion tokens on another.

What Was I Actually Doing With These Models?

Most of this usage came from trying to improve existing projects rather than continuously generating new applications.

Projects like my deployment and infrastructure tools have several moving parts. There is application code, backend logic, server configuration, process management, deployment behavior, and sometimes multiple services interacting with one another.

When revisiting code like this, the difficult part isn't necessarily writing a new function.

It's understanding what already exists.

A coding agent may need to read multiple files, follow dependencies, inspect error logs, understand how services communicate, and then make changes without breaking existing functionality.

Consider an older full-stack application.

A seemingly simple dependency upgrade can introduce issues in routing, authentication, database queries, or the build process.

The agent might inspect the existing implementation, suggest changes, run tests, encounter errors, read more files, and try again.

Each interaction consumes inference.

And when you're doing this across several projects, the numbers add up quickly.

I also found myself switching between models instead of relying on a single one for everything.

Sometimes I wanted another model to review an implementation. Other times I wanted to compare how different agents approached an issue or understood a codebase.

This wasn't an attempt to maximize token usage.

I was primarily trying to get old projects working properly again while understanding where these tools were useful and where they still needed supervision.

The Interesting Part: Caching

Of the 4.41 billion tokens processed, approximately 3.92 billion were cached input tokens.

That's almost 89% of the total.

Initially, 4.41 billion sounds like an enormous amount of inference.

But there's an important distinction between processing tokens and generating new output.

Coding agents repeatedly consume context.

They read repository files, previous conversations, tool outputs, code changes, and system instructions.

When much of that context is reused, caching can reduce the cost of processing it again.

My dashboard estimated approximately $3,591 in cache savings.

That doesn't mean I received an additional $3,591 worth of billed API usage. It's an estimate of how much more expensive the cached operations might have been without caching.

Still, it highlights something important about coding-agent economics.

The cost of an AI agent isn't determined only by how much code it writes. It's also determined by how much context it repeatedly processes while working.

And large, existing codebases can involve considerable context.

What Does a $20 Subscription Actually Get You?

This was the question I became more interested in after looking at the dashboard.

Cursor Pro, ChatGPT Plus with Codex, and Google AI Pro are all available at approximately $20 per month at their standard US prices.

But they don't provide identical allowances.

Cursor uses model-dependent included usage and can support additional paid consumption.

Codex has usage limits that vary with the model, task complexity, and usage window.

Google Antigravity also has its own model access and usage restrictions.

So there isn't a fixed number of tokens that every $20 subscriber is guaranteed to receive.

For comparison, my dashboard attributed:

• $679.21 of estimated API usage to Cursor
• $346.22 to Antigravity
• $231.89 to Codex

These are API-equivalent estimates, not the amounts the companies actually charged me or necessarily spent serving the requests.

And without reconciling the figures with each provider's billing records, I can't claim all of that consumption was covered by exactly one $20 plan per platform.

But the data gives an idea of the scale of workloads these tools are handling.

For someone actively maintaining several projects, a subscription can provide access to considerably more inference than its monthly price might suggest.

What About $100 and $200 Plans?

This raises another question.

If $20 subscriptions can support this level of activity, what does paying $100 or $200 actually change?

Higher tiers generally provide larger usage allowances and better access to certain models.

But five times the subscription price doesn't necessarily translate into five times the productive work.

A complicated refactor involving a large repository can consume far more context than multiple small fixes.

Likewise, a model that resolves an issue in one attempt may be more efficient than a cheaper model that requires repeated debugging cycles.

I've started thinking about AI subscription value in terms of completed work rather than raw tokens.

How many issues did the agent resolve?

Did the changes pass tests?

Did it understand the existing architecture?

How often did it introduce regressions?

And how frequently was I interrupted by usage limits?

These questions matter more to me than whether one subscription advertises a larger quota than another.

Does This Mean AI Companies Are Losing Money?

Not necessarily.

An API-equivalent estimate of $1,257 doesn't mean the providers spent $1,257 on my activity.

Public API prices are retail prices.

Actual inference costs depend on infrastructure, model optimization, batching, caching, routing, and other factors.

Subscription services also have usage policies and limits that influence their economics.

So I wouldn't use these numbers to argue that AI companies are losing thousands of dollars on every active subscriber.

What the data does show is that there can be a substantial difference between subscription pricing and the retail API value estimated for the same workload.

What I Took Away From This

I started this process because I wanted to revisit older projects.

Some of the code needed cleanup. Some projects needed fixes, while others deserved a more serious attempt at improving their architecture.

Using different coding agents was part of that process.

The $1,257 usage estimate was something I discovered along the way.

After 236 sessions and 4.41 billion processed tokens, my main takeaway isn't that one model is better than another or that everyone should buy multiple AI subscriptions.

It's that coding agents are increasingly capable of working with substantial existing codebases, and the amount of inference involved in doing that is easy to underestimate.

A lot of the work isn't generating code from scratch.

It's reading, understanding, debugging, reviewing, and iterating.

And that's where a large portion of those billions of tokens went.

For now, I'll keep using different models across my projects and observing how they behave with real development tasks.

I'm more interested in whether they help me maintain better software than in how many tokens I can consume.

But seeing ₹1.2 lakh worth of estimated API usage on a dashboard was definitely worth investigating.