OpenClaw: The Open-Source AI Agent That Went From Weekend Project to 68K Stars in a Week

In late January 2026, an open-source project jumped from 9,000 GitHub stars to over 60,000 in 72 hours. CNBC covered it. China’s industry ministry issued security warnings about it. One user racked up a $500 API bill in a week. Another ran it for $0 a month on a Mac Mini.

The project is OpenClaw — a free, self-hosted AI agent that lives in your messaging apps and does whatever you tell it to. And while the hype has been loud, the actual product underneath is genuinely interesting for anyone who wants a personal AI that isn’t locked behind a subscription or a corporation’s content policy.

Here’s what OpenClaw actually is, the best ways to set it up, and — critically — how to pick models that don’t drain your bank account.

What OpenClaw Actually Is

OpenClaw is not an AI model. It’s not a coding tool like Claude Code or Cursor. It’s a gateway — a locally-running Node.js service that sits between you and any large language model, connecting AI capabilities to the messaging apps and services you already use.

Think of it as a personal AI butler that lives in your WhatsApp, Telegram, Discord, Slack, Signal, or iMessage. You text it instructions. It executes them using whatever LLM you’ve configured — Claude, GPT, Gemini, DeepSeek, or a model running locally on your hardware.

The key distinction, as one comparison put it: “Claude Code lives in your terminal for coding tasks. OpenClaw lives in your messaging apps for everything else.”

It was created by Peter Steinberger, the Austrian software engineer who founded PSPDFKit (a widely-used PDF SDK company). He started it as a personal weekend project in November 2025 under the name “Clawdbot.” After trademark friction with Anthropic, it was briefly renamed “Moltbot,” then “OpenClaw” — because, as Steinberger put it, “Moltbot never quite rolled off the tongue.”

What Can It Actually Do?

The short answer: a lot more than most people expect from an open-source project.

Persistent memory — stores context as local Markdown files, remembering conversations from weeks ago and adapting to your habits
12+ messaging platform integrations — WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Teams, Google Chat, Matrix, and more
Autonomous task execution — manage emails, calendars, browse the web, summarize documents, execute shell commands, control smart home devices
700+ skills ecosystem — extensible plugins via ClawHub, the public skills registry
Browser automation — click, type, screenshot, navigate, live web search
Code capabilities — GitHub integration, multi-file edits, deployment automation
Self-extending — it can write new skills for itself

The 700+ skills number isn’t inflated. The Awesome OpenClaw Skills collection on GitHub is actively maintained, and the skills range from simple utilities to full integrations with services like Home Assistant, Notion, and Google Workspace.

The Best Setups: VPS, Local PC, and Mac Mini

OpenClaw’s biggest selling point — and biggest source of confusion — is that it runs on your hardware. No cloud subscription required. But the setup experience varies dramatically depending on what you’re running it on.

Option 1: VPS (Best for Always-On, Remote Access)

Who this is for: You want OpenClaw available 24/7 from any device, messaging you back at 3am, and you don’t want to leave a computer running at home.

Minimum specs: 2GB RAM (4GB recommended), 10GB+ disk, Ubuntu 22.04 or 24.04.

Best VPS deals right now:

Provider	Starting Price	OpenClaw Support	Notes
Contabo	~$7/month	Free 1-click Add-On	Pre-configured, boots with OpenClaw ready
DigitalOcean	$6/month	1-Click Marketplace Droplet	Easiest setup for beginners
Hetzner	~$4/month	Manual or Pulumi deploy	Best value, popular with EU users
Hostinger	~$5/month	1-click Docker template	Good docs, easy Docker setup

Setup process: On most providers, you’re looking at a one-line install command followed by openclaw onboard, which walks you through gateway, workspace, channels, and skills configuration. Total time: about 15 minutes if you’ve done server stuff before, 30-45 minutes if you haven’t.

The DigitalOcean 1-Click option is genuinely the easiest path. Spin up a Droplet, SSH in, and you’re running. Contabo’s free add-on is also solid if you’re already on their platform.

Option 2: Local on PC / Linux (Best for Privacy and Power Users)

Who this is for: You want full control, you want your data to never leave your machine, and you’re comfortable with a terminal.

Requirements: Node.js 22+, an API key (or local model setup via Ollama), and about 5 minutes of actual setup time.

Setup:

# Install Node.js 22+ if you don't have it
# Clone and install
git clone https://github.com/openclaw/openclaw.git
cd openclaw
npm install
# Run the onboarding wizard
openclaw onboard

The onboarding wizard walks through everything: which messaging platforms to connect, which LLM provider to use, and which skills to enable. Configuration lives in ~/.openclaw/openclaw.json.

