I Was Bleeding Tokens in OpenClaw. Here's the System That Fixed It.

My AI token bill was getting embarrassing.

Not "oh that's more than I expected" embarrassing. More like "I accidentally left a premium model running background health checks every 5 minutes for a week" embarrassing. The kind where you open your usage dashboard, squint, close the laptop, and go for a walk. Or pour a drink to cry into.

So I did what any rational person would do: I panicked, then I built a system.

And honestly? It's the most useful thing I've done with AI all year—not because it's clever, but because it's obvious in retrospect. The kind of obvious that makes you wonder why you didn't do it sooner.

To be clear, I'm hooked on OpenClaw. (See what I did there?) From task 1 (cleaning up my desktop), I've been borderline obsessed. But a $45/day token habit was a problem immediately.

I downloaded, connected gpt-5.3-codex and started building. It's my go-to tool for all things vital, but I connected it to everything. One model to rule them all! Bwahahaha!

Then I got a notification I was out of token budget. So I reup.

Next day, notification.

Reup. Lather, rinse, repeat for a week or so.

Now I have a model stack. gpt-5.2, mercury-2, and gpt-5-nano.

So here's the core idea to my fix, and it's deceptively simple:

Stop asking "what's the best AI model?" Start asking "what's the cheapest model that can do this specific job reliably?"

That one reframe changed everything. Read this first to understand the philosophy, then you can download my model_policy.md file from my github. Just feed the github link to your OpenClaw and it will handle the rest.

The Problem: One Model to Rule Them All (and Bankrupt You)

Most of us, myself included, fall into the same trap. You find a model you like (hey there, gpt-5.3-codex), and you use it for everything. Writing emails. Summarizing docs. Monitoring workflows. Classifying data. Reformatting CSVs.

It's like hiring a brain surgeon to put on Band-Aids. Sure, they can do it. But you're paying brain surgeon rates for Band-Aid work.

Here's what I realized when I actually audited my workflows: most of my AI tasks weren't hard. They were repetitive. They were structured. They had clear right-and-wrong answers. And they absolutely did not need a frontier model thinking deep thoughts about them.

The expensive tasks, the ones that genuinely needed top-tier reasoning, were maybe 15-20% of my total usage. The rest? I was lighting money on fire.

The Fix: Think in Tiers, Not Models

The mental shift that saved me was moving from "which model should I use?" to "which tier does this task belong in?"

I broke my entire workflow into three tiers. Nothing fancy. Just three buckets:

Tier 1: Premium (The Decision-Makers)

These are the tasks where model quality is directly visible to humans, or where bad output creates real downstream problems. For me, this is where I use gpt-5.2 currently, but feel free to slot in your personal model of choice, like Claude Opus 4.6 or Gemini 3 Pro. Dealer's choice.

Use your best model here for:

• Nuanced judgment calls: anything involving tradeoffs, prioritization, or "it depends"
• Human-facing deliverables: content that ships with your name on it
• Voice-sensitive writing: where tone, style, and subtlety matter
• Ambiguous decisions: where the model needs to navigate gray areas
• Strategy and analysis: connecting dots across complex inputs

This tier earns its premium because a weaker model here creates cleanup work, brand risk, or bad decisions that compound.

Tier 2: Workhorse (The Middle Manager)

This is where most of your agentic work should live. Tasks that require reasoning, but not exquisite taste. This is where I use Mercury 2 from Inception Labs. It's powerful, fast as lightning, and exquisitely affordable. Here's a deep dive I wrote comparing it's use in OpenClaw vs. gpt-5-mini and Claude Haiku 4.5. No contest at this stage.

• Multi-step synthesis: research aggregation, structured drafting
• Agent loops and tool-using workflows: the stuff that runs in chains
• Structured content creation: reports, summaries with defined formats
• Any task with clear guardrails: where instructions are specific enough that a mid-tier model won't wander off

Think of it this way: if you can describe the task precisely enough that a smart intern could do it, it's probably a Workhorse job.

