I recently used Cursor Agent Mode with Auto Mode enabled to do something simple: recommend a font pairing and update two files in my project. An index.html and an index.css. That's it!

The agent added a Google Fonts <link> tag, a <link> Gstatic with a crossorigin within it, and shuffled a few CSS variables as well as styling rules for the body tag and H tags.

It cost 1% of my monthly usage budget.

At first that felt wrong. Two files. A handful of lines. One percent? But once I understood what was actually happening under the hood, it made complete sense and it has now changed how I use agent mode entirely.

Quick disclaimer: I got spoiled by subscription based models, and honestly, so did most of us. Just a few months back, you could just vibe code for a flat fee.
But the economics caught up. Companies have moved to usage based pricing because developers were essentially being subsidized to throw unlimited context at frontier models without thinking twice. Those days are over, and this post is my attempt to actually understand what I'm paying for now.

The bill isn't for the edit. It's for everything the agent had to read first.

This is the part that tripped me when moving from a flat subscription to usage based billing: you pay for input tokens, not just output tokens.

In my case, I tagged two files for context: an index.html and my index.css. That CSS file is about 200 lines of Tailwind v4 theme tokens, OKLCH color variables, shadow definitions, @theme inline mappings, and layer utilities. Even though the agent only touched a few lines, it had to read and process the entire file to understand where to make changes.

Input tokens are cheaper than output tokens, but they're not free. Large context files burn through them fast. And the bigger the files you tag, the bigger the bill regardless of how small the actual change turns out to be.

Agent mode isn't one request. It's a loop.

Here's what I learned: even in "ask" mode, a single prompt generates at least two requests (it can be more than two), one to understand the context, one to write the response. I assumed it was just one. It's not.

Agent mode is worse. A typical agent loop looks more like this:

1. Read the tagged files and understand the codebase
2. Plan the approach
3. Write and apply the edits
4. Sometimes re-read the result to verify it worked

Each step passes the context through the model again. That's why a task that feels like "one thing" can quietly rack up four or five API calls, each one carrying your full file context along for the ride.

If you don’t believe me, go to Google AI Studio, get you an API key, create a project, then open Cursor, add the key, add whatever model they have available to use, run a task and you will see how models like Gemini 3.5 or 2.5 Flash which gives you 5 Requests Per Minute and 20 Requests Per Day will scream at you with hitting a limit rate.

On top of that, Auto mode picks frontier models. Cursor's Auto setting tends to reach for the most capable model available (Claude Sonnet, GPT-4o, etc.) because it optimizes for quality. Those models cost significantly more per token than smaller, faster alternatives. A task that costs 1% on Auto might cost 0.2% if you'd locked it to a lighter model.

Three layers of cost to keep in mind

The surprising insight is that input often dominates. A short, focused prompt with a small, targeted file costs far less than a thorough prompt with several large files, even if the final edit is the same size.

When agent mode earns its cost

Agent mode is genuinely worth it when the task is multi-step and hard to do yourself: refactoring a component across six files, migrating an API pattern throughout a codebase, generating and wiring up new files from scratch.

But for "tell me what to change and I'll do it myself" tasks, a font recommendation, a CSS tweak, a quick code review, Ask mode is almost always the right call. You get the answer, you make the edit manually, and you spend a fraction of the tokens.

The question to ask before reaching for agent mode:

does this task actually need the AI to act, or do I just need the answer?

For my font pairing task, the honest answer was: I just needed the answer. I could have copied two lines into my files myself in ten seconds. That 1% was the cost of not stopping to ask that question.

A few habits that help

• Tag only what the agent needs to touch, not everything related to the task. If it needs to edit index.css, don't also tag App.tsx for background context unless it's truly necessary.
• Lock the model for simple tasks. Most IDEs let you override Auto mode and pick a specific model. For quick questions and single-file edits, a smaller model is usually more than capable.
• Use Ask mode as the default, and reach for agent mode only when the task genuinely requires it to take action across multiple steps.
• Think about context size before you tag. A 500-line file with one relevant section costs you 500 lines of input every single loop iteration.

The shift from subscription to usage based pricing isn't just a billing change; it's a prompt to actually understand what's happening when you ask an LLM to do something. Once you do, you stop thinking in terms of "tasks" and start thinking in terms of context, requests, and models. That's when costs start to feel intuitive rather than surprising.

And yeah, sometimes a font change really does cost 1%. Now you know why.

---

Let's Connect!

• Website: callmeizzy.dev
• YouTube: Call Me Izzy
• GitHub: @MrItzreal
• X / Twitter: @fullstackizzy
• LinkedIn: Israel (Izzy) Santana