There is a self-hosted personal AI assistant framework called OpenClaw. It's a tool that attaches to messengers you use like WhatsApp / Telegram / Slack and works like an AI secretary. Shortly after launch, it surpassed 145k stars on GitHub. It's a hugely popular open source project.

When it first came out, I tried using it too, but didn't use it because of two things: token consumption and slow responses. While looking for alternatives, I found an open source called takopi that lets you use a terminal agent through Telegram. Since I'm a Mattermost person(?), I forked it and made a backend called tunapi that calls (Claude Code, Codex, Gemini CLI) in -p mode, and I used it by adding different transports (Mattermost / Slack / discord).

I investigated and summarized why OpenClaw burns through tokens so quickly from a technical perspective. (This is an article I posted on my personal blog and I'm moving it here haha. Since it was a blog post, there's some advertising for an app I made at the end. Sorry about that! You can filter out that part.)

1. System prompt is reassembled every time

OpenClaw recreates the system prompt every time it runs. Materials included inside:

• Workspace files: AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md, USER.md, HEARTBEAT.md, BOOTSTRAP.md

• Tool list + JSON schema

• Skill list metadata

• Runtime metadata

With default settings, up to 20k chars per file is injected into the system prompt, with a total maximum of 150k chars (approximately 37.5k tokens). Typically, 5k-10k tokens are prepended to each API call.

2. A single task is decomposed into multiple tool calls

When an agent performs a task, each tool call (fetch email → analyze → decide priority → register to Todoist → summarize) generates a separate API call, and each call carries the entire context. Even seemingly simple requests can be decomposed into 5-10 API calls.

This isn't a call running secretly in the background but rather normal agent behavior, but from the user's perspective, "I just sent one message" and the token bill is shocking.

3. Entire conversation history is resent with every request

All history is accumulated in JSONL format in the .openclaw/agents.main/sessions/ directory, and the entire conversation history is sent back to the model with each new request.

According to one user report, the main session context already occupies 56-58% of the 400k window. In other words, even a simple question requires processing 200k+ tokens of cache context.

There is compaction (automatic summarization), but the trigger threshold is high, so it only works near the 200k context window. Until then, each call occurs with tens of k tokens accumulated.

4. Cache is a partial solution - cold start on TTL expiration

Anthropic Prompt Caching charges only 10% on cache hits, but there is a TTL (typically 1 hour). If you don't use it continuously, you pay full price on every cold start.

OpenClaw provides workaround settings like heartbeat (cache warming at 55-minute TTL intervals), but this means sending model calls even during times the user isn't using it, which is another cost.

5. Tool output accumulates in context

Large tool outputs (directory traversal results, file lists, search results, etc.) are saved as-is in the session record. Once they enter, they follow all subsequent calls. OpenClaw truncates oversized outputs to ~30% of the context window (hard cap 400k chars), but the accumulated amount still grows quickly.

6. MCP server overuse

This is surprisingly a big factor. The more MCP (Model Context Protocol) servers you install, the more each tool's description + JSON schema is prepended to the system prompt.

Measurements:

• Per MCP server, approximately 200-800 tokens of tool description added

• User operating 80+ tools: 5.2k token overhead per request

• Reduced to 8: 1.8k token overhead

• In similar architecture Hermes Agent measurement, even a simple calendar question like "What's on my calendar today?" consumes 15-20k input tokens before reasoning starts. Not OpenClaw's own measurement, but applicable as a reference since it follows the same pattern (tool definition + system prompt prepend)

The problem is that MCP multiplies with the other 5 causes:

Since OpenClaw's structure actively recommends the MCP marketplace (ClawHub), users naturally end up installing many MCPs, but often blame only model quality without realizing that's the source of token burn.

7. Heartbeat and Compaction themselves are also costs

• Heartbeat: Periodic background execution even without user messages

• Compaction: Additional model calls to summarize old history

• Memory search embedding: Token consumption from separate provider (OpenAI/Gemini/Voyage)

One user report: "Set up email check every 5 minutes and Heartbeat alone was $50 a day".

Real-world examples

MacStories editor Federico Viticci's own words: Using OpenClaw resulted in burning 180M tokens per month. The assistant's name is Navi, a combination of Telegram + M4 Mac mini + Claude Opus 4.5. (180M / $3,600 invoice conversion value is based on external reverse calculation using Sonnet unit price, so the exact unit price per model is separate)

German IT media c't 3003 test: $109.55 per day for Opus usage.

Reddit user $200 / day - single automation loop incident.

Summary

OpenClaw burning tokens quickly is not due to user error but a result of the architecture itself.

So why do people use it

Having 145k stars doesn't mean there are only cases of invoice shock. The actual usage spectrum is much wider:

• Light users: $10-30 per month

• Regular users: $40-80 per month

• Power users: $100-200 per month

• Viticci's case is an outlier

Furthermore, most OpenClaw users were connected to Claude Pro/Max OAuth, which meant they couldn't see the cost (official documentation: "OAuth tokens never show dollar cost"). Anthropic blocked Claude Pro/Max usage with OpenClaw from April 4, 2026, so API keys are now mandatory.

The real value of OpenClaw lies in:

• Messenger integration (WhatsApp, Telegram, Slack, iMessage, Signal, etc. 25+) allows using an AI assistant in one place

• Self-hosting + MIT license

• Agents can improve themselves (Viticci told Navi to "add image generation functionality to yourself" → it actually added the feature)

• Positive reviews from influential people like Simon Willison and Casey Newton

So how did I use it

I decided not to use OpenClaw because it's heavy and slow. Instead, I built a messenger ↔ AI CLI bridge called tunapi. It allows calling terminal AI tools like Claude Code / Codex CLI / Gemini CLI directly from Mattermost / Slack / Telegram. It retains session context, supports multi-agent roundtables (!rt), conversation branching, and channel-based project mapping within the messenger UI. And I don't really need an assistant to read emails, organize schedules, or tell me the weather. 😆 If you want something lighter, a mobile remote terminal app like https://damoang.net/free/6247926 might be a better option.

While OpenClaw aims to have AI assistants constantly present in all messenger channels, tunapi only activates when explicitly called. The absence of automatic background heartbeat calls results in a different token burn pattern.

OpenClaw is not a bad tool; it's just expensive due to its extensive features. If your usage pattern doesn't align with it, a lighter self-made combination might be the answer.

Sources

• Official documentation: https://docs.openclaw.ai/reference/token-use

• Official MCP documentation: https://docs.openclaw.ai/cli/mcp

• Codebase analysis: github.com/centminmod/explain-openclaw

• Viticci's own article: https://www.macstories.net/stories/clawdbot-showed-me-what-the-future-of-personal-ai-assistants-looks-like/

• MCP 12 running examples (5.2k → 1.8k token overhead measurements): openclawvps.io

• "$200/month floor", dev.to analysis: https://dev.to/thegdsks

• Usage distribution ($10-200/month): aifreeapi.com

• Hermes Agent (Nous Research, separate project) cost measurements: remoteopenclaw.com

• c't 3003 test ($109.55/day): nerdbot.com quote