Medium#Performance

OpenClaw High Memory Usage

By Jason GuoPublished March 2, 2026Updated September 5, 2026

High RAM usage in OpenClaw almost always comes from the AI model loaded in memory, not from OpenClaw itself. The gateway process uses a modest 200-400 MB. A 7B parameter model at full F16 precision, however, needs 14+ GB — more than most home servers have. The strategies below can cut your model's RAM footprint in half or more without a meaningful quality drop, and work on everything from a Raspberry Pi 5 to a Hetzner VPS.

diagnose.sh

🔍 Diagnose First

# Check top memory consumers

$ ps aux --sort=-%mem | head -20

# Docker container stats

$ docker stats --no-stream

# RAM usage by quantization (8B model):

# F16 → 14GB | Q8_0 → 9GB | Q4_K_M → 5GB | Q4_0 → 4.1GB

Before optimizing, measure your baseline. On Linux/macOS, run 'ps aux --sort=-%mem | head -20' to see what's consuming the most RAM. On Docker systems, use 'docker stats' to see per-container usage. The Ollama process will typically show the model's full weight in RSS memory. Compare against the table below to understand how much room each optimization buys you.

memory_fix.yaml

✅ Memory Reduction Strategies

1. Use quantized model weights

Quantization reduces model precision from 16-bit floats to 4-8 bit integers. The quality difference is negligible for most tasks. A Q4_K_M 8B model uses about 5 GB vs 14 GB for F16 — nearly a 3x reduction. Start here before anything else.

# 8B model RAM usage by quantization:

# F16 → 14GB | Q8_0 → 9GB | Q4_K_M → 5GB

$ ollama pull llama3.1:8b-q4_K_M

2. Limit context window

The KV cache (the memory used to store conversation history) scales linearly with context length and number of concurrent conversations. Halving context_length from 4096 to 2048 saves roughly 2 GB for a 7B model. Most conversations use far less than 4096 tokens.

ai:

context_length: 2048 # saves ~2GB vs 8192

3. Enable model unloading when idle

By default, Ollama keeps the loaded model in RAM indefinitely. Setting keep_alive: '5m' tells Ollama to unload the model after 5 minutes of inactivity, freeing all GPU/RAM until the next request arrives. The model reloads in 2-4 seconds on SSD systems.

ai:

keep_alive: "5m" # unload after 5min idle

4. Configure swap on Linux (for Raspberry Pi / VPS)

Adding swap lets the OS spill model weights to disk when RAM is full. This is slower than running in RAM but prevents OOM kills. For a 4 GB Pi running a 5 GB model, 4 GB of swap on a fast SD card or USB drive is usually sufficient. Avoid excessive swap on HDDs — the latency is brutal.

$ sudo fallocate -l 4G /swapfile

$ sudo chmod 600 /swapfile && sudo mkswap /swapfile

$ sudo swapon /swapfile

# Make permanent:

$ echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

❓ FAQ

Q1. How much RAM does OpenClaw itself use?

The OpenClaw gateway and agent runtime use around 200-400 MB of RAM, depending on how many tools and skills are loaded. This is relatively small. The majority of memory usage comes from the AI model loaded by Ollama. A Q4_K_M quantized 8B model uses about 5 GB of RAM, while an F16 8B model uses around 14 GB.

Q2. Can I run OpenClaw on a 4 GB Raspberry Pi?

Yes, but you'll need to be careful with model selection. Use heavily quantized models (Q4_0 or smaller, e.g., Phi-3 Mini at 3.8B parameters — about 2.3 GB at Q4) and enable 4 GB of swap. Alternatively, use a cloud API (Claude/OpenAI/Gemini) instead of a local model — with cloud APIs, OpenClaw itself uses only 200-400 MB and a 4 GB Pi handles it comfortably.

Q3. Does reducing context_length affect output quality?

Somewhat. A 2048-token context window means the model can only reference the last ~1500 words of conversation history. For most troubleshooting help, quick tasks, and FAQ-style interactions, this is sufficient. For long research sessions, code reviews of large files, or multi-turn conversations that build on earlier context, keep it at 4096 or higher.

Q4. What's the difference between RAM and VRAM usage?

VRAM is your GPU's dedicated memory (e.g., NVIDIA RTX 4060 has 8 GB VRAM, Apple Silicon's unified memory serves both). When a model fits entirely in VRAM/GPU memory, inference is fast. When it's too big, layers spill to system RAM — this hybrid mode (partial GPU offload) is slower but still faster than pure CPU. Track VRAM separately with 'nvidia-smi' (NVIDIA) or 'sudo powermetrics --samplers gpu_power' (Apple).

Q5. Will using swap hurt performance badly?

It depends on the swap medium. SSD swap (NVMe or fast SATA SSD): you'll see a 30-50% speed reduction compared to RAM — tolerable for background tasks. SD card or slow USB swap (common on Raspberry Pi): 5-20x slower than RAM — usable but you'll notice the lag. HDD swap: avoid for active inference — too slow to be practical. If possible, use a fast USB 3.0 SSD as swap on Pi to get closer to SSD-tier performance.

Q6. How do I set memory limits in Docker to prevent OOM kills?

Add a 'mem_limit' to your docker-compose.yml service definition. For example, 'mem_limit: 6g' caps the container at 6 GB. When the limit is hit, Docker kills the container rather than letting it crash the host. Combine with 'memswap_limit: 10g' to also allow swap. Note: Ollama runs as a separate process from the OpenClaw container — you need to limit both if you want full control.

← Back Pi 5 Hardware Guide →