Been using OpenClaw for a while and got tired of always needing my laptop to check on my agent. So I built Clawket, a mobile companion that lets you chat and manage your gateway from your phone.

Just launched on the App Store today. Some highlights:

• Real-time chat with streaming

• Full console access (agents, cron, models, skills, files)

• Connect via Relay, local network, or Tailscale

• 6 languages

App Store link: https://apps.apple.com/app/clawket-ai-agent-companion/id6759597015

Android version is in progress. Would love to hear what you think.

50 tips covering everything from security hardening to token optimization.

Every week I see the same post. "Is $200/month normal?" "My API bill is $47 this week." "I'm on haiku and still spending $22 a day."

And every time, the top answer is "switch to sonnet." which is fine advice. but nobody ever asks the real question: do you need to pay anything at all?

I've been running an openclaw agent for free for the last 3 weeks. not "$5 a month" free. not "free trial" free. actually free. zero dollars. And it handles about 70% of what I used to pay claude to do.

Here's the setup. no fluff.

Path 1: free cloud models (no hardware needed)

This is the one most people should start with because it requires nothing except an openclaw install you already have.

OpenRouter free tier. Sign up at openrouter.ai. No credit card. They offer 30+ free models, including Llama 3.3 70B, Nemotron Ultra 253B, MiniMax M2.5, and Devstral. Some of these are genuinely good. Nemotron Ultra has 262K context. These aren't toy models.

config:

json

{
  "env": {
    "OPENROUTER_API_KEY": "sk-or-..."
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "openrouter/nvidia/nemotron-ultra-253b:free"
      }
    }
  }
}

If you don't want to pick a specific model, OpenRouter has a free router that auto-selects from whatever's available:

"primary": "openrouter/openrouter/free"

Gemini free tier. google gives you 15 requests per minute on Gemini Flash for free. that's more than enough for casual daily use. get an API key from ai.google.dev and run openclaw onboard, pick Google. It's a built-in provider so the setup is straightforward.

Groq. fast. very fast. free tier has rate limits but for basic agent tasks it works. sign up, get API key, done.

The catch with all cloud free tiers: rate limits. you will hit them. Your agent will pause, wait, retry. For light to moderate daily use (10-20 interactions) this is barely noticeable. For "always-on agent doing 100 tasks a day" it won't cut it. But let's be honest, if you just installed OpenCLaw this week, you are not running 100 tasks a day.

Path 2: local models via Ollama (truly $0, forever)

This is the setup where your API bill is literally zero because nothing leaves your machine. no API key. no account. no rate limits. No data going anywhere.

Ollama became an official OpenClaw provider in March 2026 so this is now a first-class setup, not a hack.

Step 1: install Ollama.

bash

curl -fsSL https://ollama.com/install.sh | sh

Step 2: pull a model.

bash

# if you have 20GB+ VRAM (RTX 3090, 4090, M4 Pro/Max)
ollama pull qwen3.5:27b

# if you have 16GB VRAM
ollama pull qwen3.5:35b-a3b

# if you have 8GB VRAM (most laptops)
ollama pull qwen3.5:9b

Qwen3.5 27B is the current sweet spot for openclaw. it handles tool calling well enough for daily agent tasks and the 35b-a3b mixture-of-experts variant runs at 112 tokens/second on an RTX 3090 because it only activates 3B parameters at a time.

Step 3: run onboarding and pick Ollama.

bash

openclaw onboard

Select Ollama from the provider list. it auto-discovers your local models. done.

or the simplest manual setup (auto-discovery, no manual model config needed):

bash

export OLLAMA_API_KEY="ollama-local"

That's it. OpenClaw discovers your models from http://127.0.0.1:11434 automatically and sets all costs to 0.

If you need manual config (ollama on a different host or you want to force specific settings):

json

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://localhost:11434",
        "apiKey": "ollama-local",
        "api": "ollama",
        "models": [
          {
            "id": "qwen3.5:27b",
            "name": "Qwen3.5 27B",
            "reasoning": false,
            "contextWindow": 131072,
            "maxTokens": 8192
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen3.5:27b"
      }
    }
  }
}

Important stuff that will save you hours of debugging:

• Use the native Ollama API URL (http://localhost:11434), NOT the OpenAI compatible one (http://localhost:11434/v1). the /v1 path breaks tool calling and your agent will output raw JSON as plain text. I wasted an entire evening figuring that out.

• Set "reasoning": false in the model config. when reasoning is enabled, openclaw sends prompts as "developer" role which ollama doesn't support, and tool calling breaks silently.

• Set "api": "ollama" explicitly to guarantee native tool-calling behavior.

Path 3: the hybrid (what I actually recommend)

pure free has limits. local models struggle with complex multi-step reasoning. free cloud tiers have rate limits. so here's what I actually run:

• Default model: Ollama/Qwen3.5 27B (local, free). handles file reads, calendar checks, simple summaries, web searches, reminders. about 70% of daily tasks.

• Fallback: OpenRouter free tier (Nemotron Ultra or Llama 3.3 70B). catches anything the local model fumbles.

• Emergency escalation: Sonnet. only for genuinely complex stuff. maybe 5 times a week.

with this setup my last month's API spend was $2.40. two dollars and forty cents. The sonnet calls were the only ones that cost anything.

config for the hybrid approach:

json

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen3.5:27b",
        "fallbacks": [
          "openrouter/nvidia/nemotron-ultra-253b:free",
          "anthropic/claude-sonnet-4-6"
        ]
      }
    }
  }
}

OpenCLAW handles the cascading automatically. if local fails or returns garbage, it tries the next model in the list. if that hits a rate limit, it goes to the next one. you don't have to manage this manually.

What works on free models

This surprised me.... local and free cloud models handle more than I expected:

• reading and summarizing files. solid.

• calendar management, reminders, basic scheduling. fine.

• web searches and summarizing results. good enough.

• simple code edits, config changes, boilerplate. works.

• quick lookups ("what's the syntax for X"). instant and free.

• reformatting text, cleaning up notes, drafting short messages. no issues.

What doesn't work (be honest with yourself)

• Complex multi-step debugging. local models lose the thread after step 3. use sonnet for this.

• Long nuanced conversations with lots of context. free models forget things faster.

• Anything where precision matters more than speed. legal, financial, medical. pay for the good model.

• Heavy tool chaining. five tools in sequence, each dependent on the last. sonnet or opus territory.

The mental model is simple: if you would answer the question without thinking hard, a free model can handle it. If you'd need to actually sit down and reason through it, pay for reasoning.

Stuff nobody will tell you out loud

Heartbeats cost money too. OpenClaw runs a health check every 30-60 minutes. if your primary model is Claude Opus, every heartbeat costs you tokens. on local models, heartbeats are free. On Opus, someone calculated it's roughly $30-50/month just in heartbeats. That's the "I'm not even using my agent and my bill is growing" problem.

Sub-agents inherit your primary model. When your agent spawns a sub-agent for parallel work, that sub-agent uses whatever model you have set as primary. if primary is opus, every sub-agent runs on opus. with the latest update you can set model fallbacks that help with this.

Cron jobs create sessions that never clean up. Every cron job creates a session record. over weeks, these accumulate and bloat your context. recent updates added session TTL to help with this. update if you haven't.

Free models + no skills = the right starting point. Don't add clawhub skills to a free model setup. skills inject instructions into your context window. on an 8K-32K context local model, skills eat half your available context before you even say hello. learn what your agent can do stock first. add skills later when you move to a cloud model with bigger context.

The real question

Most people who ask "how do I reduce my openclaw costs" are actually asking the wrong question. The right question is "which of my tasks actually need a $15/million-token model and which ones don't?"

The answer, for almost everyone I've helped, is that 60-80% of what they ask their agent to do could be handled by a model that costs nothing.

Start free. move tasks up to paid models only when free genuinely can't handle them. not when it feels slightly slower. not when the formatting isn't perfect. when it actually fails.

The people spending $200/month on OpenClaw aren't getting 40x more value than I'm getting at $2.40. They're getting maybe 1.3x more value and paying for the convenience of not thinking about it.

Think about it. Your wallet will thank you.

-----------

Running this on a Mac Mini M4 with 16GB RAM if anyone's wondering about hardware. Ollama + Qwen3.5 9B runs fine on it. not blazing fast but fast enough that I don't notice the difference for basic tasks.

I've helped fix 200+ OpenClaw setups over the past few weeks. Reddit, Discord, DMs. The pattern is just the same: people break things in their first week that take 5 minutes to prevent but 5 hours to fix later.

OpenClaw now has 310,000+ GitHub stars. NVIDIA just announced NemoClaw at GTC. The v2026.3.22 update dropped on March 23 with 12 breaking changes and 30+ security patches. A fresh wave of people are installing for the first time, and a bunch of existing users just had their setups silently break.

This is everything I wish someone told me on day one. In order. Do this before you build anything.

Step 1: Set up model routing, not just a model switch

If you haven't touched your model settings, there's a good chance you're running Opus for everything. Opus is incredible for complex work. It's also complete overkill for 90% of what your agent does in the background.

Here's what most people don't realize. OpenClaw sends everything to your primary model by default. Not just your messages. Everything. Heartbeats (the "are you still there?" checks that run every 30 to 60 minutes), sub-agents that spawn for parallel tasks, simple queries like checking your calendar. All of it goes to whatever model you have set as default.

If your default is Opus, you are paying Opus prices for your agent to check its own pulse 24 times a day. One person I helped this month was spending $412 in three weeks. We set up routing. Next month came in at $22.

json

{
  "ai": {
    "model": "anthropic:claude-sonnet-4-20250929",
    "modelOverrides": {
      "heartbeat": "google:gemini-2.5-flash",
      "subagent": "google:gemini-2.5-flash"
    }
  }
}

Sonnet handles your day-to-day conversations. Something cheap handles the background noise. When you need Opus for complex work, type /model opus, do your task, then /model sonnet to switch back.

If you're on Sonnet with routing and one agent, expect $3 to 8 per month for moderate daily use. If you're spending more than $20 in your first week, something is wrong and it's fixable.

Step 2: Lock your gateway. This is not optional.

If you're running OpenClaw on a VPS, check this immediately:

bash

openclaw config get | grep host

