How I Cut My AI Bill from $200/Month to $2.40

Last month I ran 25 AI agents across 4 businesses.

API bill: $2.40.

Not $240. Not $24. Two dollars and forty cents.

Before I figured this out, I was spending $150-200/month on AI API costs — and that was just for me, one person. I know people running larger operations spending $500-2,000/month on API fees alone, treating it like a fixed cost of doing business with AI.

It isn't. Here's the exact framework I use.

The Problem with "Just Use Claude"

Most people build their AI setup like this: get an API key for Claude or GPT-4, point all their agents at it, watch the bills arrive.

That works fine until you have more than 2-3 agents doing anything meaningful. Claude Sonnet 4 costs approximately $3 per million input tokens and $15 per million output tokens. That sounds cheap until your agents are running dozens of tasks daily.

The mistake is treating every task like it requires a $15/million-token model.

It doesn't. Most tasks don't.

The 3-Tier Model Stack

Route each task to the cheapest model that can handle it correctly. That's the whole strategy.

Here's my stack:

Tier 1: Local Models (Free — $0/month)

What runs here: Classification, filtering, routing, extraction, formatting, simple Q&A, summarization, template filling

Models I use:

• llama3.2:3b — Fast, general purpose, runs on any Apple Silicon Mac
• qwen2.5-coder:7b — Code tasks, script generation
• snowflake-arctic-embed2 — Embeddings, semantic search

Setup: Ollama. One command to install, one command per model to download.

brew install ollama
ollama pull llama3.2:3b
ollama pull qwen2.5-coder:7b
ollama pull snowflake-arctic-embed2

These models run locally. No internet required. No API call made. Zero cost per query.

The test: Can a 3B parameter model handle this task with 90%+ accuracy? If yes, it goes here.

Examples of tasks that pass the test:

• "Is this email a sales inquiry or a customer complaint?" → Classification → local
• "Extract the company name, phone, and address from this text" → Extraction → local
• "Format this data as a JSON object with these fields" → Formatting → local
• "What's the sentiment of this review?" → Sentiment → local
• "Summarize this in 2 sentences" → Summarization → local

Tier 2: Fast Cloud Models ($5-15/month)

What runs here: Multi-step reasoning, moderate writing tasks, tool use, agent coordination, tasks that need 7B+ capability but don't require top-tier intelligence

Models I use:

• claude-haiku-4 — Anthropic's fastest/cheapest, still very capable
• gemini-2.0-flash — Google's fast tier, excellent value
• Ollama cloud models (kimi-k2.5, llama3.3 70B) — When local isn't enough

The test: Does this task need more than a 3B local model but doesn't need Claude's full reasoning? Goes here.

Examples:

• Draft a cold email from a lead profile → Tier 2
• Summarize a 10-page document → Tier 2
• Route and respond to a customer inquiry → Tier 2
• Write a social media post → Tier 2
• Analyze a competitor's pricing page → Tier 2

Tier 3: Premium Models (Rare — reserve for this only)

What runs here: Complex reasoning, nuanced writing, multi-step agent tasks that require understanding context across a long conversation, code that needs to be production-quality, strategic decisions

Models I use:

• claude-sonnet-4 — The smartest option, used sparingly
• claude-opus-4 — Only for the most complex tasks (I barely use this)

The test: Would a smart, experienced human need to really think about this? Is the output going somewhere that matters — a client, a published article, a production system? Then Tier 3.

Examples:

• Write a complete blog post from scratch → Tier 3
• Debug complex agent behavior → Tier 3
• Generate production-ready code → Tier 3
• Handle a complex customer escalation → Tier 3
• Strategic planning and analysis → Tier 3

The OpenClaw Configuration

Here's exactly how to set this up in OpenClaw's openclaw.json:

{
  "models": {
    "tier1_local": {
      "provider": "ollama",
      "model": "llama3.2:3b",
      "endpoint": "http://localhost:11434",
      "max_tokens": 2048,
      "use_for": ["classification", "extraction", "formatting", "simple_qa"]
    },
    "tier1_code": {
      "provider": "ollama",
      "model": "qwen2.5-coder:7b",
      "endpoint": "http://localhost:11434",
      "max_tokens": 4096,
      "use_for": ["code_generation", "script_writing", "debugging"]
    },
    "tier2_fast": {
      "provider": "anthropic",
      "model": "claude-haiku-4-20250414",
      "api_key_env": "ANTHROPIC_API_KEY",
      "max_tokens": 4096,
      "use_for": ["drafting", "summarization", "tool_use", "agent_coordination"]
    },
    "tier3_smart": {
      "provider": "anthropic",
      "model": "claude-sonnet-4-20250514",
      "api_key_env": "ANTHROPIC_API_KEY",
      "max_tokens": 8192,
      "use_for": ["complex_reasoning", "production_code", "final_drafts", "strategic_tasks"]
    },
    "fallback_chain": ["tier3_smart", "tier2_fast", "tier1_local"]
  }
}

