OpenClaw + Ollama: Run Private AI Agents Entirely on Your Mac

Why Run AI Locally

Every prompt you send to ChatGPT, Claude, or any cloud API leaves your machine, crosses the internet, and lands on someone else's server. Your code snippets, personal notes, financial data, medical questions — all of it is logged, stored, and potentially used for training. With OpenClaw connected to Ollama running on your own Mac, none of that happens. Your data stays on your SSD. No telemetry, no logging, no third-party access. For developers handling client code, lawyers reviewing sensitive documents, or anyone who values digital privacy, local inference isn't a luxury — it's the only responsible choice.

Beyond privacy, the economics are compelling. Cloud API costs add up fast: a heavy GPT-4o user easily spends $50–200/month on tokens. A 14B parameter model running locally on a Mac Mini handles roughly 80% of everyday tasks — drafting emails, summarizing documents, generating code, answering questions — for exactly $0 in API fees. The Mac pays for itself within months. And because inference happens on-device, you get zero network latency. Responses start streaming the instant you hit enter, with no round-trip to a data center thousands of miles away.

Local AI also means offline capability. On a plane, in a remote cabin, or during an internet outage, your AI agent keeps working. OpenClaw paired with Ollama gives you a fully autonomous assistant that doesn't depend on any external service. Pull your models once, and you're set. This guide walks you through the complete setup: hardware selection, Ollama installation, model choices by RAM tier, OpenClaw configuration, and ClashX hybrid routing for when you do need cloud APIs alongside local inference.

Hardware Guide: Which Mac to Buy

Apple Silicon's unified memory architecture makes Macs uniquely suited for local LLM inference. Unlike discrete GPUs with limited VRAM, the CPU and GPU share the same memory pool — so a 24GB Mac can load a 14B model entirely into GPU-accessible memory without any offloading penalty.

Why does unified memory matter so much for LLMs? Traditional PCs split memory between system RAM and GPU VRAM. A model that needs 10GB of VRAM requires a discrete GPU with at least that much — and consumer GPUs top out at 16–24GB for $800+. On Apple Silicon, the entire memory pool is accessible to the GPU at full bandwidth. A Mac Mini M4 Pro with 24GB of unified memory can load a Q4-quantized 14B model entirely into GPU-accessible space, running inference at 200 GB/s memory bandwidth. No other machine at this price point offers that combination of capacity and throughput for LLM workloads.

Install Ollama on macOS

Ollama is the simplest way to run open-source LLMs locally. One command to install, one command to pull a model, one command to run it.

1. Install Ollama

curl -fsSL https://ollama.com/install.sh | sh

2. Verify Installation

ollama --version
# Expected output: ollama version is 0.18.3

3. Pull Your First Model

ollama pull qwen3.5

4. Test It

ollama run qwen3.5 "Hello"

5. Configure Ollama for OpenClaw

Ollama's default settings are conservative. For use with OpenClaw as an always-on agent backend, apply these optimizations:

launchctl setenv OLLAMA_HOST "0.0.0.0:11434"
launchctl setenv OLLAMA_CONTEXT_LENGTH 8192
launchctl setenv OLLAMA_NUM_PARALLEL 4
launchctl setenv OLLAMA_KEEP_ALIVE "30m"

After setting these variables, restart Ollama for the changes to take effect. If you installed Ollama via the macOS app, quit and relaunch it. If running as a service, restart with brew services restart ollama.

Best Models by RAM Tier

Not all models are created equal. Here's what actually runs well on each RAM tier, tested on M4 Pro hardware with Q4_K_M quantization:

Our practical recommendation: start with Qwen 3.5 7B for daily use. It's the fastest model in the table and handles 80% of common tasks — answering questions, drafting text, light coding, summarization — with surprisingly good quality for its size. When you hit a task that needs deeper reasoning (complex code refactoring, multi-step logic problems, nuanced writing), switch to Phi-4 14B or DeepSeek-R1 14B on a 24GB machine. You can keep multiple models pulled and switch between them instantly with OpenClaw's model routing.