Docker option (recommended for isolation):

./docker-setup.sh
# Or manually:
docker build -t openclaw:local -f Dockerfile .
docker compose run --rm openclaw-cli onboard
docker compose up -d openclaw-gateway

The Docker setup runs as a non-root node user (uid 1000) and supports per-session container isolation for security — important if you’re giving it shell access. The control UI is accessible at http://127.0.0.1:18789/.

Windows users: WSL2 is strongly recommended. Native Windows support is not officially supported, and the community consensus is “just use WSL2, it works perfectly.”

Option 3: Mac Mini as a Dedicated AI Server (Best for Zero-Cloud Purists)

Who this is for: You want a physical device that runs 24/7 in your house, uses local models, and costs $0/month in API fees after the hardware purchase.

This is the setup that’s generated the most enthusiasm in the community, and for good reason. An M4 Pro Mac Mini with 64GB RAM running OpenClaw with local models via Ollama is a genuinely compelling personal AI server.

What you need:

Mac Mini M4 Pro (or M4, or even M2/M3 with at least 16GB RAM)
64GB RAM recommended for running 70B parameter models locally
Ollama installed for local model inference
OpenClaw configured to use Ollama as the provider

What you get:

Complete data privacy — nothing leaves your network
Zero recurring API costs
Low power consumption (~15-30W under load)
Runs silently, 24/7

The Marc0.dev guide is the definitive walkthrough for this setup. It covers Ollama configuration, model selection for Apple Silicon, and optimizing memory allocation.

Realistic expectations: A Mac Mini with 64GB can run Qwen 3 72B or Llama 3.3 70B locally at reasonable speeds. Responses won’t be as fast as cloud APIs, but they’re good enough for conversational use. With 16GB RAM, you’re limited to 7B-13B parameter models, which are noticeably less capable but still useful for basic tasks.

Which Setup Should You Pick?

Priority	Best Setup
Always available, any device	VPS (DigitalOcean or Contabo)
Maximum privacy, zero API costs	Mac Mini with Ollama
Maximum performance, willing to pay	Local PC with cloud API keys
Quick experimentation	Docker on any machine
Budget under $5/month total	Hetzner VPS + DeepSeek or Gemini Flash

Models and Stacks: Where the Real Decisions Are

Here’s the part that separates a $5/month OpenClaw setup from a $500/month one. The model you choose — and more importantly, how you route between models — determines everything about cost and capability.

OpenClaw’s Model Resolver supports multiple providers with automatic failover. If your primary model hits a rate limit, it cools down that key and switches to a backup. This is the feature that makes multi-model routing practical.

The Model Landscape

Provider	Model	Input/Output per M tokens	Best For
Anthropic	Claude Opus 4.5	$15 / $75	Complex reasoning, coding, analysis
Anthropic	Claude Sonnet 4	$3 / $15	Daily driver, best quality/cost ratio
Anthropic	Claude Haiku 4.5	$1 / $5	Quick tasks, classification
OpenAI	GPT-4o	$2.50 / $10	General tasks, broad knowledge
OpenAI	GPT-4o-mini	$0.15 / $0.60	Budget tasks, simple queries
Google	Gemini 2.5 Flash	$0.15 / $0.60	Cheapest cloud option with quality
DeepSeek	DeepSeek R1	~$2.74/M total	Reasoning tasks at 10x less than Opus
DeepSeek	DeepSeek V3.2	~$0.53/M total	Cheap general-purpose
Alibaba	Qwen 3	$0.075+	Absolute cheapest cloud option
Local (Ollama)	Llama 3.3 70B, Qwen 3 72B	$0	Zero-cost, privacy-first

Recommended Model Stacks

The key insight — widely discussed in the community and detailed in VelvetShark’s multi-model routing guide — is that you should never use one model for everything. Different tasks have wildly different complexity. Using Opus to check your calendar is like hiring a brain surgeon to apply a band-aid.

The Budget Stack ($1-5/month)

Primary: Gemini 2.5 Flash or GPT-4o-mini Fallback: DeepSeek V3.2 Use case: Calendar, email management, quick lookups, simple summaries

This is the “daily driver” stack for people who mostly use OpenClaw as a smart assistant for routine tasks. Both Gemini Flash and GPT-4o-mini are under $1/M tokens and handle 90% of conversational tasks well.

The Balanced Stack ($10-25/month)

Primary: Claude Sonnet 4 ($3/$15) Fallback: DeepSeek R1 ($2.74/M) 3rd: GPT-4o-mini ($0.15/$0.60) for simple tasks 4th: Gemini 2.5 Flash ($0.15/$0.60) as final fallback

