OpenClaw + Gemma 4: Run a Free Local Agent After Anthropic's Cutoff

Anthropic killed Claude subscriptions for third-party tools on April 4. One week later, your bill went from $0 to $1,000/month.

That's the story for most OpenClaw users right now. The flat-rate Claude Pro/Max access that made agents affordable is gone. Pay-as-you-go billing turns a personal project into an enterprise expense overnight.

But there's an escape route that costs nothing. Google dropped Gemma 4 under Apache 2.0 the same week Anthropic pulled the plug—a capable open-weight model that runs locally via Ollama. Pair it with OpenClaw, and you get a fully functional agent stack that costs you zero per month. No API keys. No credit cards. No surprise bills.

This post walks through exactly how to set it up, what to expect on performance, and why your OpenClaw config is actually the hard part that most tutorials skip.

The Anthropic Cutoff Was Intentional

Let's be clear about what happened. Anthropic didn't accidentally break third-party integrations. They made a deliberate policy choice: flat-rate subscriptions are ending. Tools like OpenClaw, LangChain, CrewAI, and Zapier that relied on Claude Pro/Max billing now had to choose between implementing API key authentication or losing access.

Most chose the former. Your OpenClaw agent now runs on your own API key, billed at $3-15 per million tokens depending on model and tier.

For a moderately active agent (5,000 tokens per run, 10 runs per day), that's $150-450/month. For always-on agents or those running complex orchestration, it's easily $1,000+.

The good news: this also created an opening for local models to compete. Google's timing with Gemma 4 wasn't accidental either.

Why Gemma 4 Is the Right Move for Local OpenClaw Agents

Gemma 4 (and the Gemma 2B / 2B-it variants) are Google's open-weight models trained on synthetic data and released under a permissive license. The bigger model runs locally on a modern GPU with 8GB+ VRAM, or even on CPU with acceptable latency (8-12 seconds per request).

The catch: Gemma is weaker than Claude or GPT-4. It's not going to solve complex multi-step reasoning or debug your code as well as Claude does.

The win: it's free, it's yours, and it's fast enough for the majority of agent workloads: content retrieval, classification, summarization, light automation, data transformation.

For comparison, here's what you're trading:

Most agent tasks fall into the "Good" tier. You're only constrained when you hit the "Expert" tier—which is maybe 10% of what your agent actually does.

Setting Up OpenClaw + Gemma 4 in 5 Minutes

You need three things: Ollama (the local inference server), Gemma 4 (the model), and OpenClaw configured to use it instead of Claude.

Step 1: Install Ollama

# macOS
brew install ollama

# Linux
curl https://ollama.ai/install.sh | sh

# Windows
# Download from https://ollama.ai/download

Start the Ollama daemon:

ollama serve

This runs on localhost:11434 by default.

Step 2: Download Gemma 4

ollama pull gemma:7b-instruct-q4_K_M

The q4_K_M quantization keeps the model size at ~4GB, trading a tiny bit of precision for massive speed. This is the sweet spot for local inference. On first run, Ollama downloads the model (a few minutes on decent internet).

Verify it works:

curl http://localhost:11434/api/generate -d '{
  "model": "gemma:7b-instruct-q4_K_M",
  "prompt": "Write a one-liner about AI agents",
  "stream": false
}'

You should get a JSON response with generated text.

Step 3: Configure OpenClaw to Use Ollama

Your OpenClaw AGENTS.md needs a model configuration that points to Ollama instead of the Anthropic API.

model_override:
  provider: "ollama"
  endpoint: "http://localhost:11434/api/generate"
  model_id: "gemma:7b-instruct-q4_K_M"
  max_tokens: 2048
  temperature: 0.7

If you're using OpenClaw's config layer, update your gateway config to point at Ollama:

{
  "agents": {
    "defaults": {
      "model": "ollama/gemma:7b-instruct-q4_K_M",
      "modelConfig": {
        "endpoint": "http://localhost:11434/api/generate"
      }
    }
  }
}

Restart your OpenClaw gateway:

openclaw gateway restart

Your agent is now running on Gemma locally. No API bills. No rate limits. No Claude quotas.

What Breaks, and How to Handle It

Switching from Claude to Gemma 4 works for most use cases, but a few patterns need adjustment.

Complex Reasoning Tasks Struggle

If your agent is doing multi-step reasoning or reverse-engineering a problem, Gemma will occasionally hallucinate or go off-track. Claude catches these errors; Gemma doesn't always.

Fix: Use human-in-the-loop gates for high-stakes decisions. Add a HITL checkpoint before your agent modifies files or sends emails. This catches Gemma's hallucinations without requiring Claude's reasoning power.

Context Window Is Smaller

Gemma's context window is 8K tokens vs Claude's 200K. If your agent maintains long memory files or retrieves large documents, you'll hit the limit faster.

Fix: Implement aggressive memory management in your AGENTS.md. Use the memory/ directory pattern to store session state and only load what's relevant for the current task. This is exactly what well-structured OpenClaw agents already do.

Tool Calls Aren't Guaranteed

Gemma sometimes ignores your tool definitions or mixes up the format. Claude is strict about tool invocation; Gemma is looser.

Fix: Use allowlists in your agent config to restrict which tools Gemma can call. This is a security win anyway—it forces your agent to be explicit about intent. See the security checklist for the exact pattern.

Why Model-Agnostic Config Matters More Than the Model Itself

Here's the real lesson: Your OpenClaw workspace files should work with any model.

If your agent's behavior depends on Claude-specific quirks or prompt engineering, switching to Gemma breaks everything. If your agent is built on clear tool definitions, sandboxing rules, and structured memory, switching models is a three-line config change.

This is exactly why we generate security-hardened bundles at OpenAgents.mom. The bundle doesn't lock you into a provider. It locks you into good architecture.

• Tool allowlists work the same whether you use Claude, Gemma, or GPT-5.
• HITL gates protect your agent regardless of model.
• AGENTS.md memory patterns work everywhere.
• SOUL.md personality prompts are portable.

You can start with Claude (for development and complex reasoning), move to Gemma locally (to cut costs), then migrate to GPT or another provider if they win on price or capability. Your workspace files travel with you unchanged.

The Three-Month Math

You've been paying for Claude at $10/month through March. April hits, and suddenly your active agent is $500/month on API spend.

Switch to Gemma 4 on a $5 VPS:

• Ollama: Free (software)
• Gemma 4: Free (open weight)
• VPS: $5/month
• Domain (optional): $1/month
• Total: $6/month

By month two, you've broken even against the Anthropic cutoff shock. By month three, you've saved $1,485 compared to the API path.

And if you hit a reasoning task that Gemma can't handle, you're not locked in—HITL gates handle it or route to an API call for just that step.

The Escape Route Everyone Missed

Anthropic's cutoff was designed to push users toward official API billing. Google's Gemma 4 release was designed to challenge that cost model.

You landed in the middle of that inflection point. You can go either direction:

1. Claude + Pay-as-you-go: Full capability, high cost, fully managed.
2. Gemma 4 + Local: Limited capability, zero cost, self-managed.

The third option—and the one OpenAgents.mom bundles give you—is flexibility. Your agent config works on either path. You're not locked into one provider's pricing or capability roadmap.

That's the real value of file-based agents: portability. Build your agent once, run it anywhere, switch providers on your schedule, not theirs.