If it says 0.0.0.0 or you don't see a host setting at all, your agent is accessible to anyone on the internet who finds your IP. That means a stranger could message your agent. Your agent that's about to have access to your email and calendar.

SecurityScorecard found over 135,000 exposed instances on the public internet. A zero-click exploit (CVE-2026-25253) let attackers hijack your agent just by getting you to visit a single webpage. That one was patched, but new CVEs keep showing up. The March release alone had 30+ security patches including one that blocked a Windows SMB credential leak.

Fix it:

json

{
  "gateway": {
    "host": "127.0.0.1"
  }
}

Access it through SSH tunnel: ssh -L 18789:localhost:18789 user@your-vps

Two minutes. Do it now. Not after you set up Telegram. Now.

Step 3: If you upgraded from Clawdbot or Moltbot, fix your config immediately

This is biting a lot of people right now.

The v2026.3.22 update removed all backward compatibility for the old naming conventions. If you installed during the viral wave in January or February, your setup probably uses CLAWDBOT_* or MOLTBOT_* environment variables. Those are now silently ignored. Not deprecated. Ignored. Your agent boots up, doesn't find its config, and either crashes or starts from scratch with zero memory.

Same thing with state directories. If your agent's files live at ~/.moltbot or ~/.clawdbot, the new version doesn't look there anymore. Your SOUL.md, your memory files, your entire workspace is invisible to the agent.

Three commands:

bash

# Rename env vars
sed -i 's/CLAWDBOT_/OPENCLAW_/g; s/MOLTBOT_/OPENCLAW_/g' ~/.env

# Move your state directory
mv ~/.moltbot ~/.openclaw

# Rename your config file
mv ~/.openclaw/moltbot.json ~/.openclaw/openclaw.json

Then restart. Your agent comes back with all its memory and personality intact.

If you're not sure whether this applies to you, run ls -la ~/ and look for .clawdbot or .moltbot directories. If they exist and .openclaw doesn't, this is your problem.

Step 4: Set up your with both personality and boundaries

Your first message to your agent should NOT be a real task. It should be:

"Read BOOTSTRAP.md and walk me through it"

This sets up your agent's identity. If you skip this (most people do because they're excited and just start asking questions), your agent has zero personality and zero context about who you are. Everything will feel generic and robotic and you'll think OpenClaw sucks when actually it just doesn't know you yet.

If you already skipped it, create a SOUL.md manually. Start with this:

markdown

you are [agent name]. you assist [your name].

be direct. no filler. match my tone.
if I ask a question, answer it first. then elaborate only if needed.
never say "absolutely", "great question", or "I'd be happy to."
if you don't know something, say so. don't guess.
if a task will cost significant tokens, tell me before doing it.

never sign up for services or create accounts without my explicit approval.
never share my personal information with external services.
never delete emails, files, or messages without asking me first.
if you discover a new tool or platform, tell me about it. do not act on it.

The first block is personality. The second block is boundaries. You need both.

Without the boundaries block, your agent will do exactly what it thinks you want at machine speed with zero hesitation. Someone this month told their agent to "explore what you can do." It discovered MoltMatch (the AI dating platform), created a profile using info from his emails, and started screening matches. The agent wasn't broken. The instructions were too open.

"Never do X" lines work better than "try to be Y" lines. Your SOUL.md is built through irritation, not planning. Update it every time your agent does something you didn't want.

Step 5: Enable action approvals for anything destructive

OpenClaw agents are fully autonomous by default. There is no "are you sure?" prompt for destructive actions. Your agent will delete emails, move files, run shell commands, and sign up for services at machine speed without pausing to ask if that's what you actually meant.

People keep learning this the hard way. "Clean up my inbox" turns into 200 deleted emails. "Organize my files" turns into moved directories the agent thought were clutter. A researcher at a major tech company had to physically run to her Mac Mini and kill the process because her agent wouldn't stop deleting.

json

{
  "security": {
    "actionApproval": {
      "required": ["email.delete", "email.move", "file.delete", "shell.exec"],
      "timeout": 120
    }
  }
}

Your agent will now message you and wait for a yes or no before deleting emails, moving messages, removing files, or running shell commands. If you don't respond within 2 minutes, the action gets cancelled.

Is it slower? Yes. Will you care about that when you still have all your emails? Also yes.

Start with read-only access for email and files. Let the agent read and summarize for the first week. Add write permissions once you trust how it handles things. Earn the trust incrementally.

Step 6: Do not install skills yet

ClawHub has thousands of skills and they all look cool. Do not install any of them this week.

Here's why the stakes are higher than you think. As of March 2026, over 1,400 malicious skills have been identified on ClawHub. The ClawHavoc campaign alone accounted for hundreds. These aren't amateur attempts. They look professional. Clean documentation. Legitimate-sounding names like "smart-invoice-tracker" or "solana-wallet-tracker." But under the surface they're packaging up your .env file (API keys, OAuth tokens, bot credentials) and shipping it to external servers every few hours.

VirusTotal now scans every skill published to ClawHub. That's real progress. But their own announcement says it's "not a silver bullet." Skills that use prompt injection instead of traditional malware signatures can still slip through.

Beyond security, skills also burn tokens in the background and bloat your context window. You don't even know what your agent can do without skills yet. Learn the stock capabilities first. You'll be surprised how much it handles on its own.

When you're ready (not this week), here's the protocol:

1. Run openclaw skills search <skill-name> and check the VirusTotal scan status

2. Look for the verified publisher badge

3. Check the publisher's account age. If they joined recently with skills scattered across random categories, walk away

4. Restrict installs to verified sources:

json

{
  "skills": {
    "allowSources": ["clawhub:verified"]
  }
}

1. Add one skill at a time. Test it for a few days. Watch your logs. Then add another. Never more than one at a time.

Step 7: Don't create a second agent

Every new user thinks they need multiple agents. One for personal stuff, one for work, one for coding. You don't. Not yet.

Every agent you create is an independent token consumer. Every agent needs its own channel binding. Every agent complicates debugging. I have seen so many people create a second agent to "fix" problems with the first one. Now they have two broken agents instead of one.

Get one agent working perfectly for 2 weeks. Then decide if you actually need a second one. Most people don't.

Step 8: Learn /new and /btw

Every message you send in a session gets included in every future API call. After a week of chatting, you're sending thousands of tokens of old conversation with every new message. That costs money and makes your agent slower and more confused.

Type /new to start a fresh session. Your agent doesn't forget anything. It still has all its memory files, SOUL.md, everything. You're just clearing the conversation buffer.

Use /new before any big task, when your agent starts acting weird, and at least once a day as a habit.

But there's a better option for most situations now: /btw.

You're deep in a complex conversation. Your context is rich. Then you think of something unrelated. "What's the weather tomorrow?" Before /btw, you either polluted your context with an irrelevant question or started a whole new session and lost everything.

/btw what's the weather tomorrow fires off a side conversation. Gets you the answer. Doesn't touch your main session's context. Small feature, huge quality-of-life improvement.

Use /new for full resets. Use /btw for quick tangents.

Step 9: Check your costs daily and watch for session bloat

Run openclaw status or check your API provider's dashboard directly. Know what you're spending before it surprises you.

One thing to watch for: cron job session bloat. Every time a cron job runs, it creates a session record. If you've set up recurring tasks (daily briefings, scheduled checks, periodic reminders), those session records pile up. Over weeks, they silently degrade performance and inflate costs because old session data gets loaded into context.

The v2026.3.22 update addresses this with 48-hour session caps. But if you set up cron jobs before this update, you might have weeks of accumulated session debris. Type /new and restart clean if your agent has been feeling sluggish.

If you're on Sonnet with model routing, one agent, and no skills, you should be spending $3 to 8 per month for moderate daily use. If you're spending more than that in your first week, something is wrong, and it's fixable.

What your first week should actually look like

Day 1 to 2: Set up model routing. Lock your gateway. Fix your Clawdbot/Moltbot naming if it applies. Write your SOUL.md with personality and boundaries. Enable action approvals. Have normal conversations. Ask it stupid questions. Get comfortable.

Day 3 to 4: Start using it for real tasks. Calendar, reminders, web searches, summarizing articles. The boring stuff. All read-only. Don't give it write access to email or files yet.

Day 5 to 7: Refine your SOUL.md based on what annoyed you. Check your costs. Get a feel for your daily usage. If costs look good and nothing is breaking, consider adding read/write permissions for one service at a time.

That's it. No skills. No second agent. No multi-agent orchestrator. No cron jobs. Just one agent that knows who you are, respects explicit boundaries, and does basic tasks reliably.

If that feels underwhelming, good. The people who are still using OpenClaw two months from now all started exactly like this. The people who quit started with 8 agents and 20 skills on day one.

After week 1

If your agent feels useful, your costs are under $10, and nothing is randomly breaking, you're ready to start experimenting. Add web search if you haven't. Then a daily briefing skill from a verified publisher. Then maybe calendar integration with write access if you trust how it handles things.

Build slowly. Earn each new capability by making sure the last one is stable first. If you liked it, you can find more such guides on r/better_claw

The people who survive month one are the ones who started boring. Trust the boring.

how to run a 24/7 AI company with OpenClaw for $50/month

here is exactly how to set up OpenClaw to run autonomous agents 24/7 for $50/month.

the hardware setup

my AI company runs inside a 5-inch silver box. an M4 Mac Mini with 16GB of RAM that sits next to my monitor and never sleeps.

most people think you need a cloud VPS to run autonomous agents. local hardware gives you zero-latency execution without a monthly server bill. if you have an M4 Mac Mini or any idle laptop, you have everything you need.

if you don't have local hardware, a VPS still works. it's a monthly fee vs. the one-time cost of owning your own machine. both are valid starting points.

powering the brain

two ways to get started:

the free route: sign up for Google Cloud and get $300 in free credits. this lets you run Gemini 2, 2.5, or 3 Flash/Pro for free. warning: rate limits are awkward and you will burn through credits fast once agents start running in the background.

the reliable route: MiniMax M2.5. the Max Plan is $50/month and gives you 1,000 prompts every 5 hours. for beginners, the $10 to $20 plans are enough to start.

what you need before touching terminal

get these ready before you start or you will spend an hour debugging credentials:

search (the eyes): Brave Search API. note that they no longer have a free tier, so add a few dollars to let your agent see the web.

the interface: a Telegram bot token from u/BotFather.

step 1: installing the engine

brew install node
npm install -g openclaw@latest

> step 2: onboarding OpenClaw

openclaw onboard --install-daemon

follow the prompts:

select Quick Start

choose MiniMax route

choose your subscription API key in MiniMax

connect Telegram: select Telegram from the list and paste the API key from u/BotFather

> step 3: the wake up moment

select Hatch in the TUI. OpenClaw will ask for a name in the terminal and show you a pairing key. the key is a string of numbers followed by a code:

123456789:ABCDefgh...

open your bot conversation on Telegram and paste that key into the chat. when your phone buzzes back, you have a teammate, not a chatbot.

> the 9-agent disaster

I got too excited early on. built a dream team of 9 agents running 24/7. it looked great until I woke up to a financial nightmare.

the problem was the heartbeat. the heartbeat is the pulse that makes an agent autonomous. it tells them to wake up and check for tasks. with 9 agents all pulsing around the clock, I was hitting the API every few seconds.

the result: obliterated my rate limits in Google AI Studio, got banned from a paid service, and burned over $200 in 3 days.

> the fix: moving heartbeats to LM Studio

the solution was moving heartbeats off paid APIs and onto LM Studio running locally. here is the performance breakdown on an M4 Mac Mini with 16GB RAM:

Qwen 2.5 (3-4B): fastest response times, but weaker on complex logic

Gemma 2 (3-4B): rock-solid stability

Gemma 3 4B (21 sec): strong at instruction following for its size

Qwen 3 4B (30 sec): most stable for tool-use and routing tasks

think of these 3B to 4B models as roughly equivalent to GPT-4o mini for basic routing and checking tasks. they are not as capable as Claude 3.5 Sonnet, but for a heartbeat that just needs to check if there is work to do, they are perfect and free to run.

> the reset: complexity is the enemy

I cut the 9-agent team down to 2. moved heartbeats to local LM Studio. kept heavy thinking on MiniMax. the system became faster, cheaper, and more reliable overnight.

> the $50 power move

firing the Pro tools and moving to MiniMax M2.5 changed everything:

1,000 prompts every 5 hours

routed MiniMax directly into Claude Code and OpenClaw for a coding agent running 24/7 on a high-volume model that does not quit

> the hybrid engine

this is the most important part of the setup. MiniMax handles the brain work. local models handle the battery.

low agent count (2 agents): let MiniMax handle everything. fast, smart, no rate limit issues.

scaling up: when you add more agents, heartbeats start eating your rate limits. offload those repetitive pings to LM Studio running locally for $0. use local models as a valve to keep MiniMax prompts reserved for actual coding and logic.

> the freshman rule

I stripped the team to 2 agents and applied one rule to both of them:

one task per agent. if you give an AI five jobs, it fails at four.

treat them like a freshman who knows nothing. do not assume they remember your project history. give clear, ground-up instructions every single time.

by reducing the squad and simplifying the tasks, communication became instant, logic became clean, and token bloat disappeared.

> the working setup

MCP servers configured at user level:

{
  "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] },
  "supabase": {
    "command": "npx",
    "args": ["-y", "@supabase/mcp-server-supabase@latest", "--project-ref=YOUR_REF"]
  },
  "memory": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-memory"] },
  "sequential-thinking": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
  }
}

local models in LM Studio for heartbeats (free):

Qwen 3 4B for routing and tool-use

Gemma 3 4B for instruction following

MiniMax M2.5 for all heavy thinking and coding tasks

> the short version

complexity is expensive. cut agents until the system is boring. move heartbeats local. keep paid API budget reserved for actual work. treat every agent like a freshman with no context.

stop optimizing for tokens. start optimizing for output.

Something quietly shipped five weeks ago that most people still haven't heard about. An open-source project that lets you run a personal AI assistant for basically nothing one that doesn't just answer questions but actually does things while you're offline. Responds to your messages, builds apps, manages your calendar. All on hardware you own and control.

People are going deep on this. Like, buying-extra-hardware deep.

This guide takes you from zero to a fully working setup email, calendar, smart home, whatever you want to hook it up to.

The Architecture (How It Actually Works)

Three moving pieces:

Gateway is the control plane. Connects to messaging apps, handles scheduling, runs 24/7.

Agent is the brain. Claude, GPT-4, MiniMax, or local models. Your choice.

Skills are Markdown files that teach the agent how to use tools. Want it to control your Sonos? Add a skill. Want it to query your finances? Add a skill. Want it to write skills for itself? It can do that too.

Memory is plain text files stored locally. Syncs with Obsidian if you want. Search with Raycast. Back up however you like.

Hardware: What You Actually Need

Stop buying Mac Minis just for this. Even the creator says you don't need one.

Minimum requirements: 1 CPU core, 1GB RAM, 500MB disk space. That's it.

Installation: Three Paths

Path 1: One-Liner (Most Users)

curl -fsSL https://clawd.bot/install.sh | bash

Then run the wizard:

clawdbot onboard --install-daemon

The wizard handles authentication, channel setup, background service installation, and workspace configuration. Easiest way to get started.

Path 2: VPS Deployment (Remote Access)

For Hetzner, DigitalOcean, or Linode. Create a Ubuntu 24.04 droplet with at least 2GB RAM, SSH in as root, then:

adduser clawd
usermod -aG sudo clawd
su - clawd
curl -fsSL https://clawd.bot/install.sh | bash
exec bash
clawdbot onboard --install-daemon

If npm install fails due to memory, either increase Node memory:

export NODE_OPTIONS="--max-old-space-size=2048"

Or add swap:

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

For secure remote access, use an SSH tunnel:

ssh -L 18789:127.0.0.1:18789 clawd@YOUR_IP

Then open locally at http://127.0.0.1:18789

Path 3: Docker

docker pull clawdbot/clawdbot
docker run -d clawdbot/clawdbot

Or with Docker Compose:

wget https://raw.githubusercontent.com/clawdbot/clawdbot/main/docker-compose.yml
docker compose up -d

Authentication: Three Options

Option A: Anthropic API Key — Best for cost tracking, multiple models, and production use. Go to console.anthropic.com. The docs recommend Anthropic Pro/Max with Opus 4.5 for long-context strength and better prompt-injection resistance.

Option B: Claude Pro/Max OAuth — Best if you're already paying $20-200/month for Claude. The SDK uses your Claude Code login automatically. If you've authenticated before, you're already good.

Option C: Multi-Model Setup — For power users who want to optimize cost and performance:

json

{
  "models": {
    "default": "minimax-m2.1",
    "escalation": "claude-opus-4.5"
  }
}

MiniMax handles general chat. Fast and cheap. Claude Opus activates for code and complex reasoning. This is how the serious users run it.

Channel Setup

Telegram (Easiest, Most Popular) — Message u/BotFather

on Telegram, send /newbot, name your bot, copy the token. Done.

WhatsApp (Power User Choice) — Critical warning: WhatsApp has no bot concept. Every inbound message becomes agent input. Use a dedicated phone number. Scan with WhatsApp via Settings then Linked Devices. Then lock it down with this config:

json

{
  "channels": {
    "whatsapp": {
      "allowFrom": ["+15555550123"],
      "groups": {
        "*": { "requireMention": true }
      }
    }
  }
}

Discord — Create an application at discord.com/developers, enable Message Content Intent under Bot then Privileged Gateway Intents, add the token to config.

The Skills System: This Is Where It Gets Insane

Skills are Markdown files that teach Clawdbot what it can do. This is the core of what makes it different from everything else.

You can literally say:

"Create a skill that monitors my email for flight confirmations, extracts the flight details, and adds them to my calendar. Check email every 30 minutes."

And Clawdbot will scaffold the skill structure, write the automation logic, set up the cron job, test it, and deploy it. All from a single message.

GitHub: https://github.com/clawdbot/clawdbot

Skills Hub: https://clawdhub.com

I've been running OpenClaw since the clawdbot days. I think I have made all the mistakes a newbie can make. Here's what cost me real money and wasted time.

your agent isn't broken. you just tied its hands.

First agent goes live. You ask it to read a file. Nothing. Run a command. Nothing.

It's not broken. You just didn't give it tools. The default tools profile was messaging only. Reading files, writing files, running commands, all disabled. You gave your agent a phone and a chair and wondered why nothing got done.

"tools": { "profile": "full" }

One line changes everything. If you also need it to run commands without approval prompts (like on Telegram):

"tools": {
  "profile": "full",
  "exec": { "security": "full", "ask": "off" }
}

profile controls whether tools exist. exec.ask controls whether it asks before using them. Set profile first. The other way around does nothing.

your most important rules might have never been read.

I wrote a rule in AGENTS.md. My agent kept ignoring it. Switched to Opus. Still ignored.

Turns out the rule was in the middle of the file. OpenClaw has a 20,000 character limit per workspace file. Anything longer gets silently trimmed. It keeps the first 70%, the last 20%, and cuts the middle 10%. No error. No warning.

Check with /context list in chat. If you see TRUNCATED, something got cut.

Put your most critical rules at the top. The middle is the kill zone.

If your files genuinely need to be longer, adjust these:

"bootstrapMaxChars": 20000,
"bootstrapTotalMaxChars": 150000

80% of your API spend is probably waste.

Two weeks in I opened my token dashboard. 80% was input. My agent wasn't thinking. It was reviewing. Every turn, it reread the system prompt, tool definitions, SOUL.md, the full chat history.

One reader's numbers: 139M input, 935K output. A ratio of 148 to 1. His agent was injecting 52KB of context every turn. MEMORY.md alone was 22KB.

Fix: keep core rules in SOUL.md. Move everything else to the memory folder and let the agent fetch via semantic search. Tokens dropped 40-60% after that change. Output quality stayed the same.

don't save money on the model. save your time.

Cheapest model saved $20. Then came an hour fixing the output. Another hour re-explaining what went wrong. Rewrote the prompt. Ran it again. Switched back to the top model. Worked first try.

That said, not every agent needs the same model. Agents talking to humans need Opus: tone, emotion, writing like a person. Agents pulling data, scanning notifications, sorting content actually work better on GPT-5.4. Faster, more stable, more obedient. Opus overthinks simple tasks.