This is the sweet spot for most users. Sonnet 4 handles the bulk of intelligent tasks — writing, coding, research, analysis — at a fraction of Opus pricing. DeepSeek R1 steps in for reasoning-heavy sub-tasks. The cheap models handle heartbeats, status checks, and simple queries.

“Sonnet 4 gives you most of Opus’s capability at a fraction of the cost. For 95% of daily OpenClaw usage, it’s indistinguishable.” — haimaker.ai model guide

The Premium Stack ($50-150/month)

Primary: Claude Opus 4.5 ($15/$75) Fallback: Claude Sonnet 4 ($3/$15) 3rd: DeepSeek R1 ($2.74/M) for sub-agents 4th: GPT-4o-mini ($0.15/$0.60) for simple routing

For users doing heavy coding work, complex research, or autonomous multi-step workflows where accuracy matters more than cost. Opus handles the hard problems; everything else cascades down.

The Zero-Cost Local Stack ($0/month)

Primary: Qwen 3 72B via Ollama Fallback: Llama 3.3 70B via Ollama 3rd: Phi-3 or Gemma for quick queries Requirements: 64GB+ RAM (Mac Mini M4 Pro ideal)

Complete privacy, zero recurring costs. The tradeoff is speed — local inference on a Mac Mini is roughly 3-5x slower than cloud APIs — and capability, which is noticeably lower than frontier cloud models for complex tasks. But for a personal assistant handling calendar, notes, and basic research? It’s genuinely good enough.

The OpenRouter Shortcut

If managing multiple API keys sounds tedious, OpenRouter offers a single API key that accesses 30+ models. Their “Auto” routing mode automatically selects the most cost-effective model for each prompt. It’s a reasonable middle ground between manual routing and using a single expensive model for everything.

The $500 Mistake (And How to Avoid It)

The user who ran up a $500 bill made a common error: they used Claude Opus for every single task, including heartbeats, status checks, and simple queries that could’ve been handled by a model 100x cheaper.

As the Molted blog put it: “OpenClaw doesn’t cost $700/month. You’re doing it wrong.”

Rules of thumb to control costs:

Never use your top-tier model for heartbeats and status checks. Route these to Gemini Flash-Lite ($0.50/M) or DeepSeek V3.2 ($0.53/M).
Set spending alerts. Most API providers let you configure billing alerts and hard caps.
Use Semantic Snapshots over screenshots for web browsing. OpenClaw parses accessibility trees instead of sending full screenshots, dramatically reducing token usage.
Start with cheap models and upgrade selectively. Begin with GPT-4o-mini for everything, then identify which tasks actually need a better model.
Monitor your usage. The control UI at http://127.0.0.1:18789/ shows token consumption per session.

A well-configured multi-model setup typically runs 50-80% cheaper than a single-model approach with virtually no quality loss for most tasks.

Security: The Elephant in the Room

OpenClaw’s power comes from its access to your systems — and that’s also its risk. It can execute shell commands, read your files, send messages on your behalf, and browse the web. If misconfigured, that’s a significant attack surface.

Trend Micro published a security analysis highlighting prompt injection risks, particularly when OpenClaw processes messages from untrusted sources (group chats, web content). China’s industry ministry issued explicit warnings about the agent’s access capabilities.

Mitigation measures worth taking:

Run OpenClaw in Docker with per-session isolation
Don’t give it access to credentials or secrets you wouldn’t give a stranger
Be cautious with group chat integrations — other users’ messages become inputs to the model
Consider NanoClaw, a security-focused fork that forces AI to run inside isolated containers
Review the skills you install from ClawHub before enabling them

This isn’t FUD — it’s the same advice you’d give anyone running an autonomous agent with system access. OpenClaw is a power tool, and power tools demand respect.

Bottom Line

OpenClaw isn’t a chatbot, and it isn’t a coding tool. It’s a personal AI infrastructure layer — a self-hosted gateway that makes LLMs useful for daily life, not just development. The fact that it’s free, open-source, and runs on your own hardware makes it fundamentally different from every commercial AI assistant on the market.

The setup isn’t hard. The model routing is where the real optimization happens. Get that right, and you’re looking at a genuinely capable personal AI assistant for $5-20/month. Get it wrong, and you’re the next person writing a “my $500 API bill” blog post.

Start with the Balanced Stack. Run it on a $6 DigitalOcean Droplet or your existing hardware. Connect it to whichever messaging app you actually use. And keep an eye on your API dashboard for the first week.

The lobster way, apparently, is the smart way.

Sources: