MemoClaw’s pay-per-request model is simple: $0.005 for a store or recall, $0.01 for AI-powered endpoints like ingest and consolidate. No subscriptions, no minimums. But if your agent is chatty with the API, costs add up.

A “medium usage” agent doing 100 stores and 200 recalls per day runs about $1.50/day — around $45/month. That’s fine for some use cases, but it’s also way more than necessary if you’re smart about which endpoints you call and when.

Here’s how to cut your MemoClaw bill without sacrificing memory quality.

Know what’s free

The single biggest optimization: stop paying for things that are free. MemoClaw has a long list of endpoints that cost nothing because they don’t use OpenAI embeddings or LLM calls:

• GET /v1/memories — List memories with pagination
• GET /v1/memories/:id — Get a specific memory by ID
• DELETE /v1/memories/:id — Delete a memory
• POST /v1/search — Full-text keyword search
• GET /v1/suggested — Proactive memory suggestions
• GET /v1/memories/core — Core (pinned) memories
• GET /v1/memories/:id/history — Change history
• GET /v1/memories/:id/relations — List relations
• GET /v1/memories/:id/graph — Memory graph traversal
• GET /v1/export — Export all memories
• GET /v1/namespaces — List namespaces
• GET /v1/stats — Usage statistics

That’s a lot of free functionality. Use free endpoints first, and only fall back to paid ones when you actually need semantic search.

Strategy 1: Search before recall

The most common waste is using recall ($0.005) when search (free) would have worked.

recall generates an embedding from your query and does vector similarity search. It’s powerful for fuzzy, meaning-based lookups. But if you’re looking for something specific — a name, a URL, a configuration value — keyword search works fine.

# Costs $0.005:
memoclaw recall "What is the production database host?"

# Free:
memoclaw search "production database host"

When to use free search:

• Looking for a specific term, name, or identifier
• You know the exact wording (or close to it)
• Filtering by tags or namespace narrows results enough

When to pay for recall:

• Fuzzy queries (“What does the user prefer for formatting?”)
• You don’t know how the memory was worded
• You need similarity ranking

For OpenClaw agents, a good pattern is to try search first and only call recall if search returns nothing:

# In your agent's instructions:
When looking up a memory:
1. First try keyword search (free) with the most distinctive terms
2. If no results, fall back to semantic recall
3. Always filter by namespace and tags when possible

Strategy 2: Batch your stores

Storing memories one at a time costs $0.005 each. Batching up to 100 memories in a single call costs $0.04 total.

The math: 10 individual stores = $0.05. One batch of 10 = $0.04. At 100 memories, it’s $0.04 vs. $0.50 for individual calls — a 92% reduction.

# Expensive (5 × $0.005 = $0.025):
memoclaw store "Fact 1"
memoclaw store "Fact 2"
memoclaw store "Fact 3"
memoclaw store "Fact 4"
memoclaw store "Fact 5"

# Cheaper ($0.04 for up to 100):
memoclaw store-batch \
  '{"content": "Fact 1", "importance": 0.7}' \
  '{"content": "Fact 2", "importance": 0.8}' \
  '{"content": "Fact 3", "importance": 0.6}' \
  '{"content": "Fact 4", "importance": 0.7}' \
  '{"content": "Fact 5", "importance": 0.9}'

The practical pattern for agents: buffer memories during a session and store them all at once in an end-of-session hook. Instead of storing every observation in real time, collect them and batch-store when the session ends.

Strategy 3: Use core memories for frequent lookups

If your agent recalls the same information every session — user name, timezone, preferences — you’re paying $0.005 per session for information that never changes.

Pin these as core memories and retrieve them for free:

# Store once (paid, $0.005):
memoclaw store "User timezone is UTC-3, São Paulo" \
  --importance 0.9 --tags identity --pinned

# Then use the free core memories endpoint every session:
curl https://api.memoclaw.com/v1/memories/core

GET /v1/memories/core returns all pinned memories — no embedding cost, no charge. Perfect for the 5-10 facts your agent needs every single session.

Strategy 4: Set importance thresholds

Not everything is worth storing. An agent that stores every observation burns through API calls on low-value memories that clutter recall results and waste money.

Set a threshold:

# Agent instruction:
Only store memories with importance >= 0.5.
For observations below that threshold, skip the store.
Ask yourself: "Will this matter in 3 sessions?" If not, don't store it.

If half your agent’s stores are low-importance ephemeral notes, cutting them saves 50% on store costs and improves recall quality (less noise).

Strategy 5: Use ingest instead of store + extract

If you’re extracting facts from conversations and then storing them individually, you’re paying twice: once for extraction ($0.01) and once for each store ($0.005 each).

The ingest endpoint ($0.01) does extraction, deduplication, and relation-building in one call:

# Expensive way: extract then store each fact
# Extract: $0.01
# Store 5 facts: 5 × $0.005 = $0.025
# Total: $0.035

# Cheaper way: ingest does it all
# Ingest: $0.01
memoclaw ingest \
  --messages '[{"role":"user","content":"I use Postgres 15, deploy to Railway, and prefer 2-space indent"}]' \
  --namespace project-x

Ingest also handles deduplication automatically, so you won’t waste future recall calls sifting through duplicates.

Strategy 6: Consolidate periodically

Over time, agents accumulate redundant memories. Five slightly different versions of “user prefers dark mode” all compete in recall and dilute each other’s scores.

Run consolidation periodically ($0.01 per call) to merge similar memories:

memoclaw consolidate --namespace default

This pays for itself by reducing the number of memories (fewer to score during recall), improving recall precision, and making future recalls faster.

Recommended frequency: once a week, or whenever your memory count exceeds ~500 in a namespace.

Strategy 7: Monitor with free stats

Keep an eye on your usage patterns with the free stats and free-tier/status endpoints:

# Check your free tier remaining:
curl https://api.memoclaw.com/v1/free-tier/status

# Check overall usage stats:
memoclaw stats

Track these numbers weekly. If your store-to-recall ratio is heavily skewed toward recalls, you might be recalling redundantly (cache results in your session). If it’s skewed toward stores, you might be over-storing.

Cost comparison: before and after

A realistic example for an OpenClaw agent running 5 sessions per day:

Before optimization:

Operation	Count/day	Unit cost	Daily cost
Store (individual)	50	$0.005	$0.25
Recall	100	$0.005	$0.50
Extract	10	$0.01	$0.10
Total			$0.85/day

After optimization:

Operation	Count/day	Unit cost	Daily cost
Store-batch (5 batches of 10)	5	$0.04	$0.20
Search (free, replaces 60 recalls)	60	$0.00	$0.00
Recall (semantic only)	40	$0.005	$0.20
Ingest (replaces extract+store)	5	$0.01	$0.05
Core memories (free)	5	$0.00	$0.00
Total			$0.45/day

That’s a 47% reduction — from ~$25.50/month to ~$13.50/month — with zero loss in memory quality.

The 80/20 of agent memory costs

Most of your MemoClaw spend comes from two operations: store and recall. The optimizations that matter most:

1. Batch your stores — biggest single improvement
2. Use free search before paid recall — eliminates unnecessary embedding costs
3. Pin and use core memories — stop re-recalling the same facts
4. Don’t store junk — set an importance threshold

Nail these four and you’ll cut your bill in half. Everything else is refinement.

---

New to MemoClaw? Start with the quickstart guide — your first 100 API calls are free.