For a while, the loudest trend in AI was token maxxing: burning through tokens, the units AI usage is counted and billed in, as if they cost nothing. The mood has flipped, and now every team wants to spend less, get more and prove the investment pays back. I always found token maxxing a bit ridiculous, and I'm pretty sure that in a few months we'll look back at it very differently.
Almost every conversation about cutting tokens is about money, though, and almost none of it is about quality. I learned the hard way that you can't separate the two. When I went looking for where my tokens were going, most of the waste turned out to be in my own setup before I'd asked for anything, and the savings that looked cheapest were often the most expensive ones. Everything I learned along the way went into Token Optimizer, an open source tool that has crossed 30K users in just a few months.
I paid $200 a month and still hit the wall
This might sound familiar to anyone with an AI subscription. My Claude Code subscription started at $20 and climbed to $100 and then to $200. Even at $200 I kept hitting the limit, because I build several projects in parallel. I'd get stuck and wait, usually for less than an hour, but still. The easy way out was to buy extra usage, which bills you API prices and gets expensive fast, so I decided to understand what was actually going on and how to cut it down.
There was a professional reason too. At 10x Company I build agents and AI systems for companies, and if I don't work with this technology properly, the costs blow up for my clients as well as for me. So I started investigating where the waste comes from, and the first answer is one you learn fast once you work with coding agents.
In the end, everything is context.
Context is everything you feed your agent: the knowledge and information it needs so it can act in the world for you. You're building its world for it, and the classic rule applies, garbage in, garbage out. So when you want to spend fewer tokens, context is the first place to look.
My setup was eating tokens before I typed a word
I didn't plan to build my own tool. I looked at what was out there first, hoping to find something that would save a bit here and a bit there, and I noticed that none of it looked at the actual quality of the work. When savings come at the expense of output quality, the savings are an illusion, because you'll spend five times more fixing the mistakes. So I jumped in and started with what was happening on my own machine, and the first leaks were sitting right in my personal setup.
Skills were the first one. A skill is packaged expertise, a set of instructions your agent picks up when a task needs it, and I love them. The catch is that each installed skill's description loads into the context window, the agent's working memory for the session. One skill with a 100-token description might be perfectly fine. Fifty or sixty of them, let alone 200, and you're burning thousands of tokens for nothing, every single session.
Connectors work the same way. MCP connectors are the plugs that hook your agent up to your other apps, and each one brings its own list of tools, so every tool adds another description the model has to read.
You pay for all of this before you've asked your agent for anything. Cleaning it up was the very first thing Token Optimizer did, and that first version saved me about 40,000 tokens on every session.
The cheap model sends you a second bill
The second lesson bothered me even more. Most advice for saving tokens is to hand the task to a cheaper model. So instead of asking Opus to do my research, I ask Sonnet, because Sonnet costs less, and on paper I've saved. But if the research comes back weaker than what Opus would have given me, I end up doing the work again, and the saving disappears.
If I'm now doing the work twice because the output wasn't good enough, I've wasted two times, three times more tokens.
Quality mattered to me in everything I built for exactly this reason. Matching each task to the right model is a real skill (it's the problem I built Outsourcerer to solve), and a saving only counts when the work still holds up.
Token Optimizer follows the same principle, and you don't need to be technical to use it. If you work with coding agents, you hand it the link and say, "Hey, install this thing for me." It then offers to audit your setup, from your connectors and skills to your memory and CLAUDE.md or AGENTS.md (the instructions file your agent reads every session), and shows you exactly where you're wasting, something like "you have 50 skills here and you actually use 10." Nothing changes until you approve it.
But the audit is just the beginning. Token Optimizer works in the background and compresses your context so fewer tokens go out each time, only where quality doesn't suffer. And nothing is lost, because the agent can instantly recover any compressed context when it needs it. Session continuity is built in too, so your agent remembers your sessions, the tool call results, the big decisions and every important piece of context. You can always start fresh without losing anything: open a new session after a coffee break, say "a moment ago we worked on this, let's continue," and pick up right where you were.
I don't collect any data, and I like it that way, because I built it to give something back. So the only numbers I can show you are mine: in the last 30 days it saved me almost 2,000 dollars, and at that point it had at least 8,000 or 9,000 installs. That's one person's savings, on a tool that runs on thousands of computers.
Let your agent interview you
Cleaning up waste is one half of the job, and the other half is giving your agent good context from the start, which matters far more than prompts. Please don't pay anyone to teach you how to write a prompt, because Claude will happily write one for you. Your time is better spent building your agent its brain.
There's a huge amount of hype around agents right now. "We run 20 agents that work while we sleep." Great. Nice. Cool. For most people that sounds like something they could never do, and the truth is it really isn't that scary. An agent is basically a folder. Inside it are what we at 10x call building blocks, and one of them is knowledge, the "what" of your world. When I manage a client, for example, that client gets a subfolder with files on who they are, summaries of our calls, what's on the table right now and which tasks are still open.
When I built my own brain, my personal OS, I deliberately didn't copy one of the many frameworks out there. I learned long ago that copy-paste in this world doesn't give good results, because you end up with a structure built around someone else's way of working, and it starts messing things up for you. So I had the agent build it with me. I told it, "You'll help me build this folder, which will be your brain. Ask me questions, pull every piece of information you can out of me, and tell me where you think there's a gap." It's one of the biggest tips I can give anyone, because it gets the knowledge sitting in your head out and into the work.
And every time you're missing something, ask me a question. Don't guess.
Once the brain exists, you work inside it. Open Claude Code in that folder and it already knows who you are, what you discussed with each client and which tasks are open. Ask for a landing page for a client and it goes straight to their folder, finds their branding assets and builds the page the way it should be, with no explaining from scratch, and every explanation you don't have to type is tokens you don't spend.
Skills make the brain stronger still. They are the packaged expertise, the methodologies that, in effect, become the operational memory of your agent's brain. My deep research skill, for example, sends out up to about 17 sub-agents, each responsible for a different slice of the research. One reads and analyzes YouTube transcripts, and another has a single job, checking that every source the others brought back is real and accurate.
Memory, so you never explain yourself twice
The brain folder has its weaknesses. Your agent only knows it while you're working inside it, and someone has to keep it up to date and make sure the relevant information sits at the top. With time you become the maintainer of your own knowledge and memory, or of the setup you built to maintain that layer. Lessons you teach along the way are even more fragile. You correct your agent, you even tell it "never do that again," and maybe it wrote that down somewhere and maybe it didn't, so the same mistake comes back.
I built Total Recall for exactly that. It's automated, proactive memory, the kind where your agent remembers without you having to work at making it remember. With it, I open a completely empty session, without even opening the project folder, and say something like, "Remember the landing page we built for the client at company A, all the corrections I gave you and every bug we hit putting it live? Build me exactly one like that for client B, and this time make it work." And it does. It runs locally, only on your computer, and it reads your session history in a way that saves up to 97% of tokens compared with markdown-based memory. And it's the same brain for all your agents, so Codex and Devin remember what Claude decided and why, and Hermes remembers which projects are running and how far along they are.
Most things don't need to be agents
If you're just starting with Claude Code and hitting walls, my first tip sounds almost too simple: ask it. People forget this all the time. You don't need to google how something works, you can ask Claude Code, "If I want to do this and this with you, how do I do it?" And make it ask you questions, always.
My second tip is to start from the problem. Look at what hurts and what bugs you in your day, and build for that. Most of it won't need an agent. The word "agent" scares people right now, and most of the beautiful automations you see online turn out to be a skill, or an automation that runs on a schedule and moves one thing, which moves something else.
Most things don't need to be agents. So first of all, remember that. Sometimes, and most of the time, a high-quality skill is enough for you.
Token Optimizer started exactly that way. I had one annoying problem, my limits, so I cleaned up my setup and wrote a skill that could do the cleanup for me. The skill grew into a whole platform, and the cleanup is now just one of the things it does.
Key moments
- 28:17My Claude Code plan climbed from $20 to $100 to $200, so I built Token Optimizer and put it on my GitHub for everyone.
- 29:04All the waste traces back to one thing, context.
- 29:46Token minimizing talk is all money and no quality, and a cheaper model can cost more.
- 33:10Have your agent interview you to build its brain, instead of copying someone's framework.
- 36:55Skill descriptions and connectors were the hidden leak, and the first cleanup saved about 40,000 tokens a session.
- 41:57Total Recall lets an empty session rebuild past work, corrections and bugs included.
- 46:01Start from the problem, and remember most things don't need to be agents.
Alex Greenshpun is an AI strategist and builder and co-founder of 10x Company. She builds Total Recall, Token Optimizer and Outsourcerer.
