Here’s a number that might bother you: if your MEMORY.md is 3,000 tokens and you use Claude Sonnet, you’re spending roughly $0.009 per message just on memory. That’s before the actual conversation. Before your agent reads any files. Before it thinks about your question. Just the memory tax.

Multiply that by 50 messages a day and you’re at $0.45/day on context you mostly don’t need. Over a month, that’s ~$13.50 on tokens your agent skimmed past to find the one line that mattered.

MemoClaw costs $0.005 per recall. One recall per message, only when the agent actually needs context. For most conversations, that’s fewer than 10 recalls a day. $0.05/day. Probably less.

Let me break down why.

The MEMORY.md problem

Every OpenClaw agent starts the same way. The AGENTS.md file says “read MEMORY.md” and the agent dumps the whole file into context. Every session. Every message. The entire file.

This made sense when MEMORY.md was 20 lines. But files grow. After a month of daily use, a typical MEMORY.md hits 2,000-4,000 tokens. I’ve seen some over 10,000.

The math is simple. Every token in your context window costs money, and MEMORY.md tokens are the worst kind: they’re always there, most of them aren’t relevant to the current message, and they push out space that could be used for actual work.

Here’s what a typical session looks like token-wise:

System prompt:       ~500 tokens
AGENTS.md:           ~800 tokens
MEMORY.md:          ~3,000 tokens   ← this is the problem
USER.md:             ~200 tokens
Conversation:       ~2,000 tokens
---
Total:              ~6,500 tokens

MEMORY.md is 46% of your input context. Almost half your tokens are memory, and on any given message, maybe 5% of those memories are relevant.

What MemoClaw does differently

Instead of loading everything, MemoClaw stores memories as individual records with vector embeddings. When your agent needs context, it makes a recall call with a relevant query and gets back just the matching memories.

A recall for “what language does the user prefer” might return 3 memories totaling 150 tokens. Not 3,000. Just the ones that match.

memoclaw recall "user's preferred programming language" --limit 3

Returns something like:

┌────┬─────────────────────────────────────┬────────────┬─────────┐
│ ID │ Content                             │ Importance │ Score   │
├────┼─────────────────────────────────────┼────────────┼─────────┤
│ 42 │ User prefers TypeScript over JS     │ 0.8        │ 0.94    │
│ 15 │ Always use .ts extensions, not .js  │ 0.7        │ 0.89    │
│ 73 │ User's main project is in TypeScript│ 0.5        │ 0.82    │
└────┴─────────────────────────────────────┴────────────┴─────────┘

Three memories. ~80 tokens. Exactly what the agent needed.

The cost comparison

Let’s do the math for a realistic day. Say your agent handles 40 messages, and about half of them benefit from memory context.

MEMORY.md approach:

• 3,000 tokens loaded into every message
• 40 messages × 3,000 input tokens = 120,000 tokens/day on memory alone
• At Claude Sonnet pricing ($3/M input tokens): $0.36/day
• Monthly: ~$10.80

MemoClaw approach:

• 20 recalls/day (only when needed) × $0.005 = $0.10/day
• Each recall returns ~100-200 tokens instead of 3,000
• Context token savings: ~100 tokens × 20 = 2,000 tokens vs 120,000
• Monthly recall cost: ~$3.00
• Monthly context savings: ~$10.44

The net savings depend on how big your MEMORY.md is and how chatty your agent is. But the pattern holds: selective recall beats full-file loading every time.

For agents with large memory files (8,000+ tokens) or high message volumes, the gap widens fast.

It’s not just cost — it’s speed

Token count affects latency. More input tokens means longer time-to-first-token. If you’ve noticed your agent getting slower over time, your growing MEMORY.md might be part of it.

Shaving 2,800 tokens off every request won’t make responses instant, but it helps. Especially on models that charge more and think longer with larger contexts.

How to set this up

Install the MemoClaw skill:

clawhub install anajuliabit/memoclaw

Then update your agent’s instructions. Instead of:

Read MEMORY.md at session start.

Use something like:

Use memoclaw recall to fetch relevant context when you need it.
Don't load all memories at once. Query for what's relevant to the current task.

Your agent now has store and recall tools. It calls recall when it needs context and store when it learns something new. No file reading, no bulk loading.

What about the free tier?

MemoClaw gives you 100 free API calls. Store and recall each cost one call. If you’re doing 20 recalls a day, you’ll burn through the free tier in about 5 days.

After that, it’s pay-per-request with USDC on Base. No subscriptions, no monthly minimums. You pay for what you use via x402 — the payment happens automatically with each request.

At $0.005 per recall, even heavy usage stays cheap. 1,000 recalls = $5.00.

# Check where you stand
memoclaw status

The tradeoff

There is one. MEMORY.md is free to read — it’s just a file. MemoClaw costs $0.005 per recall. If your agent makes a lot of recalls per message, the cost could theoretically exceed the context-window savings.

In practice, this rarely happens. A well-configured agent makes 0-2 recalls per message. The context savings almost always outweigh the recall cost, especially as your memory store grows. A 200-line MEMORY.md costs you tokens every message whether you need those memories or not. A 200-memory MemoClaw store costs nothing until you query it.

The other tradeoff: latency. A recall takes ~200-400ms. That’s an extra network round trip your agent didn’t have before. For most use cases, this is invisible — the model’s thinking time dwarfs it. But if you’re building something where every millisecond counts, it’s worth knowing.

When to stick with MEMORY.md

Honestly? If your MEMORY.md is under 500 tokens and you don’t expect it to grow much, the file approach is fine. The savings from MemoClaw kick in when your memory gets big enough that loading it all becomes wasteful.

The crossover point is roughly 1,000-1,500 tokens of memory. Below that, the simplicity of a flat file wins. Above that, you’re paying a growing tax on every message for context your agent mostly ignores.

---

Your agent’s context window is expensive real estate. MEMORY.md treats it like a storage unit — cram everything in and sort through it later. MemoClaw treats it like a search engine — ask for what you need, get what’s relevant. The difference shows up in your API bill and your response times.