OpenClaw on a Mac mini: how much memory you need ?

#OpenClaw on a Mac mini: why this machine comes up so often

OpenClaw is a self-hosted agent: a Node.js gateway that runs continuously, keeps connections open to your messaging apps, and forwards each message to a tool-equipped language model. So it needs a machine that's on day and night, that you control, and that doesn't hold your personal data. The Mac mini checks these boxes for four reasons.

iMessage

For many users, this is the deciding factor. iMessage only exists within the Apple ecosystem: for OpenClaw to read and send iMessages, you need a Mac running the Messages app signed in to an Apple ID. No Linux PC or VPS can fill that role on its own. The OpenClaw documentation covers the available iMessage integrations and the macOS permissions they require.

Low power use

An Apple Silicon chip draws little power at idle, which matters for a machine that spends 95% of its time waiting for messages. Apple publishes the power consumption and thermal output of each Mac mini on its support site. Look up the figure for your model rather than relying on a number copied from somewhere else.

Noise and footprint

A desktop box you can forget about on a shelf, without the fans of a tower with a graphics card.

Unified memory

If you ever want to run the model locally, the Mac's memory is shared between the CPU and GPU. A Mac mini with 48 or 64 GB can load models that no 24 GB consumer graphics card can fit entirely.

None of this is required by OpenClaw. The gateway also runs on Linux, and on Windows via WSL2. The Mac mini is only the right choice if one of these four arguments applies to you, and iMessage is the only one with no equivalent elsewhere.

#Two completely different scenarios: remote API or local model

The memory you need varies by a factor of ten depending on where the model runs. So settle this before you look at configurations.

Online model via API

The Mac mini only runs the gateway, Node.js, the agent's tools, and possibly a controlled browser. The reasoning happens at the provider. The load is light, and any current configuration is enough. The tradeoff: your messages and the content the agent reads are sent to that provider, and every exchange is billed.

Local model with Ollama

The Mac mini also loads the model weights and its context window into unified memory. This is what drives the entire purchase. The trade-off: a reasonably sized local model calls tools less reliably than a large hosted model, and is more easily hijacked by booby-trapped text.

Mixte

Nothing stops you from starting with an API on a modest Mac mini and moving to local later. But memory can't be added: if local is a serious plan, buy the capacity it will need right from the start.

#The current Mac mini lineup and its memory options

In August 2026, Apple introduced the M6 and M5 Pro Mac mini, available since September 22, replacing the M4 and M4 Pro. The older models are still in stock at some resellers and on the used market. Here's what matters for OpenClaw, based on the announcement and the tech specs from Apple.

Mac mini M6

16 GB of unified memory base, 24 or 32 GB optional. Bandwidth: 153 GB/s with 16 GB, 170 GB/s with 24 GB or more. Maximum: 32 GB.

Mac mini M5 Pro

24 GB base, 48 or 64 GB optional. Bandwidth: 307 GB/s. This is the only configuration in the lineup that opens up 30B to 35B parameter models with real headroom.

Mac mini M4 (remaining stock, used)

10-core CPU, 10-core GPU, 120 GB/s, 16 GB base, 24 or 32 GB optional.

Mac mini M4 Pro (remaining stock, used)

24 GB base, 48 or 64 GB optional, 273 GB/s, Thunderbolt 5.

Apple claims significantly faster prompt processing for the M6 and M5 Pro than the previous generation in LM Studio, thanks to the accelerators added to the GPU cores. For an agent, this is the most useful gain: at every step, OpenClaw sends the model its system prompt, its tool descriptions, and the history, meaning a long prompt before your message even arrives. Generation speed, however, remains limited by memory bandwidth and improves much less. We don't give speeds for OpenClaw: no public benchmark combines this hardware, this agent, and a reproducible methodology.

#How much memory for OpenClaw on a Mac mini with an API

With a hosted model, the gateway just relays messages and runs tools. The project's published hardware requirements are low: the Docker installation docs ask for at least 2 GB of RAM, and even that is for building the image. Every current Mac mini configuration far exceeds this threshold.

