OpenClaw VPS-Anforderungen: Wie viel RAM, CPU & Speicher Sie wirklich brauchen

The #1 Mistake People Make With OpenClaw Hosting

Most OpenClaw crashes aren't bugs. They're hosting problems. Specifically, insufficient RAM.

OpenClaw's gateway process needs around 530-550 MB just to start. Add a few channels, some tool calls, and a conversation with context accumulation, and you're well past 1 GB. On a 1 GB VPS, the JavaScript heap hits its limit and the process gets OOM-killed -- often without a clear error message. Your agent just silently stops responding.

This guide gives you the exact specs you need based on what you're building, so you don't waste money on too much server or lose time debugging crashes caused by too little.

Quick Reference: VPS Specs by Use Case

Use Case	RAM	CPU	Storage	Monthly Cost
Testing & evaluation	1 GB	1 vCPU	20 GB SSD	~$5/mo
Single chat agent (text-only)	2 GB	1-2 vCPU	40 GB SSD	~$6-12/mo
Production agent with tools	4 GB	2-4 vCPU	40 GB NVMe	~$6-15/mo
Browser automation	8 GB	4 vCPU	80 GB NVMe	~$8-24/mo
Multi-agent or local models (7B)	16 GB	4-8 vCPU	80 GB NVMe	~$15-48/mo
Local models (13B+)	32 GB+	8+ vCPU	160 GB NVMe	~$29-100/mo

RAM: The Spec That Matters Most

RAM is the single most important factor for a stable OpenClaw deployment. Not CPU, not storage speed, not bandwidth. RAM.

Here's what actually happens at each tier:

1 GB RAM: Crashes Constantly

OpenClaw's gateway alone needs ~530 MB. The Node.js runtime, system processes, and any channel connections eat the rest. You'll see FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory within minutes of starting a conversation. Docker's pnpm install step will OOM-kill with exit code 137 before you even get the container running.

Verdict: Only useful for a 15-minute evaluation. Not production-viable.

2 GB RAM: Bare Minimum for Text Chat

Enough for a single text-based agent on one channel (Telegram or Discord). No browser automation, no heavy tool use, no concurrent conversations. You'll run into trouble if context windows grow large (150,000+ tokens after extended conversations) or if you run multiple channels simultaneously.

Verdict: Works for personal use with a single channel. Tight.

4 GB RAM: The Sweet Spot for Most Users

Handles production text agents, multiple channels, tool calling, and moderate concurrency comfortably. This is where most self-hosted OpenClaw deployments should start.

Important note for v2026.3.7+: Recent versions have a regression where the openclaw-message binary can consume 500+ MB before failing. If you're hitting OOM on 4 GB, add this to your environment:

NODE_OPTIONS="--max-old-space-size=4096"

Verdict: Recommended starting point for production deployments.

8 GB RAM: Required for Browser Automation

Chromium (used for web browsing tools) consumes 2-4 GB per session on its own. Add OpenClaw's gateway, a database, and normal operations, and 4 GB isn't enough. If your agent needs to browse the web, scrape pages, or take screenshots, start here.

Verdict: Required if your agent uses browser-based tools.

16-32 GB RAM: Local Models with Ollama

Running local LLMs alongside OpenClaw is resource-intensive. A 7B parameter model needs ~8 GB of additional RAM. A 13B model needs ~16 GB. These requirements stack on top of OpenClaw's own needs.

Verdict: Only needed if you're running Ollama locally to avoid API costs.

CPU: Less Critical Than You Think

OpenClaw is not CPU-bound for most workloads. The heavy lifting (LLM inference) happens on your API provider's servers, not yours. Your VPS mainly handles I/O: receiving messages, calling APIs, parsing responses, and executing tools.

• 1 vCPU: Fine for a single agent with light tool use
• 2-4 vCPU: Recommended for production with multiple channels and tool calling
• 4-8 vCPU: Needed for browser automation (Chromium is CPU-hungry) or multi-agent setups
• 8+ vCPU: Only necessary if running local models with Ollama (CPU inference without GPU)

The official recommendation is 4 CPU threads minimum. In practice, 2 vCPU handles most deployments comfortably.

Storage: NVMe Makes a Real Difference

OpenClaw itself doesn't need much disk space -- the base installation is under 2 GB. But storage speed matters significantly.

Capacity

• Minimum: 40 GB (base install + logs + conversation history)
• Recommended: 80 GB (room for growth, model files if using Ollama)
• With local models: 80-160 GB (each model file is 4-8 GB)

Speed: NVMe vs SATA SSD

NVMe reduces model load times by roughly 40% compared to SATA SSDs. In real-world benchmarks, NVMe sustains 2,800-3,800 MB/s throughput versus SATA's 500-550 MB/s. For text-only agents using cloud APIs, this difference is negligible. For anything involving local models, file processing, or database operations, NVMe is worth the small price premium.

Network & Bandwidth

Good news: bandwidth is rarely a constraint for OpenClaw.

