Lately I use an AI coding agent almost every day — writing GIS data-processing scripts, debugging code across different projects, that sort of thing. The problem I keep running into isn’t the model’s capability, it’s that tokens run out faster than expected, especially on Antigravity, where sometimes just a few rounds of work is enough to hit the limit and force a reset or a switch to a different model.

I recently came across a project called tokless by HoangP8, so I tried installing it alongside my usual workflow, and it genuinely helped: the same amount of work used noticeably fewer tokens, letting a session run longer before running dry. But before getting into tokless, there’s a more basic thing worth thinking about first — choosing the right model for the job — which affects cost/quota far more than most people realize. So this post covers both: picking the right model, then what tokless is, how it works, and how to install it.

Why tokens run out so fast

A common issue for anyone using an AI coding agent is that the context fed into the model each turn balloons far beyond what’s actually needed. For example:

• Running a command that dumps a page of output, when the AI only needs a line or two of it
• Having the AI read an entire file just to find one function
• The AI’s own replies running long, over-explaining things that don’t need it
• Heavy data-processing tasks where the AI has to pull the full raw output back into context

Every one of these burns tokens unnecessarily, and it adds up fast within a single conversation.

First things first: pick the right model for the job

There’s something worth addressing before tokless, because it saves even more, and it should be step one: matching the model to the size of the task, rather than leaving the top-tier model running for everything.

A lot of people (myself included, in the past) get into the habit of leaving the most powerful model on at all times, even for work that’s just fixing a typo, writing a docstring, or a small refactor — the kind of thing a smaller model handles just fine. The catch is that the per-token price gap between top-tier and smaller models isn’t a small difference — it’s often several times over.

Here’s a price comparison per 1M tokens (based on official pricing pages at the time of writing — prices change often, so check the latest pricing page before relying on this):

On the Anthropic side alone, the gap between the top-tier and smallest model is about 5x on both input and output. On the OpenAI side it’s even starker — roughly 40–50x between the flagship and the small model. Same amount of work completed, but the cost (or quota burned) is in a completely different league.

So before reaching for a tool to save tokens, ask yourself first: does this task actually need the top-tier model? If it’s a large, complex project — architecture planning, gnarly debugging — switch to the top-tier model. But for small, routine, repetitive tasks that don’t need heavy reasoning, a mid-tier or small model is enough, and it makes your existing quota/credits last a lot longer.

Once you’ve matched the model to the task, add tokless as a second layer, to cut down on the tokens still leaking out of each individual request. The two work at different layers and stack cleanly — no overlap.

What is tokless

tokless is a single CLI tool that bundles four token-saving plugins covering the most common places tokens get wasted, and it supports the major agents: Claude Code, OpenCode, Codex, and Antigravity.

• RTK — filters noisy bash/tool output before it reaches the model. The README gives an example of 45 lines (~800 tokens) of output trimmed down to 12 lines (~150 tokens).
• Caveman — nudges the AI toward terse, to-the-point replies instead of long preambles. The README’s example shows an explanation that used to take 69 tokens cut down to 19.
• CodeGraph — lets the agent query a code graph to find what it needs, instead of reading whole files.
• Context-Mode — runs heavy data-processing work in a sandbox and returns only the relevant results, not the full raw output.

What I like about it is that it doesn’t force you to change how you work — install it once, and all four plugins run in the background of whichever agent you’re already using.

What I found in practice

I compared my usual kind of work (writing/fixing code, running commands to check results, having the AI explain code) with and without tokless installed, mainly on Antigravity. What stood out clearly was that the same session lasted noticeably longer before running out of tokens or hitting the limit, while completing a similar amount of work. In short: same output, fewer tokens spent — which lines up with the example numbers tokless shows in its own README (about an 81% reduction in bash output and about a 72% reduction in reply length, in their example case).

I haven’t run a rigorous benchmark (exact token counts across a fixed number of tasks), but from day-to-day real use, the difference was clear enough that I’d recommend giving it a try.

Installation

macOS / Linux

curl -fsSL https://raw.githubusercontent.com/HoangP8/tokless/main/scripts/install.sh | bash

Windows (PowerShell)

irm https://raw.githubusercontent.com/HoangP8/tokless/main/scripts/install.ps1 | iex

Running tokless on its own launches an interactive setup where you pick which plugins to install and which agents to enable them for (e.g. Claude Code, OpenCode, Codex, Antigravity).

To install for specific agents only, pass a flag:

tokless --agents claude,antigravity

To preview what would change without actually installing:

tokless --dry-run --verbose

Commands you’ll use often after installing

Check the current configuration status — which plugins are active, and whether anything’s wrong:

tokless doctor

Update plugins to the latest version, with a diff preview of what’s changing:

tokless update

To remove everything:

tokless uninstall

Wrapping up

If you use an AI coding agent regularly and feel like tokens run out too fast — especially now that Antigravity has gotten so popular — do these two things together:

1. Pick the right model for the job first — small, repetitive tasks only need a mid-tier or small model; save the top-tier model for work that genuinely requires heavy reasoning. This alone can save you several times over, based on the price gaps above.
2. Add tokless on top to cut down on the tokens leaking out of each request, regardless of which model you’re running.

It takes only a few minutes to install, doesn’t require changing how you work, and lets a session run noticeably longer. In my own use, I got the same amount of work done while burning through noticeably fewer tokens.

If you try it, I’d love to hear how it goes.

References

• tokless — GitHub repo
• Anthropic — Claude API pricing
• OpenAI — API pricing

Model prices above are as of the time of writing (September 2026). Providers frequently adjust pricing and release new models, so check the official pricing pages again before relying on these figures.