Install and Configure OpenClaw

With Ollama running and models pulled, it's time to install OpenClaw — the AI agent framework that turns your local LLM into an autonomous assistant.

1. Install OpenClaw

curl -fsSL https://openclaw.ai/install.sh | bash

2. Run Onboarding

openclaw onboard --install-daemon

The onboarding wizard walks you through initial setup. When prompted for an LLM provider, select Ollama. OpenClaw auto-discovers all models you've pulled locally — no manual endpoint configuration needed.

3. Set Environment Variable

export OLLAMA_API_KEY="ollama-local"

Ollama doesn't require an API key, but OpenClaw expects one to be set. Use any placeholder string.

4. Start the Gateway

openclaw gateway --port 18789 --verbose

The gateway is OpenClaw's central router — it receives requests and dispatches them to the appropriate model (local or cloud). Port 18789 is the default; --verbose shows real-time request logs, useful for debugging.

5. Open the Dashboard

openclaw dashboard

This launches the web-based control panel in your browser, where you can monitor active agents, view logs, switch models, and configure routing rules.

macOS-Specific Features

OpenClaw on macOS includes several platform-exclusive features. The menu bar app gives you quick access to agent status, model switching, and gateway controls without opening Terminal. Voice Wake lets you activate the agent with a hotword — say "Hey Claw" and start dictating a task. Talk Mode overlay provides a translucent floating window for voice conversations with your agent, similar to the Apple Intelligence Siri overlay but connected to your local models.

ClashX Hybrid Routing: Local + Cloud

Most users will want a hybrid setup: local Ollama for everyday tasks, cloud APIs (OpenAI, Anthropic) for tasks that demand frontier-model quality. The key is routing — local traffic should stay on your machine (DIRECT), while cloud API calls go through your proxy for privacy and geo-optimization.

Here's a minimal ClashX rule configuration for hybrid OpenClaw routing:

rules:
  - IP-CIDR,127.0.0.0/8,DIRECT
  - IP-CIDR,192.168.0.0/16,DIRECT
  - DOMAIN-SUFFIX,openai.com,🤖 AI Agent
  - DOMAIN-SUFFIX,anthropic.com,🤖 AI Agent
  - DOMAIN-SUFFIX,deepseek.com,DIRECT
  - MATCH,DIRECT

The first two rules ensure all local traffic (Ollama on 127.0.0.1:11434, OpenClaw gateway on 127.0.0.1:18789, and any LAN devices) bypasses the proxy entirely. OpenAI and Anthropic API calls route through your 🤖 AI Agent proxy group for privacy and optimal routing. DeepSeek is globally accessible without restrictions, so it goes direct to minimize latency. Everything else defaults to DIRECT.

VPS Alternative: No Mac Required

Not everyone has a Mac — or wants to keep one running 24/7. A cloud VPS is a viable alternative for running OpenClaw with Ollama as an always-on AI agent server. The tradeoff: no Apple Silicon GPU acceleration, so you're limited to CPU inference (significantly slower), but the server runs independently with guaranteed uptime.

For a budget-friendly option, Contabo Cloud VPS S (4 vCPU, 8GB RAM, $6.99/mo) can run 7B models at usable speeds via CPU inference. The setup is nearly identical to macOS — install Ubuntu 22.04, then run the same Ollama and OpenClaw commands:

# On your VPS (Ubuntu 22.04)
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen3.5
curl -fsSL https://openclaw.ai/install.sh | bash
openclaw onboard --install-daemon

Important limitation: standard VPS instances lack GPU hardware, so all inference runs on CPU. Expect 3–8 tokens/second for a 7B model on a 4-core VPS — usable for background tasks and async agents, but noticeably slower than Apple Silicon's 30–45 t/s. For real-time conversational use, a Mac with Apple Silicon remains the better choice. GPU-equipped cloud instances (A10G, L4) exist but cost $0.50–1.50/hour, which defeats the cost-saving purpose of local inference.

FAQ