Although it’s cheaper to use the official Anthropic and OpenAI apps for coding, I can’t stop using Cursor.
For me, it’s the best way to multitask. I can easily switch between and combine different agents, models, and projects without losing track.
Here’s what I do to keep the costs under control.
0. The most expensive plan is the cheapest plan
I use Cursor Ultra. It costs $200 per month and includes $400 in API credits, plus a large number of Composer 2.5 credits.
The $20 plan only includes $20 in API credits. As a heavy user, I spend well over $400 per month on API credits, so Ultra saves me $200 every month.
1. Start with the cheapest model
In addition to getting the cheapest credits, you should always use the cheapest model that can do the job.
For most work, that means Composer 2.5. It handles simple programming tasks, explores codebases, answers questions, manages my communication, triages work from different systems, and can coordinate work with human teammates through tools like Jira.
This already covers a surprisingly large part of my day. In a typical month, I use up about 60% of my Composer credits on the Cursor Ultra plan.
2. Let expensive models delegate
Some tasks are simply too complex for cheap models. Architecture, difficult debugging, and larger design decisions still benefit from expensive frontier models like Opus or Fable: using those will save money because fewer human hours need to be spent on reviewing and correcting the agent's work.
On the other hand, if you used Opus for a task where part of the work was simple but token-intensive (for example, exploring a codebase), you would still be wasting money unnecessarily.
The trick is to mix models within a single task. The expensive model should split the work into hard and easy parts, keep the hard parts for itself, and delegate the easier parts to cheaper agents.
For months I used a global Cursor Rule that told my orchestration models to always decide first whether a cheaper agent could do the work.
It turns out Cursor now already encourages this in its own system prompt, so if you use Cursor today, you are probably already benefiting from this delegation strategy.
The main time I still intervene is when I want a specific model for a specific role. For implementation work, I usually prefer GPT-5.5. It produces very good code, but uses tokens much more efficiently than Fable or Opus.
3. Bring your own model
Even with task delegation, my Cursor API credits were usually gone after about three weeks.
My first solution was to switch to Codex with GPT-5.5 once the credits ran out.
It worked, but I missed having everything in one place. Switching coding agent harnesses means your threads get scattered across multiple applications. When I use Codex, I also miss the Anthropic models that I like to use for orchestration and architecture reviews.
So I needed a solution that did not force me to leave Cursor.
As a Cursor Pro or Ultra user, you can use bring-your-own-model. Instead of using Cursor credits, you are billed directly by the model provider for inference. This can be cheaper because you avoid the markup or routing cost of API requests through Cursor.
My company has access to OpenAI models, but I can only use them through a LiteLLM router. I tried to connect that router to Cursor's bring-your-own-model support, but I could not get it working.
As a workaround, I now use a PI Coding Agent connected to LiteLLM. I added a Cursor Skill that tells any orchestrator agent how to use the PI Coding Agent CLI for implementation tasks.
Cursor still manages the task, but when implementation becomes expensive, the orchestrator can hand it off to GPT-5.5 through the PI Coding Agent.
4. Shrink your initial context
Every chat starts with rules, skills, and AGENTS.md before you type anything. If your AGENTS.md alone adds more than 100,000 tokens, the start of a conversation with Fable already costs you more than $1 before you ask your first question.
I removed any rules or skills I don't strictly need. Anything a linter can enforce belongs in lint rules instead. Those do not consume context, and they have the added benefit of being deterministic, so you do not need to retune them for every model you use.
I am also moving more rules and skills to project-specific config instead of global. Global is convenient because you keep everything up to date in one place, but not every rule applies to every project.
5. Keep paying attention
With my current setup I can:
- Keep using Cursor as my only IDE.
- Keep all of my chat history and context in one place.
- Continue using Opus and Fable for architecture and orchestration.
- Use GPT-5.5 for complex implementation work at a much lower cost.
I expect to stay well below $300 per month in inference costs throughout July 2026.
August is another story. The AI coding landscape changes fast. A new model could be both cheaper and more capable, or a new harness could help existing models use fewer tokens.
Perhaps the best money-saving tip is simply staying up to date.