The fallback_chain runs in reverse — try local first, escalate only if needed. You can set this as your default, then override per-agent or per-task when you know what tier is needed.

The Agent-Level Configuration

Each agent specifies its default tier. Most of my agents are set to Tier 1 by default:

# SOUL.md — Lead Intake Agent

## MODEL TIER
Default: tier1_local
Escalate to tier2_fast when: Multi-step reasoning required
Escalate to tier3_smart when: Writing a final client-facing message

## REASONING
This agent classifies and routes leads. 95% of tasks are simple classification.
Local model handles this with 95%+ accuracy at zero cost.
Only escalate when drafting the actual outreach email.

This one change — defaulting agents to Tier 1 and escalating only when needed — cut my API bill by about 80% immediately.

The Math on 25 Agents

Here's what my actual usage looked like before and after:

Before (all tasks → Claude Sonnet):

• ~500,000 tokens/day across all agents
• Average Claude Sonnet cost: ~$6 per million tokens blended
• Monthly cost: ~$90/month (and rising)

After (3-tier routing):

• Tier 1 (local): ~70% of tasks → $0
• Tier 2 (Haiku/Gemini Flash): ~25% of tasks → ~$0.10/day
• Tier 3 (Sonnet): ~5% of tasks → ~$0.08/day

Monthly cost: $2.40 for all 25 agents across 4 businesses.

The output quality didn't drop. The tasks I send to Claude now are the ones that actually need Claude. The rest runs offline, instantly, for free.

Which Tasks Surprise People

Most people assume you need a big model for things that actually work fine locally:

These are Tier 1 (local) tasks — people over-pay for all of them:

• Email classification and routing
• Extracting data from forms/documents
• Generating structured JSON from text
• Tagging and categorizing content
• Detecting sentiment or intent
• Summarizing short texts
• Filling templates with provided data
• Validating that content meets a checklist
• Image description (with a local vision model)
• Simple translation

These genuinely need Tier 2 or 3:

• Writing cold emails that don't sound robotic
• Complex multi-step research with tool use
• Debugging agent behavior in context
• Generating code that runs in production
• Synthesizing insights across multiple documents

The key question: Is this task pattern-matching or reasoning?

Pattern-matching → local model. Reasoning → cloud model.

Setting Up Cost Monitoring

I use the last30days-lite skill to track actual API costs and flag when any agent is spending more than expected:

openclaw skillpack install last30days-lite

# Set budget alerts
openclaw budget set --agent lead-intake --monthly-limit 1.00
openclaw budget set --agent content-agent --monthly-limit 5.00
openclaw budget set --agent sales-agent --monthly-limit 3.00

When an agent approaches its budget, you get a Telegram notification. When it hits the limit, the agent auto-pauses and escalates to review.

This is how you catch routing mistakes before they become expensive ones.

The Hardware Reality

You don't need a server farm for this. I run everything on a Mac Mini M4 (32GB RAM).

What I can run locally simultaneously:

• llama3.2:3b: 2GB VRAM — runs on any M1+ Mac
• qwen2.5-coder:7b: 4.7GB VRAM — M1 Pro or better
• snowflake-arctic-embed2: 669MB — runs anywhere

Total local model footprint: ~8GB. On 32GB RAM, there's plenty of headroom.

If you have an M1 Mac with 16GB RAM, you can still run the 3B model for free forever. That alone handles 70% of your agent tasks.

Getting Started

1. Install Ollama and pull llama3.2:3b (takes 10 minutes, works immediately)
2. Update your OpenClaw config to add local as Tier 1
3. Audit your agents — for each one, ask: what percentage of their tasks are classification/extraction vs reasoning?
4. Default most agents to Tier 1, set escalation rules for when they need more
5. Install last30days-lite to track the actual savings

Most people see 70-90% cost reduction within the first week. The quality doesn't drop because the tasks you're moving to local models genuinely don't need a $15/million-token model.

👉 Get the Cost Monitoring Skill (last30days-lite) →

Track exactly what you're spending, which agents are costing the most, and where you can cut further.

---

Related: OpenClaw + Paperclip Setup Guide | OpenClaw Sales Agent Guide | Complete Guide to OpenClaw Skills

Related Notes

Semantic connections via NVIDIA NV-EmbedQA | 2026-04-07

• [[2026-03-08-Spent-210-in-4-days-on-OpenClaw-What-am-I-doing-wr]] ↗️08-research — 75% match
• [[2025-09-14-Don-t-know-where-to-start-here]] ↗️08-research — 74% match
• [[2025-09-16-Sold-your-AI-Agents]] ↗️08-research — 74% match
• [[2026-02-08-How-do-you-monetise-AI-and-automation]] ↗️08-research — 73% match
• [[2026-02-22-AI-stack-for-1k-EE-enterprises]] ↗️08-research — 73% match