• Text-only agents: Under 50 GB/month total bandwidth
• Agents with file transfers or browser automation: 100-200 GB/month
• Per-agent daily budget: 500 MB - 2 GB

What matters more than raw speed is latency and stability. A stable 50 Mbps connection beats an unreliable gigabit link. Aim for under 100 ms round-trip to your API provider (Anthropic, OpenAI, etc.).

Most VPS providers include 1-4 TB of monthly bandwidth, which is far more than OpenClaw will use.

Docker-Specific Requirements

If you're deploying with Docker (recommended), keep these limits in mind:

# docker-compose.yml resource limits
services:
  openclaw:
    image: openclaw/openclaw:latest
    deploy:
      resources:
        limits:
          memory: 7G
          cpus: '3.5'
        reservations:
          memory: 2G
          cpus: '1.0'

• Docker version: 24 or newer
• Minimum RAM for building the image: 2 GB (the pnpm install step OOM-kills on 1 GB)
• Sandbox container limits: Each tool execution sandbox gets 512 MB memory and 1 CPU core by default
• Node.js: Version 24 recommended (22.14+ minimum)

Database: Optional but Useful

OpenClaw works without a database for basic setups. But if you want persistent memory, RAG (retrieval-augmented generation), or searchable conversation history, PostgreSQL is the way to go.

• PostgreSQL version: 13 or higher
• Recommended extension: pgvector for vector similarity search
• Performance: Community benchmarks show 1,100+ documents indexed with search latency under 200 ms
• Security tip: Use a read-only database user to prevent accidental data modifications

A managed PostgreSQL instance from DigitalOcean ($15/mo) pairs well with an OpenClaw VPS, or you can run PostgreSQL on the same server if you have 4+ GB RAM.

Recommended VPS Providers for OpenClaw

Based on our testing and the requirements above:

Best Value: Contabo

Contabo's Cloud VPS 1 at $4.50/mo gives you 4 vCPU, 8 GB RAM, and 50 GB NVMe. That's more than enough for production OpenClaw with browser automation. No other provider comes close on raw resources per dollar.

Best for: Budget-conscious deployments, heavy workloads, local model experimentation.

Best Overall: Hostinger

Hostinger KVM 1 at $6.49/mo delivers 1 vCPU, 4 GB RAM, and 50 GB NVMe with a clean control panel, weekly backups, and 24/7 support. The KVM 2 at $8.49/mo bumps to 8 GB RAM for browser automation.

Best for: Production deployments where ease of management matters.

Best for Developers: DigitalOcean

DigitalOcean has a one-click OpenClaw image in their marketplace. The $24/mo droplet (2 vCPU, 4 GB) gives you a running OpenClaw instance in under 5 minutes.

Best for: Developers who want the fastest possible setup with great documentation.

Best Global Coverage: Vultr

Vultr operates 32 data centers across 6 continents. If low latency to your API provider matters (and it does for real-time chat agents), pick a Vultr server in the same region as your LLM provider.

Best for: Deployments where latency is critical, especially outside US/EU.

Running OpenClaw + Ollama: Additional Requirements

If you want to run local models to avoid API costs, here's what to add on top of OpenClaw's base requirements:

Model Size	Additional RAM	Additional Storage	Recommended Model
7B parameters	+8 GB	+8 GB	qwen2.5:7b-instruct-q4_K_M
13B parameters	+16 GB	+12 GB	qwen2.5:14b-instruct-q4_K_M
32B parameters	+32 GB	+20 GB	qwen2.5:32b-instruct-q4_K_M

Important: Local models need a minimum 64K context window to work well with OpenClaw's system prompts. Smaller context windows (like 4K or 8K on some models) will cause degraded performance or failures.

GPU acceleration (NVIDIA CUDA) dramatically improves local model performance. Without a GPU, CPU-only inference on a VPS is slow (10-30+ seconds per response for 7B models). Most VPS providers don't offer GPU instances at budget prices, so for most self-hosters, cloud API providers remain the practical choice.

Quick Decision Guide

Spending under $20/mo on API calls? Get a 2 GB VPS ($5-6/mo) and use cloud APIs.

Running a production agent for your team? Get a 4 GB VPS ($6-10/mo) with NVMe.

Need browser automation or web scraping? Get an 8 GB VPS ($8-15/mo) minimum.

Want to avoid API costs with local models? Get 16+ GB VPS ($15-30/mo) and budget for slower responses.

Running multiple agents? Get 8-16 GB VPS ($15-48/mo) and consider queue management.

Conclusion

OpenClaw's resource needs are modest for text-only agents but scale quickly with browser automation and local models. The #1 cause of crashes is insufficient RAM -- not bugs, not configuration errors, not network issues.

Start with 4 GB RAM for production use, upgrade to 8 GB if you need browser tools, and only go higher if you're running local Ollama models. Pick an NVMe-based VPS from any of our recommended providers and you'll have a stable, responsive AI agent running 24/7.