---
title: "Which local models can run OpenClaw on your Mac? We tested 6"
description: "We tested 6 open-weight models with OpenClaw on a Mac: what runs, what breaks, and the RAM you need. 24GB to experiment, 32GB for everyday use."
updated: 2026-08-17
canonical: https://holaclaw.ai/blog/running-openclaw-with-local-models
---

> **TL;DR** (August 2026): You can run OpenClaw with local open-weight models on a Mac today. We recommend 24GB of unified memory as the minimum to run and experiment with them, and 32GB for everyday use. Qwen 3.6 27B, Qwen 3.8 27B, and Muse Glimmer 30B are the models we would pick today.

In the last few months, we saw many changes in the industry. **[GLM 5.2](https://z.ai/blog/glm-5.2), [MiniMax M3](https://www.minimax.io/blog/minimax-m3), and similar open models were released**, reducing the gap between top-tier models such as Claude Opus and GPT 5.X and open-weight models. And it continues: [GLM 5.3](https://z.ai/blog/glm-5.3) is around the corner. Meta released [Muse Glimmer](/blog/muse-glimmer-on-mac), a 30B model built for always-on local agent workloads. Now **you can run a very capable model locally** with end-user hardware.

In addition to that, **access to the most powerful cloud models keeps changing**. Anthropic and OpenAI initially released their top models ([Sol](https://openai.com/index/previewing-gpt-5-6-sol/) and [Mythos](https://www.anthropic.com/news/claude-fable-5-mythos-5)) to a limited set of partners, and only later opened them to users. These decisions are not in your hands: availability, pricing, and usage rules can change at any time. This uncertainty caused a spike in interest in **local models as a way to own the entire agentic stack, from the agent harness to the model powering its intelligence**.

At [HolaClaw](/), we firmly believe that local models are part of the future. The entry bar is still high due to the rising prices in hardware, but today you can run OpenClaw and similar agents using open-weight models locally.

We spent quite a bit of time tweaking and working with open-weight models, and this is what we found.

## What hardware do you need to run local models?

To use an AI model locally you need three main resources: **memory, bandwidth, and computational power.** The first stores the model data (weights) in a very fast location. The second moves the data quickly between the store and the chipset that will process it. The third reads this data and runs all the calculations against it to produce the output.

You have a wide variety of options, from a dedicated GPU like Nvidia devices to TPUs and unified memory, and all the different variations. However, all of them have one thing in common: they are increasingly expensive.

So, what can you run on the hardware you already own? Like a MacBook or a Mac mini?

Apple devices come with an embedded GPU and unified memory. That's convenient, but it limits the memory you can dedicate to running AI models, as you are sharing it with the rest of your system. Depending on your RAM capacity, you can run different open models.

There are a wide variety of modern open models, such as [Qwen 3.6](https://qwen.ai/blog?id=qwen3.6-27b), Qwen 3.5, [Gemma 4](https://ai.google.dev/gemma/docs/core), and [Muse Glimmer](/blog/muse-glimmer-on-mac). The smallest versions of these models can run on Mac devices with as little as 8GB. However, **our recommendation is 24GB as the minimum to run and experiment with agentic tools like OpenClaw, and 32GB for everyday use.** Smaller models than that will struggle to complete basic tasks and won't be able to complete the complex ones.

For example, we are experimenting with really small models such as [LFM2 2.6B](https://huggingface.co/LiquidAI/LFM2-2.6B) from [Liquid AI](https://www.liquid.ai/). It's a very promising model, but due to the amount of information that OpenClaw provides to the model, sometimes it gets stuck processing the data and calling the tools.

## How well do small models handle OpenClaw?

**For generic tasks, the bigger the model is, the better the results you get**. That's a simple rule. Small models can run fast, but their capacity is limited. The model itself has less knowledge, and following complex rules becomes a difficult task.

Apps like OpenClaw provide a lot of context information and guidance for the models. For example:

- How they should behave
- The tools they can access
- How to interact with the user

In OpenClaw v2026.6.1, **the first message includes around 19K tokens** (we measured it in our [Token Counter](/tools/token-counter) tool). You can tweak the configuration to reduce it, but by default you send that amount of data. **This is a lot of information for a small model**.

> We will write a separate article on the technical details of how we measured this and the improvements we introduced in HolaClaw to reduce it.

The prompt size is the first problem you will encounter. On your device, this will take time to process. Sending a plain new message to a local model is not the same as sending all that information at once. In our tests, loading the first OpenClaw message took 90 to 120 seconds on a MacBook Air M4 for models like Qwen 3.5 and Gemma 4. After that, the agent becomes responsive, replying in about 5 seconds.

> We always try to test the models in the most basic hardware we own. In this case, part of the limitation is thermal management, as MacBook Air laptops are fanless devices. You can achieve better results with a Mac mini or a MacBook Pro.

A quick way to get a feel for these models is chatting with them in a tool like [Ollama](https://ollama.com) or [Llama](https://llama.app). Keep in mind that chatting with a model is not the same as using it with OpenClaw: the agent sends a much bigger context, so a model that feels fast in plain chat can still take minutes to process OpenClaw's first message.

Another issue we encountered is that small models tend to be very literal, each of them in their own way. A model might "prioritize" certain rules over others, causing totally different behaviors across different models. For example, Gemma 4 stopped responding because it misunderstood a rule we introduced. Other times, they use the wrong tool.

Fortunately, all this is improving. Small models are getting more and more capable. They also come with the benefit of privacy and control: you don't share any data with external providers and you keep the inference under control.

But the question is, can you use local models today with OpenClaw?

## Which local models work with OpenClaw?

Thanks to modern open-weight models, you can definitely run them to power your OpenClaw assistant! Unfortunately, we found that there's a bare minimum today to do real work. Many models can start the conversation, complete the configuration, and interact naturally with you. However, they start misbehaving when you ask for more complex tasks or the conversation grows.

We tested different models in HolaClaw to see what the experience is like using them. This is what we found:

| Model | Minimum RAM | Result | Suitability |
| :---- | :---- | :---- | :---- |
| Gemma 4 E2B | 8GB | The model communicates properly and in character, but it struggles sometimes to complete the initialization process. It can complete some very basic tasks. | ⭐ |
| Gemma 4 E4B | 16GB | The model communicates properly and in character. It completes the initialization process consistently. It completes some basic tasks, but enters a loop when doing more complex tasks, such as navigating over websites. | ⭐⭐ |
| Qwen 3.5 9B | 12GB | Similar experience as Gemma 4 E2B. | ⭐ |
| Qwen 3.6 27B | 32GB | This model surprised us. We define it as the bare minimum you can use. It communicates properly, completes the configuration process, and works on most of the tasks we tested. | ⭐⭐⭐ |
| Qwen 3.8 27B | 32GB | Early results match Qwen 3.6 27B: it communicates properly, completes the configuration process, and works on most of the tasks we tested. We are still testing it. | ⭐⭐⭐ |
| Muse Glimmer 30B | 32GB | Built for agent workloads. It completes the initialization process and worked on the tasks we tested. Generation is slow on base M chips (we measured it in [our benchmark](/blog/muse-glimmer-on-mac)). | ⭐⭐⭐ |

> Here we are talking about *quantized* models. Quantization is a technique to reduce the size and memory requirements to run the model. The tradeoff is that the model becomes "less intelligent" (reduced precision) than the original version.
> <br><br>
> The tradeoff is totally worth it, as you can now run much more powerful models without requiring more expensive hardware. You might find that the Qwen 3.6 you run locally is not the same as the cloud ones, although several AI cloud providers use quantized models too.

HolaClaw supports [local models](/docs/ai-providers/local-models) out of the box. If you want to try one today, our tutorial on [using Muse Glimmer locally with OpenClaw](/docs/tutorials/use-muse-glimmer-with-openclaw) covers the whole setup.

**For us, 24GB is the minimum to run and experiment with local models, and we recommend 32GB for everyday use.** You will still find these models more error-prone than the powerful models you can find in AI cloud providers. To compete with them, smaller models can iterate until they complete a task. They only need a way to validate the result, as iterating is much more powerful than a one-shot response.

However, we need to be clear: agents tend to work much better with more powerful models today, especially if you are looking to ask for complex tasks. **But the gap is narrowing**.

## What's next for local models?

What we expect for the future (meaning a few months in the AI era) is an increase in local inference. People and companies are getting more interested in how they can run and operate their models for cost and privacy.

Not all tasks must be done using the most powerful models. You can experiment by mixing more capable models for organization and complex tasks, while reducing costs and time using local models for simple things.

Also, hardware is evolving. Prices will still be high in the short term, but competitiveness will bring new components or ways to reuse existing ones. If you want to experiment with local models, do not wait. Start playing with them on the devices you have, and let us know your experience.

On our side, we will continue testing small models, using them, and optimizing HolaClaw so you get the best experience regardless of the model you choose! If you want to try them with OpenClaw, [download HolaClaw](/download) and pick a local model when you create your assistant.