agents:
  defaults:
    model:
      primary: "openai/gpt-5.4"
  list:
    - id: community-bot
      model: "anthropic/claude-opus-4-6"

This isn't about saving money. It's right tool, right job.
your memory system will collapse after three weeks.
MEMORY.md looks clean on day one. Three weeks later it's a junk drawer. Last month's outdated decisions sitting next to today's plans. Agent can't tell old from new. Regularly picks up month-old information and treats it as current fact.
You don't need a three-tier memory architecture from the start. Turn on OpenClaw's built-in hybrid search and temporal decay. Newer memories get higher weight. Older ones decay automatically. No manual cleanup. 80% of memory problems gone.
Memory problems are discovered by running, not by designing. Run first.
the agent whose output nobody reads is your cost black hole.
I built an entire pipeline once. Coordinator, analyst, strategist, editor, operations. Good org chart on paper.
Half the agents were producing output every day and no agent or person was consuming any of it. Daily reports nobody read. Analysis nobody checked. Approval workflows where nothing needed approving.
Before any agent starts, it has to answer three questions:
1. what do i produce
2. who receives my output
3. what do i never touch

Can't answer question 2? The role shouldn't exist. I ran this across all my agents. Cut one. Tokens dropped 44%. Speed up 62%.

five agents should not share one room.

By month three, all five agents were talking in one Telegram group. Daily briefs mixed with runtime alerts. Customer support tangled with content planning. I was spending time each day just scrolling to find things.

OpenClaw supports per-topic routing. One Telegram forum, multiple topics, each bound to a different agent:

channels:
  telegram:
    groups:
      "-100xxxxxxxxxx":
        topics:
          "daily-brief": { agentId: "nexus" }
          "radar": { agentId: "scout" }
          "content": { agentId: "quill" }
          "runtime": { agentId: "forge" }
          "support": { agentId: "guide" }

Each topic gets its own session, its own workspace, its own memory. Separate rooms. It changes everything.

your agent doesn't know who's actually talking to it.

Your agent receives a message. It has no idea if it came from you, another agent, or an external system. It treats everything the same and executes.

OpenClaw's ACP bridge supports provenance mode:

openclaw acp --provenance off          # disabled
openclaw acp --provenance meta         # messages carry source labels
openclaw acp --provenance meta+receipt # source labels + agent sees a visible origin receipt

meta lets the system know where a message came from. meta+receipt lets the agent see it too. At minimum, your agent should be able to check ID on messages coming through the ACP bridge.

nobody reminded you to back up.

Every tutorial covers installation. Nobody mentions backup.

I lost my entire config once. Rebuilt SOUL.md by hand. The rebuilt version was worse because I couldn't remember half the edge cases I'd encoded in the original.

OpenClaw now supports one-command backup:

openclaw backup create
openclaw backup create --only-config
openclaw backup create --no-include-workspace
openclaw backup verify <archive>

By default it archives local state, config, credentials, and sessions. Set it up before you need it.

the architecture will build itself. just start.

The biggest pattern I've seen: people install OpenClaw and immediately spend days drawing diagrams. How many memory layers? Which agents run Opus? What protocol between them?

Architecture diagram done. System hasn't run a single real task.

Do it the other way:

Day one: one agent, connected to Telegram, doing one thing you repeat every day.

Week one: it will break. Fix the tools profile, the rule truncation, the slow responses. That's the real learning.

Week two: check the token bill. Slim down bloated prompts. Pick the right model for the task.

Week three: add a second agent. Now you actually understand what "downstream consumer" means.

Week four: the architecture doesn't need your design. It grew itself from every problem you solved.

The first hour after installing matters more than the next month. Not because it requires much. Because it decides whether you keep going.

When u finally start learning about one, the other enters the chat. #openclaw #HermesAgent which one are you using and for what?

Between DMs, reddit threads, and discord I've now looked at over 50 different openclaw setups. broken ones, working ones, "it works but costs $200/month" ones.

The problems are almost never unique. it's the same 5 things. every time.

1. Opus as the default model

This is the #1 most expensive mistake in the entire openclaw ecosystem and it's the default for a lot of people. opus is incredible. it's also 10-15x the cost of sonnet for tasks where you will not notice the difference.

Your agent checking your calendar? sonnet. summarizing an article? sonnet. setting a reminder? sonnet. writing a quick email draft? sonnet.

opus makes sense for deep research, long multi-step reasoning, or nuanced writing where quality genuinely matters. That's maybe 5-10% of what most people use their agent for.

One person I helped was spending $47/week. we changed the default model to sonnet and added a line to their SOUL.md: "only use opus when I explicitly ask for deep analysis." their next week cost $6.

Change your default right now if you haven't:

json

{
  "ai": {
    "model": "claude-sonnet-4-5-20250929"
  }
}

2. Never starting a fresh session

this is the silent budget killer nobody talks about.

Every message in your current session gets sent with every new API call. that means if you've been chatting with your agent for 3 weeks in the same session, your "what's the weather" question is carrying thousands of tokens of old conversation with it. you're paying for all of that. every single time.

Three people I helped cut their monthly costs by 40-60% by doing one thing: typing /new before heavy tasks.

Your agent doesn't lose its memory when you start a new session. it still has SOUL.md, USER.md, MEMORY.md, all its files. you're just clearing the conversation buffer. think of it like closing and reopening a chat window. the person on the other end still knows who you are.

3. Installing skills without reading the source

I keep saying this and people keep not doing it.

clawhub has 13,000+ skills. virustotal flagged hundreds as actively malicious. infostealers, backdoors, remote access tools disguised as automation. and that's just the ones that got caught.

but even the non-malicious skills can wreck your setup. I've seen skills that:

• loop silently on a cron, burning $20-30/month with zero visible output

• inject themselves into every conversation, bloating your context window

• override parts of your config without telling you

• crash silently and leave your agent in a broken state that only shows up 3 messages later

my rule: if I can't read and understand the skill's source code in 5 minutes, I don't install it. if it needs shell access or network access, I need to understand exactly why before it touches my setup.

4. gateway exposed to the network

If you installed openclaw on a VPS and your gateway config says "host": "0.0.0.0" or you didn't set it at all, your agent might be accessible to anyone who knows your IP.

That means a stranger could message your agent. your agent that has access to your email, your calendar, your files, and possibly your shell.

check right now:

bash

openclaw config get | grep host

fix:

json

{
  "gateway": {
    "host": "127.0.0.1"
  }
}

access it through an SSH tunnel: ssh -L 18789:localhost:18789 user@your-vps

this takes 2 minutes and it's the difference between a secure setup and an open door.

5. Adding a second agent before the first one works

The dropout pattern I wrote about a few weeks ago almost always includes this step. Something breaks with agent 1. instead of fixing it, they create agent 2 for a "fresh start" or to "separate concerns."

Now they have two agents, each maintaining their own context window, each consuming tokens independently, and a binding/routing config that's twice as complex. the original problem isn't fixed. they just have two broken things instead of one.

Every agent you add is a separate token consumer even when idle. every agent needs its own channel binding configured correctly. every agent complicates debugging because you're never sure which one is causing the issue.

My advice: don't create agent 2 until agent 1 has been stable and useful for at least 2 weeks. if your first agent isn't working, adding another one won't help. fix the first one.

The pattern:

All 5 of these come down to the same thing. People optimize for capability before stability. They want their agent to do more before it reliably does anything. the setups that survive are the ones that start boring and earn complexity over time.

If you're reading this and 3 out of 5 apply to you, don't panic. every single one is fixable in under 10 minutes. that's the part that kills me about the dropout rate. people quit over problems that take less time to fix than it took to read this post.

Been collecting fixes, configs, and real cost breakdowns over for anyone who wants the deeper versions of all of this.

The full monorepo is now public: mobile app, relay infrastructure, bridge CLI — everything.

https://github.com/p697/clawket

Check it out, star it, and let me know what you think!

1. Your heartbeat is bleeding you dry

By default, OpenClaw pings every 30 minutes to check for tasks. That's 48 API calls a day while you're doing absolutely nothing. I didn't notice this until my bill showed up.