Tier 3: Utility (The Workhorse's Workhorse)

This is where you save the real money. These are the tasks that don't need to think—they just need to execute. For me, this is where I use gpt-5-nano. This is the type of scenario where you can save a fortune, reclaim some latency, and a significant amount of money.

• Health checks and status monitoring
• Data extraction and classification
• Short summaries of already-structured text
• Routing and formatting
• Pass/fail evaluations with clear rules
• Template filling
• Deterministic post-processing

Here's the thing most people miss: this tier is usually where your cost balloons. Not because each call is expensive, but because there are so many of them. Forty low-value background tasks running on a premium model will eat your budget faster than one complex analysis job.

How to Sort Your Tasks: The Five-Question Test

When I'm not sure where a task belongs, I run it through five questions. Takes about 30 seconds.

1. Visibility: Will a human directly see this output?

If yes, lean toward a stronger model. If it's internal plumbing that no one reads, go cheap.

2. Judgment: Does success require taste, prioritization, or tradeoffs?

If the task is mostly mechanical, like extraction, formatting, classification, a smaller model handles it fine. If it requires nuanced decision-making, bump it up.

3. Structure: How constrained is the output?

The more structured and templated the task, the more likely a smaller model nails it. JSON extraction? Utility tier. Open-ended creative brief? Premium.

4. Recoverability: If the model gets it slightly wrong, how bad is that?

If failure is cheap and easy to catch, downshift aggressively. If a subtle error could cascade through your system undetected, use the stronger model. Worth the insurance.

5. Verification: Can you automatically check if it's correct?

This is the sleeper question. If you can programmatically validate the output (regex checks, schema validation, test suites), cheaper models become much safer. You're not trusting the model alone here, you're trusting the verification layer, as well.

The Cheat Sheet

When in doubt, here's the quick mapping I keep taped to my mental dashboard:

• "Decide something" → Premium
• "Write in a specific voice" → Premium
• "Synthesize across sources" → Workhorse
• "Assemble from known inputs" → Workhorse
• "Check something" → Utility
• "Extract data" → Utility
• "Monitor and report" → Utility

Not perfect. But it's a shockingly good starting point for 90% of situations.

Where People Get This Wrong

The biggest mistake isn't using small models. It's using small models for the wrong things.

Small models are surprisingly capable at classification, extraction, short summaries, repetitive transformations, and pass/fail evaluations. Teams consistently underestimate them here.

Where small models get dicey:

• Open-ended prioritization
• Subtle voice matching (try getting Haiku to write in your exact brand voice—good luck)
• Nuanced critique or feedback
• Multi-constraint planning under uncertainty

So the error isn't "small models are bad." The error is "small models should do taste-heavy work." That's like asking your calculator to write poetry. Technically it has a screen, but... no.

Why This Matters Even More for Agent Workflows

If you're running agents—and if you're reading The Neuron, you probably are or will be soon—this becomes critical.

In agent systems, cost isn't about a single prompt. It compounds across scheduled jobs, retries, multi-step chains, background observers, QA loops, and fallback runs. One poorly assigned model tier can multiply across dozens of executions per day.

The cheapest meaningful optimization in most agent stacks isn't prompt engineering. It isn't caching. It's model assignment. Just moving your background monitoring tasks from Opus to Haiku (or equivalent) can slash costs without anyone noticing a quality difference.

The Metric That Actually Matters

Here's the trap: a model isn't truly "cheap" if it causes more reruns, more human cleanup, more validation failures, or more fragile workflows.

The right cost metric isn't API price per token. It's total operating cost:

• Model spend (the obvious one)
• Failure rate (how often it gets it wrong)
• Repair time (how long it takes you to fix it)
• Latency impact (does it slow everything else down?)
• Reliability drag (do you lose trust in the system?)

Sometimes a mid-tier model is actually cheaper in practice than a tiny one because it avoids the retry spiral. I learned this the hard way when I moved a synthesis task to utility tier and spent more time fixing its output than I saved on tokens. Classic.

How to Roll This Out Without Breaking Everything

Don't flip everything at once. That's how you end up debugging at 2 AM wondering why your agent just emailed a client something unhinged.

Here's the approach that worked for me:

Step 1: Inventory your tasks. List every AI job in your workflow. Sort by what kind of work it is, not which team owns it.

Step 2: Group by function. Judgment? Synthesis? Monitoring? Extraction? Formatting? QA? Put each task in a bucket.

Step 3: Downshift the safest jobs first. Start with the most procedural, most structured tasks. Move them to the cheapest model. These are your quick wins.

Step 4: Test manually. Run each newly downshifted job once, with your eyes on it, before you trust it to automation. Don't skip this. Seriously.

Step 5: Watch one full live cycle. One synthetic test ≠ production reality. Let it run through a real cycle before you declare victory.

Step 6: Escalate selectively. Only move a task back up the tier stack if quality or reliability clearly degrades. Don't preemptively upgrade out of nervousness.

This gives you a stable optimization loop instead of random model-swapping chaos.

The TL;DR Policy

If I had to boil this entire system down to a sticky note:

• Premium models for visible judgment
• Workhorse models for agentic synthesis
• Utility models for operational plumbing
• Keep one fallback model for continuity (for me, it's gpt-5.3-codex)
• Re-evaluate based on task performance, not model hype

That's it. That's the whole thing. No fancy routing algorithms. No ML-on-ML meta-optimization. Just honest task assessment and disciplined tier assignment.

The future of AI cost optimization isn't picking one cheap model and using it everywhere. It's building a task-aware routing policy. Knowing which jobs need the expensive brain, and which ones just need a reliable pair of hands.

My token bill? Down roughly 40-60% depending on the week. And the quality of my actual high-stakes outputs? Better—because I'm spending my premium tokens where they actually matter instead of burning them on health checks.

The unit of optimization isn't the prompt. It's the job.

Now if you'll excuse me, I need to go check which of my background tasks I accidentally left on Opus again. Old habits die hard.

Have a model routing strategy of your own? Reply and tell us about it—we're always looking for ways to be less broke.