What really uses memory is everything around it: a browser the agent drives to read web pages, several connected messaging apps, other services hosted on the same machine (a notes database, a home automation server, a backup), and macOS itself with Messages always open. None of these alone justifies moving up a tier.

Recommendation

The base configuration, meaning 16 GB on an M6 (or a used M4). It leaves plenty of headroom for the gateway, a browser, and a few services.

When to get more

Only if you're considering a local model later. In that case, use the next section, not this one.

Storage

The gateway and its Markdown memory take up little space. The base storage is enough with an API; a local model, on the other hand, needs several tens of gigabytes per downloaded model.

#How much memory with a local model served by Ollama

The math changes scale. Three things have to fit together in the share of memory macOS leaves to the GPU: the model weights, the context window, and the rest of the system.

The weights

Q4_K_M reference points, weights only: about 5 GB for a 7-billion-parameter model, 9 GB for 14 billion, 19 GB for 32 billion, 40 GB for 70 billion.

Context

Ollama's OpenClaw page recommends at least 64,000 tokens of context with a local model. This window reserves memory on top of the weights; how much depends on the model's architecture. Don't overlook it: it's what makes a model that fit perfectly well in a simple chat overflow.

The GPU ceiling

A Mac's GPU doesn't use all of the unified memory. According to llama.cpp users, the default ceiling is between two-thirds and three-quarters of RAM. On 16 GB, that leaves about 11 GB for the model and its context.

The system

macOS, Messages, the OpenClaw gateway, and any browser live in the remaining memory. That's one more reason not to push the GPU ceiling to the max.

Cross-referencing these benchmarks with the available configurations gives the following table. These are calculated estimates, not measurements: always check the actual allocation with ollama ps once the model is loaded.

16 GB (base M6 or M4)

Too tight for a local agent. A 7 to 9 billion model handles chat, but with 64,000 tokens of context within a limit of about 11 GB, the headroom disappears. And these small models are rarely reliable at tool calling. Keep this configuration for the API scenario.

24 GB (M6, or base M5 Pro)

The minimum for trying a local agent with a 7B to 9B model and a large context. A 14B model (about 9 GB of weights) becomes possible if you keep its context reasonable. Check this model by model.

32 GB (M6 maximum)

A 14-billion model with 64,000 tokens of context and headroom to spare. This is the most sensible configuration if you want a local agent without stepping up to the M5 Pro.

48 GB (M5 Pro)

A dense 32-billion model (about 19 GB of weights) with a large context, or an MoE with 30 to 35 billion parameters. The 307 GB/s memory bandwidth makes these models usable.

64 GB (M5 Pro maximum)

The comfortable configuration for a 35-billion MoE or a 32-billion model with a long context. A 70-billion model at Q4 (about 40 GB) loads, but leaves little room for the 64,000-token context: for that size, look at the Mac Studio instead.

#Sizing your Mac mini for OpenClaw in 5 steps

1. 01
   1. Decide where the model runs

   API, local, or API now and local later. If local is just a curiosity, go with the API and a base configuration. If it's part of the plan, the rest of these steps apply.
2. 02
   2. List your messaging channels

   If iMessage is on the list, you need a Mac and the question is settled. For Telegram, WhatsApp, Discord, or Signal alone, a Linux mini PC or a small rented server works too: compare the alternatives below before you buy.
3. 03
   3. Choose your target model size

   Start from the reliability you need for tool calling, not from the memory you have available. Plan on at least 14 billion parameters for a local agent, and 32 billion or a 30 to 35 billion MoE for more headroom. Make sure the model's maximum context window actually reaches 64,000 tokens.
4. 04
   4. Add context and system overhead, then go one tier up

   Q4_K_M weights, plus the context window, plus a few gigabytes for macOS and the gateway: the total must fit under the default GPU limit. If you're right at the limit, go with the next memory tier up. Unlike storage, you can't add it later.
5. 05
   5. Verify after installation

   Once Ollama and OpenClaw are set up, send the agent a request that uses a tool, then run ollama ps. The CONTEXT column should show your target window, and the PROCESSOR column should show 100% GPU. Also keep an eye on macOS memory pressure over several days of normal use.

# Mémoire physique installée (en octets)
sysctl hw.memsize