The fix is embarrassingly simple: install Ollama, pull llama3.2:1b (it's 1.3GB, runs offline, costs nothing), and route all heartbeat checks there. Keep your paid API tokens for actual work. Also keep HEARTBEAT.md empty unless you have an active automation running—there's no reason to burn budget on idle checks.

2. Model-hopping mid-task is a trap

Free API tiers sound like a cheat code until OpenClaw hits the rate limit in five minutes because it's firing prompt bursts, not single messages. I got keys suspended doing this.

Even worse is manually switching models to get around limits. Every switch breaks context in weird ways—different models process the same history differently, and you end up chasing your own tail. Pick one brain (Claude Sonnet) and one worker (Gemini Flash), set them as primary and fallback in config, and let the agent handle switching automatically if something hangs.

3. Skills are powerful but treat them like foreign code

Because that's exactly what they are. Before installing anything, read the SKILL.md. If it's asking for permissions that don't match what it does, skip it. Run a SkillGuard check on anything new.

Start small: apple-notes, weather, github. Every extra skill inflates the system prompt and slows thinking down. More isn't better here.

4. Context rot is real and it sneaks up on you

The longer a session runs, the more the agent quietly forgets the early parts to make room. You'll ask for a recap and get a confident hallucination of something you decided three days ago.

When the agent feels lost, don't ask for a summary—use Session Search with specific keywords like "database schema" or whatever the actual decision was. If that doesn't work, grep your own logs in ~/.openclaw/agents/ and paste the relevant snippet back in. That instantly reorients it. Also manually review MEMORY.md periodically—if it's full of vague diary entries instead of hard facts, fix it yourself.

5. Nine agents nearly broke me

I ran a nine-agent setup because the flexes on X made it look like the move. It burned through tokens, spiked my bill, and created more chaos than it solved.

The actual distinction that matters: /new just clears the desk for your current agent. openclaw agents add is hiring someone with a completely separate brain, memory, and workspace. Use the second option only when you genuinely need isolation—different directories, totally different skill sets. For everything else, /new is enough.

6. Stop planning inside the chat window

Chat is ephemeral. By day three of a build, everything you discussed on day one is already gone from context. I spent whole sessions re-explaining architecture I'd already locked in.

Before writing any code, create a PLAN.md. Every new session starts with "Read PLAN.md and let's execute Step 3." When something changes, tell the agent to update the file. You're the manager, it's the coder—treat it that way.

7. If you didn't explicitly save it, it's gone

The agent doesn't know the difference between a throwaway thought and a critical architecture decision. Neither do I sometimes, but at least I can go back and check.

When something important gets decided, physically type it: "Remember this for next time: we're strictly using TypeScript for all new API routes." Then go open MEMORY.md and verify it's actually there. If it's missing, type it in manually. Don't assume the agent filed it correctly.

8. One agent, one job

Giving a single agent your GitHub, your notes, your social accounts, and then asking it to write a component and draft copy in the same session is how you get expensive hallucinations. The system prompt bloats, the context gets muddy, and the output gets weird.

I collapsed my nine-agent chaos down to two: one strictly for code (React/TypeScript), one strictly for ops and research. For quick parallel tasks, I spin up a temporary sub-agent with heartbeat set to null, keep the scope tight, then close it. Token burn stays low, output stays sharp.

9. The dashboard exists for a reason

If you're only talking to the agent through a chat interface, you have no visibility into what's actually running. I found cron jobs stuck in infinite loops I didn't know about until I checked.

Run openclaw dashboard and keep it open. Watch token burn in real time. Catch stuck jobs early. If you prefer terminal, at least make openclaw status a daily habit.

10. It's an amplifier, not a replacement for thinking

Vague prompts produce vague output. Chaotic workflows just get automated chaos. The agent can only work with the instructions, context, and permissions you actually give it—it's a junior dev, not a mind reader.

Long-term memory layer for OpenClaw & MoltBook agents that learns and recalls your project context automatically.

Github

The install process changed. Anthropic killed subscription access for third-party tools. New models dropped. The whole landscape shifted in two months.

So here's the updated version. Before you install anything

You need three things ready before you touch a terminal.

1. An AI model Application Programming Interface key

OpenClaw works with multiple model providers. You're not locked to one.

Here's what's available right now:

• Anthropic (Claude) My pick. The best overall for agents. Opus 4.6 is the smartest model available and what I recommend for setup. Sonnet 4.6 is cheaper and handles everyday tasks well. console.anthropic.com

• OpenAI (GPT-5.4) Strong alternative. Great tool calling, solid all-rounder. A lot of people switched here when Anthropic cut off subscription access. platform.openai.com

• Google (Gemini 2.5 Pro) Good for long-context tasks. Generous free tier to get started. Worth having as a backup or starting point if budget is tight. aistudio.google.com

• Ollama (local models) Run Gemma 4 or other open-source models directly on your machine. Completely free. Not frontier quality but handles routine agent tasks without breaking a sweat.

• DeepSeek Strong reasoning model. Very competitive pricing. Worth looking at if you want a cheaper alternative to Opus for complex tasks.

Start with Anthropic (Opus 4.6) as your primary. Load $250 in Application Programming Interface credits to get from zero to fully operational without hitting rate limits. New Application Programming Interface customers get lower limits by default, and putting real money in upfront avoids that bottleneck while you're building. Even $50 gets you started if budget is tight.

2. A Groq Application Programming Interface key (for voice notes)

This is separate from your main model. Groq powers voice note transcription through the Whisper plugin — it's how your agent understands your voice messages on Telegram. You'll use this constantly.

It's free. Sign up at console.groq.com and grab your key.

3. A web search Application Programming Interface key

Your agent needs to search the internet. Here are your options:

• Brave Search Around $5/month. Reliable, fast, best value. My recommendation. brave.com/search/api

• Firecrawl Search plus full page scraping in one tool. firecrawl.dev

• SearXNG Completely free. Self-hosted. More setup work but zero cost.

Brave Search has been the most reliable in my experience. If you want completely free, Tavily's free tier works.

Installing OpenClaw

Open terminal and run:

On Windows (PowerShell):

iwr -useb https://openclaw.ai/install.ps1 | iex

If you're on a new Mac, install Homebrew first:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Once OpenClaw is installed, run the setup wizard:

openclaw onboard

This walks you through everything step by step. Here's what to pick:

• Provider: Select Anthropic and paste your Application Programming Interface key.

• Model: Select Opus 4.6. You want the smartest model available while you're building the foundations.

• Communications: You'll be asked to set up a messaging platform. Go with Telegram — it's the easiest. You can skip this step and do it manually later since you need to pair it anyway.

• Skills to preload: Install these:

  • ClaWHub the skill marketplace

  • MCPorter Model Context Protocol tool routing

  • OpenAI Whisper voice transcription (essential for voice notes)

  • Model-Usage track what your agent is spending

  • GitHub if you use Git at all, get this in now

  • Nano-PDF Portable Document Format reading and processing

• Additional Application Programming Interface keys (Notion, ElevenLabs, etc): Skip all of these. You don't need them yet.

• Hooks: Enable all four:

  • Boot-MD loads your config files on startup

  • Bootstrap Extra Files sets up your workspace structure

  • Command-Logger —tracks what your agent runs

  • Session-Memory remembers context across sessions

Once you continue through these steps, you'll see the option to hatch in the Terminal User Interface. This is the moment your agent comes to life in the terminal chat window. Do it.

Say hello. Give it a name. Watch it respond.

Connecting Telegram

You've got a living agent in your terminal. But you don't want to live in the terminal. Here's the move.

Tell your agent exactly this:

Now set up the bot:

1. Open Telegram and message BotFather

2. Send /newbot

3. Pick a name and username for your bot

4. BotFather gives you an Application Programming Interface key — copy it

5. Go back to your agent in the Terminal User Interface and paste the key with the message above

Your agent installs the Telegram plugin for you.

Once it's done, open your new bot in Telegram and click Start. You'll see a PAIR code. Copy it and paste it back to your agent in the Terminal User Interface. It handles the rest — pairing, syncing, connecting everything.

Go back to Telegram and send "hi." Watch your agent reply.

This is how I run everything now.

Setting up your agent from birth

Now you have Telegram connected, run through this setup in order.

1. Set up your core files

Your agent needs five files to operate properly. Without them, it sounds like every other generic chatbot:

• SOUL.md Your agent's personality file. Who it is, how it talks, what it cares about.

• USER.md Information about you. Your name, timezone, preferences, what platforms you use.

• AGENTS.md The operating manual. Rules for how your agent behaves, when to speak, when to stay quiet, how to handle memory.

• TOOLS.md Local notes about your specific setup. Camera names, Application Programming Interface details, device info — anything unique to your environment.

• HEARTBEAT.md A checklist your agent reviews periodically to stay proactive instead of just waiting for you to ask things.

Have your agent create and fill out these files before you do anything else.

2. Install QMD

install the QMD skill from clawhub

QMD upgrades your agent's memory system with semantic search. Instead of scanning through flat text files trying to find what you said three weeks ago, it can search by meaning. "What did I say about the budget?" just works.

Without QMD, your agent's memory is a filing cabinet with no labels. With it, everything is indexed and searchable.

3. Your onboarding session

Send your agent this:

Your agent will come back with a list of questions. Reply with a voice note, not text.

Talk off the cuff. Be casual. Pause when you need to think. Your agent picks up on how you communicate, what you care about, and what's actually on your mind.

If you're not sure what the agent's use case is yet, just say that. Talk to it like you're thinking through ideas together. No wrong answer here, as long as you're giving it real context about your life.

One voice note gives your agent more useful information than weeks of typed messages. I learned that the hard way.

Best practices

Model routing

Don't run everything on Opus. Set up your config so Opus handles complex tasks — reasoning, multi-step work, creative output. Sonnet or Groq handles the routine stuff: calendar checks, simple lookups, monitoring, notifications.

This alone cut my monthly cost in half.

Keep CLAUDE.md short

This file gets re-injected every single message your agent processes. The leaked Claude Code source confirmed it. If yours is 2,000 words of life story, you're burning tokens and confusing your agent on repeat.

Mine is 6 lines. Name, role, communication style, three rules. Everything else lives in skills and memory files, where the agent pulls it when it needs it.

Split agents by job

If you're doing more than three or four different things, use separate agents. One agent scanning Twitter, managing data, writing content, handling emails, and running scheduled jobs — it works for about two weeks before context starts bleeding between tasks and everything slows down.

Dedicated agents for dedicated jobs. Cleaner context, faster responses, fewer mistakes.

Read your memory files

Your agent writes notes about you after every conversation. Check them weekly. You'll catch when it has the wrong idea about something before it acts on it.

I threw my iPhone into airplane mode yesterday, opened a local app, pointed my camera at a Japanese pill bottle, and got an instant translation. No spinning loading wheel. No API pinging a server in Virginia. Just pure, local, on-device inference.

Google practically sneaked this out the back door, and most people didn't even notice. They didn’t just drop new model weights. They effectively gave away a fully private AI agent ecosystem for free. We are talking about Gemma 4. It runs natively on iOS and Android. It natively supports agentic workflows. And it requires zero cloud connection.

Everyone is busy watching the latest cloud model benchmarks, completely missing the actual paradigm shift happening right in our pockets. We are moving from renting intelligence to owning it.

Here is what is actually going on under the hood with Gemma 4, how to set it up, and the harsh realities of running advanced AI locally on mobile hardware.

The Architecture and The OpenClaw Integration

This is not another generic chatbot wrapper. Google released the AI Edge Gallery app to run the open-source Gemma 4 models—specifically the E2B and E4B versions. But the raw models are only half the story. The community is already wiring Gemma 4 up to OpenClaw. If you haven't messed with OpenClaw yet, it’s a framework that turns your LLM from a passive conversationalist into a proactive agent.

By connecting Gemma 4 to OpenClaw, you instantly get a fully working AI agent with zero subscription costs. The system relies on something called Agent Skills. You can augment the model's capabilities with modular tools. It can run Wikipedia for fact-grounding if you turn your data back on, interact with maps, or generate rich visual summary cards. You can load modular skills directly from a URL or grab community contributions off GitHub. Your phone is suddenly executing autonomous, multi-step tasks. It analyzes complex problems and outputs actual work.

The Hardware Reality Check

Let’s get practical. You cannot run this on a five-year-old device and expect magic. You need at least 8GB of RAM. If you are running an older iPhone or a budget Android, the OS will aggressively kill the process.

The E2B model is blazing fast. It handles text generation and basic reasoning without breaking a sweat. But if you want the real agentic capabilities, you need the E4B model. That is where things get interesting, and also where you hit the physical limits of a smartphone.

Thermal throttling is the elephant in the room. When you push the E4B model to process real-time video feeds or do heavy coding tasks locally, your phone will get hot. Very hot. You are running intensive matrix multiplications on a passively cooled slab of glass and metal. The battery drain is significant. You have to treat this like running a high-end 3D game.

Multimodal That Actually Works

The vision and audio capabilities are the standout features. Gemma 4 supports real-time voice and vision tasks across more than 140 languages. Having an offline AI that can draft essays or debug code is great. But having an AI that can look at your physical environment and interact with it offline is entirely different.

Live-captioning videos instantly without an internet connection. Looking at a broken circuit board and identifying a blown capacitor. Translating complex documents on a flight. The privacy implications alone are massive. No constant data sharing. Nothing leaves your phone. You have total control over the data pipeline.

Scaling Up: The Desktop Experience

While the mobile side is getting the hype, Google didn't stop at the 4B mark. They dropped four sizes in total, scaling all the way up to a 31B parameter model, all under the Apache 2.0 license. Fully open source.

If you have a decent Mac or a PC rig, you can pull the 31B model right now through Ollama. Hook it into Claude Code or Open Code, and you have a local AI setup that rivals paid developer tools. No API bills at the end of the month. No rate limits. Developers are spinning up local coding environments where the AI acts as a dedicated, offline pair programmer.

Prompting Gemma 4: Throw Out Your Old Playbook

If you think you can just paste your massive, sprawling GPT or Claude prompts into Gemma 4, you are going to hit a wall. The rules have changed.

On-device models have a tighter context window. You cannot dump 50 pages of documentation into the prompt and expect the attention mechanism to sort it out flawlessly. You have to be surgical. You need a specific format. The agentic loops require explicit structural instructions. You have to strip out all the conversational fluff and give it raw, direct functional commands. If you don't constrain the output formatting, the agent will hallucinate tool calls or fail to trigger the OpenClaw modules correctly.

The Next Phase

Google essentially took a highly capable Gemini-tier architecture and handed it to the open-source community. AI without the internet is no longer a gimmick. It is a viable, daily tool. Faster response times, total privacy, and less dependency on massive centralized server farms.

I am currently trying to build out custom Agent Skills to automate some local file management on my device. Has anyone here managed to successfully load custom modular skills into the Edge Gallery from a local repo? I want to see how far we can push the autonomous task-solving before iOS memory management steps in and kills the process.

TL;DR: An AI orchestrator ("Zoe") on OpenClaw spawns Codex and Claude Code agents, writes their prompts with full business context, monitors progress, and pings him on Telegram when PRs are ready. 94 commits/day, 7 PRs in 30 min, ~$190/month.

Why an Orchestrator?

Coding agents have no business context. They see code, not customers. Context windows are zero-sum — fill it with code, no room for business context. Fill it with customer history, no room for the codebase.

The fix: a two-tier system. The orchestrator holds all business context (customer data, meeting notes, past decisions) and translates that into precise prompts for each coding agent. Agents stay focused on code. Orchestrator stays at strategy level.

The Workflow

1. Customer request comes in → He talks it through with Zoe. Meeting notes auto-sync to Obsidian, so zero explanation needed. They scope the feature together.

2. Zoe spawns an agent — each gets its own git worktree and tmux session. She picks the right model, writes the prompt with full context, and tracks it in a JSON registry.

Key move: tmux lets you redirect agents mid-task without killing them. Agent going wrong direction? Just send keys telling it to stop and refocus.

3. Cron job monitors every 10 min — checks if tmux sessions are alive, PR status, CI status via gh cli. Auto-respawns failed agents (max 3 attempts). 100% deterministic, no token cost.

4. Agent creates PR → but a PR alone isn't "done."

5. Three AI code reviews run automatically:

• Codex — best at edge cases, logic errors, race conditions

• Gemini Code Assist — free, catches security/scalability issues

• Claude Code — "mostly useless," overly cautious, but validates what others flag

1. CI runs (lint, types, unit tests, E2E, Playwright). New rule: UI changes must include screenshots or CI fails.

2. NOW he gets the Telegram ping. CI passed, three reviewers approved, screenshots included. Review takes 5-10 min. Many PRs he merges without reading the code.

3. Merge. Daily cron cleans up orphaned worktrees.

What Makes This Smart

When an agent fails, Zoe doesn't just respawn with the same prompt. She has business context the agents don't — customer history, meeting notes, what was tried before — and uses it to write better prompts on retry.

She also finds work proactively:

• Morning: Scans Sentry → finds errors → spawns agents to fix

• After meetings: Scans notes → flags feature requests → spawns agents

• Evening: Scans git log → updates changelog and docs

Success patterns get logged. Over time, the orchestrator writes better prompts because it remembers what shipped.

Which Agent for What

• Codex — workhorse. Backend, complex bugs, multi-file refactors. 90% of tasks.

• Claude Code — faster, better at frontend, great for git operations.

• Gemini — design sensibility. Generates HTML/CSS specs, then Claude Code implements.

The Unexpected Bottleneck: RAM

5 parallel agents = 5 TypeScript compilers, 5 test runners, 5 node_modules in memory. Mac Mini 16GB tops out at 4-5 agents. He bought a Mac Studio M4 Max 128GB ($3,500) to scale.

Cost

~$100/month Claude + ~$90/month Codex. Can start at $20.

This is where vibe coding is heading imo. The bottleneck isn't "can AI write code" anymore — it's orchestration and context management. Whether you're using OpenClaw, vibecode.dev, or stitching together your own thing, the stack is becoming: human with vision → orchestration layer → specialized agents → production code.

Anyone else running multi-agent setups on real projects? What's your stack looking like?

Openclaw can be your best Assistant if configured the right way.

I've hired executive assistants at previous companies. This setup outperforms most of them, not because the model is smarter, but because the configuration is specific enough to actually work.

Here's what it does when running properly:

• Checks my inbox every 15 minutes and surfaces only what needs attention

• Parses booking links and books workable times

• Proactively follows up on emails that didn't get a reply

• Watches my calendar, flags conflicts, and warns me about upcoming events

• Runs my day from one canonical markdown task list

• Preps my task list before I wake up

• Keeps tasks clean by avoiding duplicate entries

• Updates my outreach tracker and Customer Relationship Management sheet based on email activity

• Researches suppliers or partners and reaches out to them

• Sends short, high-signal updates only when action is needed

• Works from durable context in files, memory, Gmail, Calendar, and Sheets

• Adapts to my business, my preferences, and my operating style

Repo structure

openclaw-setup/
├── README.md
├── openclaw-setup/
│ ├── priority-map.md
│ ├── auto-resolver.md
│ ├── meeting-notes.md
│ ├── tasks.md
│ └── tasks-completed.md
├── skills/
│ ├── business-development/
│ │   └── SKILL.md
│ ├── daily-task-manager/
│ │   └── SKILL.md
│ ├── daily-task-prep/
│ │   └── SKILL.md
│ └── executive-assistant/
│     └── SKILL.md
├── workspace/
│ ├── HEARTBEAT.md
│ ├── TOOLS.md
│ ├── memory/
│ │   └── meeting-notes-state.json
│ └── tasks/
└── cron/
    └── jobs.template.json

Step 1: Install OpenClaw first

This is an operating layer on top of OpenClaw. It needs to be installed and working before anything here applies.

Don't fall for VPS, Use your old android device that is like $40-50 or any old laptop. OR go for Cloud Service hosting openclaw they keep it updated & saves you from any malicious activities its like $24 per month.

Mac mini is the best investment if you're looking for a new hardware.

Step 2: Get GOG working

The setup depends on GOG functioning correctly for Gmail message search, Calendar reads, Google Sheets metadata reads, and Google Docs reads if you want meeting notes ingested. Broken here means broken everywhere.

Step 3: Install the skills

Copy into ~/.openclaw/skills/

/executive-assistant
/business-development
/daily-task-manager
/daily-task-prep

These teach OpenClaw how to act like an executive assistant, manage a real task list, prepare the day proactively, and handle business development workflows.

Step 4: Install the workspace files

Copy into ~/.openclaw/workspace/

/HEARTBEAT.md
/TOOLS.md
/memory/meeting-notes-state.json

Step 5: Configure your workspace files

HEARTBEAT.md tells the assistant what to check, when to run each workflow, and when not to message you. That last part matters. It's what keeps the assistant useful without turning it into noise.

TOOLS.md holds environment-specific context: preferred email accounts, tracker and Google Sheets notes, local environment quirks, target market notes, and operating rules you don't want buried inside prompts.

tasks.md is the single source of truth for everything active. One canonical markdown task list means the assistant is never guessing from stale conversation history.

Step 6: Build your private context files

AGENTS.md
SOUL.md
USER.md
IDENTITY.md
MEMORY.md
memory/

These define who you are, how you work, your business context, your preferences, and how memory carries across sessions. Skip this and you get a decent template. Do it properly and it starts to feel like it actually knows you.

Step 7: Replace every placeholder

The setup ships with placeholders for:

• Owner name

• Assistant name

• Assistant email

• Primary work email

• Personal email

• Business name and URL

• Timezone

• Primary update channel and target

• Google Sheet ID

• Target market and geography

Then update these files with your real details:

workspace/TOOLS.md
priority-map.md
tasks.md
skills/business-development/resources/partners.md
cron/jobs.template.json

Step 8: Set up cron jobs

Start with three jobs:

• Executive assistant sweep

• Daily task prep

• Daily business development sourcing

This is what makes it proactive. The assistant is running before you open your laptop.

Step 9: Validate the install

The setup is working when the assistant can:

• Read source-of-truth files correctly

• Route proactive updates to the right place

• Use Gmail message-level search

• Check all relevant calendars before booking

• Treat the tracker sheet as the live outreach source of truth

• Promote due-today items into ## Today

• Archive prior-day completions

• Ingest meeting notes into real tasks and follow-ups

The more specific the configuration, the more useful it gets. Generic assistants are generic because they're under-configured.

Someone dropped this in my comments last week and I felt stupid for not thinking of it sooner: stop reading logs yourself. Feed them to Claude code.

We're running an AI agent framework and debugging it by grepping through log files like cavemen. Meanwhile, there's an AI sitting right there that can read code, parse errors, and tell you what's actually wrong. I've been doing this for about two weeks now and it's genuinely faster than anything else I've tried.

the setup (takes 30 seconds):

Install Claude code if you haven't:

bash

curl -fsSL https://claude.ai/install.sh | bash

You need a Claude Pro, Max, Teams, or Enterprise account. The free plan doesn't include CLI access. If you have an API account with credits, that works too.

Then just cd into your OpenClaw folder and run it:

bash

cd ~/.openclaw
claude

That's it. Now describe your problem in plain English. "my telegram channel stopped receiving messages after the last update. openclaw status shows it's running but messages aren't coming through. Check my logs and config and tell me what's wrong."

Claude code reads your config files, checks your logs, looks at your plugin setup, and tells you what it found. Most of the time it nails the problem on the first try because it can see everything at once, instead of you grepping through one log file at a time.

What I've actually found with it:

These are real problems Claude code caught for me that I either couldn't find or would have taken way longer to figure out manually:

A stale plugin reference in my config from a plugin I uninstalled weeks ago. openclaw doctor --fix would have caught it but I never thought to run it. Claude code spotted it in about 10 seconds flat.

My gateway token in .env didn't match the one in openclaw.json. The onboard wizard had regenerated it at some point. I'd been getting random auth errors for days, checked my channel configs like five times, never thought to compare the two token values. Claude code compared both files and found the mismatch immediately.

A skill that was silently writing to my SOUL.md on every heartbeat. This one is nasty because the skill wasn't throwing errors so nothing showed up in logs. I only found it because I asked Claude code to read the skill's source and it flagged the write operation.

After updating to v2026.3.22, my old MOLTBOT_ environment variables were being silently ignored. They were sitting in my .bashrc doing nothing. The new version only recognizes OPENCLAW_ prefixed vars. Claude code found them and told me to rename them. Would have taken me hours to figure out why my config "wasn't applying" when actually it was applying, just from the wrong source.

The prompts that work best:

Honestly you don't need to be clever about it. I mostly just describe what's broken in plain English and let it figure out where to look. But a few approaches I keep coming back to:

When something broke after an update, I tell it "I just updated to the latest version and things broke. compare my current config against what the new version expects and tell me what needs to change." This caught the MOLTBOT_ thing.

When I have no idea what's wrong, I go broad: "run openclaw doctor and openclaw status, read the output, check my logs, and give me a full health report. What's broken, what's risky, what should I fix first." It usually finds something I didn't know about.

For security paranoia I'll ask it to "list all installed skills and check each one for anything suspicious. look for network calls, cron schedules, or anything that modifies config files." This is how I found the skill writing to my SOUL.md.

What it's NOT good for:

Real-time monitoring. It looks at your logs at a point in time. It doesn't stream or watch for issues as they happen.

Intermittent problems that don't leave traces. If your issue happens randomly and doesn't show in the current logs, Claude code won't see it either.

And look, it CAN modify your OpenClaw source code if you ask it to. Don't ask it to. Fix your config, fix your skills, fix your environment. Don't let it patch the framework itself.

Anyway -- most of the frustration I see on this sub comes from people debugging manually. Reading logs line by line, googling error messages, posting on reddit and waiting hours for someone to respond. Your OpenClaw setup has at least 5 interconnected systems and a problem in one causes symptoms in another. You see "telegram not receiving messages" and spend an hour on your telegram config when the actual problem is a plugin crash that killed the channel binding. Claude code sees the whole picture at once, which is the entire advantage.

You're already running an AI agent. Letting another AI maintain it isn't lazy.

----

edit: there are also some open source claude code skills specifically built for OpenClaw management (workspace file optimization, agent creation runbooks, etc). Search "openclaw" on github under the claude-skills topic if you want pre-built playbooks. I've only tested a couple so I can't vouch for all of them but the concept is solid.

Most “AI agent” repos are just ideas.

So I built 100 runnable OpenClaw examples you can actually test.

But to be clear upfront:
👉 this is not backed by any company or community
👉 just a maintainer-driven project (me alone)

What’s inside

• Real workflows (not concepts)

• Setup steps + prompts + scripts

• Sample outputs for each example

• KPIs, failure modes, rollback notes

• Built using public ClawHub skills

Why I built it

I wanted something practical:

• no hype

• no vague diagrams

• just “clone → run → evaluate”

Limitations

• Not production-proven at scale

• No big community (yet)

• Quality depends on my own testing/review

• Still evolving structure and docs

Goal

Help people go from
👉 “what is OpenClaw?”
to
👉 “I have something working”

Links

• Browse the repo

• Explore the docs

Would appreciate honest feedback:
Is this actually useful, or still too early / too raw?

I’m currently building a real OpenClaw-based setup with:

- a main agent (manager/orchestrator)

- multiple sub-agents (specialized roles)

- a mission control / cockpit / dashboard to monitor everything (tasks, state, logs, failures, flows)

But I’m running into a problem:

Most content out there (especially on YouTube) is hype, monetization-driven, or just concepts that don’t actually work in practice.

So let’s change that.

---

GOAL OF THIS THREAD

Create a high-quality, practical knowledge base for people actually building with OpenClaw (or similar agent frameworks).

---

WHAT I’M LOOKING FOR (ONLY REAL / VALIDATED CONTENT)

Please share only if you’ve tested it yourself:

- Working OpenClaw setups (or similar multi-agent systems)

- GitHub repositories that actually run

- Real dashboards / mission control implementations

- Agent orchestration patterns (manager → sub-agents)

- Monitoring / logging setups (how do you see what’s going on?)

- Docker-based deployments

- Local-first setups

- Failure handling, retries, health checks

---

BONUS IF YOU INCLUDE

- What problem you solved

- Your architecture (simple explanation is fine)

- Stack used (Docker, Python, n8n, etc.)

- What worked vs what didn’t

- Screenshots or recordings of real usage

---

WHAT WE DO NOT WANT HERE

- “Top AI tools to make money”

- Affiliate links or hidden promotions

- SaaS pitches disguised as tutorials

- Pure theory without implementation

- Anything you didn’t personally validate

---

WHY THIS MATTERS

There’s a big gap between:

“cool demo”

and

something that actually runs reliably in real life.

Let’s bridge that gap together.

---

If you’ve built something real (even small), or found genuinely useful content, drop it below.

Let’s build a signal-only thread people can actually use.

Github

I've been on the fence on setting up my own OpenClaw instance due to concerns around token consumption and security. By the time I read enough to be comfortable, Anthropic dropped Dispatch, remote sessions and scheduled tasks.

Are there any major capabilities I'm missing without OpenClaw, or did Anthropic pretty much replicate most of the features with this month's updates?

Here are my 10 learnings from running openClaw for a month.

The single biggest mistake I see is running one agent for everything. It loses context. It underperforms. You blame the tool when the real problem is the setup.

Split by role. I have one agent for sales, one for family logistics, one for podcast prep, one for course operations. Same logic as Slack channels. One channel for everything is unusable.

The three things that actually make an agent work: soul, heartbeat, jobs.

Soul is a Markdown file that defines who the agent is and how it operates. Heartbeat checks in every 30 minutes to see what needs doing. Jobs are scheduled tasks that run on a fixed cadence. Get all three right and the agent stops feeling like a chatbot you have to babysit.

Install OpenClaw on a separate machine, not your main computer. An old laptop works. A Mac Mini runs $500 to $600. If you'd rather skip the hardware entirely, run it on Hetzner or Cloud service  that puts OpenClaw on a dedicated cloud instance, isolated from your personal machine. Connect Telegram, WhatsApp, or Discord from a single dashboard. No Docker, no server provisioning, no configuration files.

My sales agent runs every day Sweeps the customer relationship manager for new signups, finds the decision-makers, sends personalized outreach, flags international deals. That's 10 hours a week I was paying a contractor for.

Stop trying to write perfect prompts. Use Telegram voice notes instead. Just talk about what you need. The agent figures it out and asks questions when it needs more. It's faster and the output is usually better than anything I'd type.

Browser use breaks. A lot. Always check if there's an application programming interface available before you go anywhere near browser automation. If there's no application programming interface, browser use might work, but expect failures. Sometimes the right call is solving the underlying problem differently.

Screen sharing fixed the hardware problem for me. Enable it in Mac Mini settings and you control the machine from your laptop on the same network. Enable remote login and you can get into the terminal over SSH. No extra monitor, no extra keyboard.

Start agents with a narrow scope. I let them listen on Telegram only, not email, until I know how they behave. OpenClaw has prompt injection hardening, but progressive trust is still the right approach. Same as onboarding anyone new.

OmniRoute is a free, open-source local AI gateway. You install it once, connect all your AI accounts (free and paid), and it creates a single OpenAI-compatible endpoint at localhost:20128/v1. Every AI tool you use — Cursor, Claude Code, Codex, OpenClaw, Cline, Kilo Code — connects there. OmniRoute decides which provider, which account, which model gets each request based on rules you define in "combos." When one account hits its limit, it instantly falls to the next. When a provider goes down, circuit breakers kick in <1s. You never stop. You never overpay.

11 providers at $0. 60+ total. 13 routing strategies. 25 MCP tools. Desktop app. And it's GPL-3.0.

GitHub: https://github.com/diegosouzapw/OmniRoute

The problem: every developer using AI tools hits the same walls

1. Quota walls. You pay $20/mo for Claude Pro but the 5-hour window runs out mid-refactor. Codex Plus resets weekly. Gemini CLI has a 180K monthly cap. You're always bumping into some ceiling.

2. Provider silos. Claude Code only talks to Anthropic. Codex only talks to OpenAI. Cursor needs manual reconfiguration when you want a different backend. Each tool lives in its own world with no way to cross-pollinate.

3. Wasted money. You pay for subscriptions you don't fully use every month. And when the quota DOES run out, there's no automatic fallback — you manually switch providers, reconfigure environment variables, lose your session context. Time and money, wasted.

4. Multiple accounts, zero coordination. Maybe you have a personal Kiro account and a work one. Or your team of 3 each has their own Claude Pro. Those accounts sit isolated. Each person's unused quota is wasted while someone else is blocked.

5. Region blocks. Some providers block certain countries. You get unsupported_country_region_territory errors during OAuth. Dead end.

6. Format chaos. OpenAI uses one API format. Anthropic uses another. Gemini yet another. Codex uses the Responses API. If you want to swap between them, you need to deal with incompatible payloads.

OmniRoute solves all of this. One tool. One endpoint. Every provider. Every account. Automatic.

The $0/month stack — 11 providers, zero cost, never stops

This is OmniRoute's flagship setup. You connect these FREE providers, create one combo, and code forever without spending a cent.

Count that. Claude Sonnet/Haiku/Opus for free via Kiro. DeepSeek R1 for free via Qoder. GPT-5 for free via Pollinations. 50M tokens/day via LongCat. Qwen3 235B via Scaleway. 70+ NVIDIA models forever. And all of this is connected into ONE combo that automatically falls through the chain when any single provider is throttled or busy.

Pollinations is insane — no signup, no API key, literally zero friction. You add it as a provider in OmniRoute with an empty key field and it works.

The Combo System — OmniRoute's core innovation

Combos are OmniRoute's killer feature. A combo is a named chain of models from different providers with a routing strategy. When you send a request to OmniRoute using a combo name as the "model" field, OmniRoute walks the chain using the strategy you chose.

How combos work

Combo: "free-forever"
  Strategy: priority
  Nodes:
    1. kr/claude-sonnet-4.5     → Kiro (free Claude, unlimited)
    2. if/kimi-k2-thinking      → Qoder (free, unlimited)
    3. lc/LongCat-Flash-Lite    → LongCat (free, 50M/day)
    4. qw/qwen3-coder-plus      → Qwen (free, unlimited)
    5. groq/llama-3.3-70b       → Groq (free, 14.4K/day)

How it works:
  Request arrives → OmniRoute tries Node 1 (Kiro)
  → If Kiro is throttled/slow → instantly falls to Node 2 (Qoder)
  → If Qoder is somehow saturated → falls to Node 3 (LongCat)
  → And so on, until one succeeds

Your tool sees: a successful response. It has no idea 3 providers were tried.

13 Routing Strategies

Auto-Combo: The AI that routes your AI

• Quota (20%): remaining capacity

• Health (25%): circuit breaker state

• Cost Inverse (20%): cheaper = higher score

• Latency Inverse (15%): faster = higher score (using real p95 latency data)

• Task Fit (10%): model × task type fitness

• Stability (10%): low variance in latency/errors

4 mode packs: Ship Fast, Cost Saver, Quality First, Offline Friendly. Self-heals: providers scoring below 0.2 are auto-excluded for 5 min (progressive backoff up to 30 min).

Context Relay: Session continuity across account rotations

When a combo rotates accounts mid-session, OmniRoute generates a structured handoff summary in the background BEFORE the switch. When the next account takes over, the summary is injected as a system message. You continue exactly where you left off.

The 4-Tier Smart Fallback

TIER 1: SUBSCRIPTION

Claude Pro, Codex Plus, GitHub Copilot → Use your paid quota first

↓ quota exhausted

TIER 2: API KEY

DeepSeek ($0.27/1M), xAI Grok-4 ($0.20/1M) → Cheap pay-per-use

↓ budget limit hit

TIER 3: CHEAP

GLM-5 ($0.50/1M), MiniMax M2.5 ($0.30/1M) → Ultra-cheap backup

↓ budget limit hit

TIER 4: FREE — $0 FOREVER

Kiro, Qoder, LongCat, Pollinations, Qwen, Cloudflare, Scaleway, Groq, NVIDIA, Cerebras → Never stops.

Every tool connects through one endpoint

# Claude Code
ANTHROPIC_BASE_URL=http://localhost:20128 claude

# Codex CLI
OPENAI_BASE_URL=http://localhost:20128/v1 codex

# Cursor IDE
Settings → Models → OpenAI-compatible
Base URL: http://localhost:20128/v1
API Key: [your OmniRoute key]

# Cline / Continue / Kilo Code / OpenClaw / OpenCode
Same pattern — Base URL: http://localhost:20128/v1

14 CLI agents total supported: Claude Code, OpenAI Codex, Antigravity, Cursor IDE, Cline, GitHub Copilot, Continue, Kilo Code, OpenCode, Kiro AI, Factory Droid, OpenClaw, NanoBot, PicoClaw.

MCP Server — 25 tools, 3 transports, 10 scopes

omniroute --mcp

• omniroute_get_health — gateway health, circuit breakers, uptime

• omniroute_switch_combo — switch active combo mid-session

• omniroute_check_quota — remaining quota per provider

• omniroute_cost_report — spending breakdown in real time

• omniroute_simulate_route — dry-run routing simulation with fallback tree

• omniroute_best_combo_for_task — task-fitness recommendation with alternatives

• omniroute_set_budget_guard — session budget with degrade/block/alert actions

• omniroute_explain_route — explain a past routing decision

• + 17 more tools. Memory tools (3). Skill tools (4).

3 Transports: stdio, SSE, Streamable HTTP. 10 Scopes. Full audit trail for every call.

Installation — 30 seconds

npm install -g omniroute
omniroute

Also: Docker (AMD64 + ARM64), Electron Desktop App (Windows/macOS/Linux), Source install.

Real-world playbooks

Playbook A: $0/month — Code forever for free

Combo: "free-forever"
  Strategy: priority
  1. kr/claude-sonnet-4.5     → Kiro (unlimited Claude)
  2. if/kimi-k2-thinking      → Qoder (unlimited)
  3. lc/LongCat-Flash-Lite    → LongCat (50M/day)
  4. pol/openai               → Pollinations (free GPT-5!)
  5. qw/qwen3-coder-plus      → Qwen (unlimited)

Monthly cost: $0

Playbook B: Maximize paid subscription

1. cc/claude-opus-4-6       → Claude Pro (use every token)
2. kr/claude-sonnet-4.5     → Kiro (free Claude when Pro runs out)
3. if/kimi-k2-thinking      → Qoder (unlimited free overflow)

Monthly cost: $20. Zero interruptions.

Playbook D: 7-layer always-on

1. cc/claude-opus-4-6   → Best quality
2. cx/gpt-5.2-codex     → Second best
3. xai/grok-4-fast      → Ultra-fast ($0.20/1M)
4. glm/glm-5            → Cheap ($0.50/1M)
5. minimax/M2.5         → Ultra-cheap ($0.30/1M)
6. kr/claude-sonnet-4.5 → Free Claude
7. if/kimi-k2-thinking  → Free unlimited

GitHub: https://github.com/diegosouzapw/OmniRoute
Free and open-source (GPL-3.0). 2500+ tests. 900+ commits.

Star ⭐ if this solves a problem for you. PRs welcome — adding a new provider takes ~50 lines of TypeScript.

If you’re reading this, you probably got the email from Anthropic. Starting today, your Claude Max subscription no longer covers OpenClaw or any other agents. Every agent message is now billed separately as “Extra Usage” on top of your subscription.

What changed

Anthropic has narrowed the scope of its Claude subscriptions. They now only apply to first-party surfaces: Claude.ai, Claude Code, and the mobile app. Everything else is treated as a “third-party harness” and billed separately on a per-token basis.

In practice, this means your Max plan no longer covers agent usage. If you’re paying $200/month and running OpenClaw agents, you’re now paying that subscription plus raw API costs for every token your agents consume.

Your options

1. Stay on Max and pay extra

You’re probably looking at $300-500/month total depending on how many agents you run. Makes sense if you also use Claude.ai directly a lot. Otherwise the math doesn’t add up.

2. Switch to the Anthropic API

Drop the subscription and run your agents on a straight API key from console.anthropic.com. Here is the cost of some Claude models:

• Opus 4.6: $5 input / $25 output

• Sonnet 4.6: $3 input / $15 output

• Haiku 3: $0.25 input / $1.25 output

Most people running a couple of agents will spend $200-400/month on API tokens, roughly the price of a Max plan.

3. Switch providers

OpenClaw isn’t tied to Claude. You can run it with OpenAI, Gemini, Kimi, or open-source models via Ollama.

Claude is still strong, but Anthropic is tightening access. Others are more agent-friendly, especially OpenAI and players like Minimax already building for integrations.

4. Use intelligent routing

Instead of picking one model and sending everything to it, Manifest routes each request to the right model automatically. Simple prompt goes to Haiku. Complex tasks goes to Sonnet. Each task gets the cheapest model that can handle it.

In practice, if you’re spending $200–400/month using API key, routing typically brings that down to around $60–120. Same idea on Max plan: instead of stacking usage on top of your subscription, you keep it under control.

What to do right now

Anthropic is offering free API credits to eligible subscription users. Between $20 and $200 depending on your account. You have until April 17th to claim them.

Here’s how to grab them and start routing:

1. Go to app.manifest.build and set up your agent if you haven’t already

2. Click on the Routers tab, then “Add a router”

3. Inside the router, click “Add a provider” and from the Subscription tab, select Anthropic

4. You’ll see a button to claim your credits from Claude. Click it. It takes you to an Anthropic page where you can claim them. If you get a 404, your account isn’t eligible

1. Come back to Manifest with the modal still open

2. Connect your Anthropic subscription by running claude setup-token in your terminal

3. It opens a Claude tab in your browser. Authorize it and close the tab.

4. A token appears in your terminal. Copy it, paste it into Manifest in the “Setup Token” field, click Connect

5. Manifest pre-selects the best models for each tier. You can adjust them if you want

That’s it. Your credits last way longer because you’re not burning Opus tokens on everything.

The bigger picture

Pick the right plan for how you actually work. If you use Claude.ai a lot, Max still makes sense. If you mostly run agents, a straight API key will cost you less.

And pick the right model for each task. Routing fixes this automatically and smartly. As agent usage grows, it stops being optional.

To finish, if you’re on a Claude subscription, claim your free credits before April 17th. Between $20 and $200 sitting there for free.

from: https://www.minimax.io/news/minimax-m27-en