# Plafond GPU actuel : 0 = politique par défaut du système
sysctl iogpu.wired_limit_mb

# Pression mémoire globale de macOS
memory_pressure

# Modèle chargé : contexte alloué et répartition GPU/CPU
ollama ps

If the PROCESSOR column shows a mixed CPU/GPU split, the model and its context exceed the limit: the agent slows down and may hit timeouts. Choose a smaller model rather than cutting the context below the recommendation, because a truncated context makes the agent fail without any error message. Our guide on OpenClaw with Ollama walks you through configuring the context in Ollama step by step.

#Turning a Mac mini into an always-on OpenClaw server

A Mac mini isn't configured out of the box to run an agent day and night. A few settings prevent unpleasant surprises, whatever amount of memory you choose.

Veille

Disable system sleep in System Settings, or from the command line with pmset. A sleeping Mac no longer receives messages.

Power outage

Turn on automatic restart after a power failure so the machine comes back up on its own.

Logged-in session

The gateway installed by onboarding runs as a service in your user session, and Messages needs a logged-in session. After a restart, neither one starts until someone logs in.

Remote access

macOS Screen Sharing or SSH, over a private VPN, lets you manage the Mac without a display. Don't expose the gateway's port 18789 to the internet: by default it listens only on the machine itself, and that's exactly how it should be.

Dedicated accounts

A macOS user account reserved for the agent, a separate Apple ID for iMessage if possible, and API keys with limited permissions and budgets. The Mac mini should be a dedicated machine, not your personal computer.

# Ne jamais mettre le système en veille (secteur)
sudo pmset -a sleep 0

# Redémarrer automatiquement après une coupure de courant
sudo pmset -a autorestart 1

# Vérifier les réglages d'alimentation appliqués
pmset -g

# Diagnostiquer l'installation OpenClaw
openclaw doctor

# Repérer les réglages de sécurité dangereux
openclaw security audit

OpenClaw's commands and options change from one version to the next. If one isn't recognized, check openclaw --help and the official documentation, which is authoritative.

#Alternatives to the Mac mini for OpenClaw

The Mac mini is just one option among others. Depending on your channels and your model, another machine may be a better fit.

Small rented server (VPS)

A good fit if you use an API and don't need iMessage: nothing to buy, and the machine is always online. The Docker installation guide explains how to isolate it, because a VPS has a public address and a port that's published by mistake is exposed to the entire Internet.

Linux mini PC or old PC

Enough for the gateway with an API. For a local model, a typical mini PC's system memory isn't accessible to the GPU the way it is on a Mac; only mini PCs with high-capacity unified memory are in the same league.

PC with a graphics card

For a local agent, a RTX 3060 12GB or a RTX 4070 12GB can load a 14-billion model, and a RTX 4090 24GB a 32-billion model, with a tighter context margin than a 48 or 64 GB Mac. Power draw and noise are significantly higher for a service that runs around the clock.

A Mac you already own

An old M2 Mac mini or an unused Apple Silicon laptop is enough for the API scenario, and it's often the most affordable way to keep iMessage. Avoid installing the agent on it if it's your main computer.

Mac Studio

For models with 70 billion parameters and up with a large context, beyond what the Mac mini M5 Pro's 64 GB allows.

#What this guide doesn't cover

We didn't run any tests of OpenClaw on a Mac mini for this guide, so it contains no generation speeds, agent response times, or measured power consumption. The memory tiers are calculated from Q4_K_M weight sizes, Ollama's context recommendation, and the GPU cap reported by llama.cpp users. They're meant to help you avoid buying the wrong configuration, not to predict results.

The lineup specs come from Apple's August 2026 announcement and its tech specs. Prices for each configuration aren't listed: they vary by date and reseller, and only the Apple configurator is authoritative when you order. Finally, OpenClaw evolves very quickly: iMessage integrations, Node.js requirements, and commands may have changed since this was written. If anything differs, the official documentation takes precedence.

#Go further

Once you've chosen your configuration, these guides take over: choosing a model based on your Mac mini's memory, fine-tuning Apple Silicon, then installing OpenClaw and connecting it to Ollama.