Wer Modelle lokal ausführt, braucht keine API-Schlüssel, zahlt keine Nutzungsgebühren und schickt keinen proprietären Code an fremde Server. Dafür sind die Antworten langsamer und bei schwierigen Problemen ist die Qualität geringer. Ob sich dieser Kompromiss lohnt, hängt davon ab, was du machst.

Wenn du über eine Suche nach „openclaw local model” oder „openclaw local llm” hier gelandet bist, starte einfach: Nutze Gemma 4 8B oder Qwen3.6 9B auf 16-GB-Rechnern, Qwen3.6 27B auf GPUs mit mindestens 24 GB (einer einzelnen RTX 5090 oder einem M5 Pro) und behalte einen Cloud-Fallback für Aufgaben, bei denen lokale Modelle nicht weiterkommen. Lokales OpenClaw ist inzwischen gut. Aber es ist keine Magie.

Zwei Dinge haben die Ausgangslage 2026 grundlegend verändert. Das Qwen3.6-Release am 22. April brachte ein Dense-Coding-Modell mit 27B Parametern, das beim SWE-bench ein 397B-MoE schlägt. Und Apples M5 Max (angekündigt im März 2026) bringt 128 GB Unified Memory und Neural Accelerators in jeden GPU-Kern – Modelle der 70B-Klasse laufen damit auf einem Laptop. Da Ollama inzwischen offizieller OpenClaw-Provider ist, ist das Setup außerdem einfacher als je zuvor.

Modell-Ranking

Aktuelle lokale Modelle für Coding-Aufgaben in OpenClaw, sortiert nach SWE-bench-Verified-Ergebnissen, Tool-Calling-Zuverlässigkeit und realer Agent-Performance:

ModellParameterAktivierungVRAM-BedarfSWE-benchGeschwindigkeit (RTX 5090)Ideal für
Qwen3.6 27B27B27B (Dense)18 GB+77,2 %~70 t/sBestes Verhältnis aus Qualität und Größe für Coding
Qwen3 Coder Plus72B72B (Dense)48 GB+70,6 %~30 t/sSchwerste Coding-Aufgaben, vollständige Agent-Loops
Qwen3.6 35B-A3B35B3B (MoE)16 GB+—~180 t/sGeschwindigkeitskritische Arbeit, hoher Durchsatz
Qwen3.6 9B9B9B (Dense)8 GB+—~186 t/sEinsteiger-Hardware, einfache Aufgaben
Llama 3.3 70B70B70B (Dense)Dual-GPU—~27 t/s (2× 5090)Allgemeines Coding, gutes Instruction-Following
gpt-oss 20B21B3,6B (MoE)16 GB—~160 t/sBeste Wahl für 16 GB, einstellbarer Reasoning-Aufwand
Laguna XS 2.133B3B (MoE)24 GB+—schnell (MoE)Agentisches Coding, Tool-Calling-Loops
Gemma 4 8B8B8B (Dense)8 GB+—~150 t/sDatenschutzorientiert, leichtgewichtige Setups
Qwen3 32B32B32B (Dense)24 GB+—~60 t/sSolider Allrounder, breit getestet

Qwen3.6 27B ist das neue Highlight. 77,2 % im SWE-bench Verified, 59,3 % im Terminal-Bench 2.0 – exakt gleichauf mit Claude Opus 4.5 – und es läuft auf 18 GB VRAM. Dass ein Dense-Modell mit 27B Parametern beim Coding ein 397B-MoE schlägt, ist das Ergebnis von Architekturänderungen im 3.6-Release: Gated Delta Networks plus gezieltes Post-Training auf echten gemergten PRs.

Das 35B-A3B-MoE ist der Joker. Pro Forward Pass werden nur 3B Parameter aktiviert, daher läuft es auf einer einzelnen RTX 5090 mit ~180 t/s. Bei schweren Problemen ist die Qualität geringer als beim 27B-Dense-Modell, aber bei Dateizugriffen, Boilerplate-Generierung und einfachen Änderungen fühlt es sich wie eine Cloud-API an.

Drei neuere Modelle verdienen Aufmerksamkeit. gpt-oss 20B ist in der Community der Konsens für 16-GB-Maschinen – ein kleines MoE mit einstellbarem Reasoning-Aufwand. Laguna XS 2.1 (Poolside) ist ein MoE mit 33B Gesamt- und 3B aktiven Parametern, das speziell für agentische Coding-Loops entwickelt wurde. Und Kimi K2.7 Code bringt die frontiernahe K2-Reihe von Moonshot für alle mit 48-GB+-Setups zu Ollama – das vollständige Open-Weight-Modell Kimi K3 erscheint Ende Juli für alle, die Server-Hardware betreiben.

Hardware-Anforderungen

Die Qualität lokaler Modelle hängt von der Modellgröße ab, und die Modellgröße bestimmt den Hardwarebedarf. Die folgenden Stufen gehen von Hardware aus dem Jahr 2026 aus – auf NVIDIA-Seite die RTX-50-Serie, auf Apple-Seite die M5-Generation.

8–16 GB VRAM (Einsteigerklasse)

RTX 5060 / 5070 oder 16 GB Unified Memory (M5-Basis, M5 Pro Einstieg). Das reicht für Qwen3.6 9B und das 35B-A3B-MoE. Das 9B bewältigt einfache Aufgaben und Code-Zusammenfassungen mit ~186 t/s auf einer 5090; auf einer 5070 sind ~120 t/s zu erwarten. Das 35B-A3B braucht deutlich weniger Speicher, als die Parameterzahl vermuten lässt, weil pro Durchlauf nur 3B Parameter aktiviert werden.

Modelle: Qwen3.6 9B, Qwen3.6 35B-A3B, Gemma 4 8B

18–32 GB VRAM (empfohlen)

Eine einzelne RTX 5090 (32 GB GDDR7, 1.792 GB/s) oder 36–64 GB Unified Memory (M5 Pro / M5 Max Basis). Ab hier werden lokale Modelle für den realen Einsatz alltagstauglich. Qwen3.6 27B läuft bequem auf 18 GB, und sein SWE-bench-Wert (77,2 %) kann mit Cloud-Modellen mithalten, für die du pro Token zahlen würdest.

Der Bandbreitensprung der RTX 5090 gegenüber der 4090 (1.792 GB/s statt 1.008 GB/s, ein Plus von 78 %) ist für die Inferenz die entscheidende Zahl, nicht die reinen FLOPS. Die Token-Generierung ist durch die Speicherbandbreite limitiert. Eine einzelne 5090 erzeugt rund 186 t/s bei Qwen 8B und 124 t/s bei Modellen der 14B-Klasse.

Modelle: Qwen3.6 27B, Qwen3 32B, Qwen3.6 Plus (sofern es passt)

48 GB+ effektiver Speicher (Premium)

Dual RTX 5090 (zusammen 64 GB) oder 96–128 GB Unified Memory im M5 Max. Hier sind Qwen3 Coder Plus und Llama 3.3 70B zu Hause.

Zwei Wege:

  • Dual-5090-Rig: 27 t/s bei Llama 70B Q4_K_M mit vLLM-Tensor-Parallelismus – damit bist du fast auf H100-Niveau, zu einem Bruchteil der Kosten. Die beste Wahl für Desktops, in die zwei Karten passen.
  • MacBook Pro mit M5 Max und 128 GB: Ein 70B-Modell in Q4_K_M (~40 GB auf der Festplatte) lädt vollständig in den Unified Memory und lässt noch reichlich Platz für Kontext. Apples Neural Accelerators, die in jeden GPU-Kern integriert sind, beschleunigen die Prompt-Verarbeitung um das 3,3- bis 4-Fache gegenüber dem M4 Max; die kontinuierliche Textgenerierung liegt bei etwa 18–25 t/s. Der Preis dafür ist die Portabilität: Dieses Setup ist das einzige, das in einen Rucksack passt.

Modelle: Qwen3 Coder Plus, Llama 3.3 70B, Qwen3.6 Plus in voller Präzision

Der M5 Max mit 128 GB Unified Memory ist der neue Sweet Spot für ernsthafte lokale Arbeit auf einem Laptop. Apples MLX-Framework wird inzwischen mit Neural-Accelerator-Unterstützung ausgeliefert, sodass GPU und Neural Engine bei jedem Forward Pass parallel arbeiten statt nacheinander.

Deine Hardware passt in keine dieser Stufen? haimaker stellt OpenClaw einen einzigen Endpunkt für das Cloud-Routing bereit. So kannst du lokale Modelle dort nutzen, wo sie funktionieren, und bei Aufgaben, die sie nicht schaffen, auf Cloud-Modelle zurückgreifen.

HAIMAKER FÜR CLOUD-ROUTING TESTEN

Ollama einrichten

Ollama ist der einfachste Weg, lokale Modelle zu betreiben. Installieren, Modell pullen, fertig – auf localhost läuft eine OpenAI-kompatible API.

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

# Pull a model (pick one based on your hardware)
ollama pull qwen3.6:27b          # Best quality, needs 18GB+ VRAM
ollama pull qwen3.6:35b-a3b      # Fast MoE model, runs on 16GB
ollama pull qwen3.6:9b           # Lightweight, runs on 8GB
ollama pull qwen3-coder-plus     # Premium, needs 48GB+ or 96GB unified

Ollama stellt standardmäßig eine API unter http://localhost:11434 bereit.

Tipp aus r/LocalLLaMA: Mehrere Nutzer berichten, dass sich die Performance bei den 27B- und größeren Modellen verbessert, wenn sie von Ollama direkt auf llama.cpp wechseln. Ollama bietet Komfort, llama.cpp dagegen mehr Kontrolle über Quantisierung und Speicherbelegung. Starte mit Ollama – und wechsle zu llama.cpp, wenn du an Performance-Grenzen stößt.

OpenClaw-Konfiguration

Da Ollama jetzt ein offizieller Provider ist, ist das Setup unkompliziert. Führe den Onboarding-Assistenten aus:

openclaw onboard --auth-choice ollama

Oder füge Ollama manuell in ~/.openclaw/openclaw.json hinzu:

{
  models: {
    providers: {
      ollama: {
        baseUrl: "http://localhost:11434/v1",
        api: "openai-completions",
        models: [
          {
            id: "qwen3.6:27b",
            name: "Qwen3.6 27B",
            reasoning: false,
            contextWindow: 131072,
            maxTokens: 8192
          }
        ]
      }
    }
  },
  agents: {
    defaults: {
      model: { primary: "ollama/qwen3.6:27b" },
      models: {
        "ollama/qwen3.6:27b": { alias: "qwen-local" }
      }
    }
  }
}

Wechsle zu deinem lokalen Modell:

/model qwen-local

Was lokale Modelle gut können

Nach mehreren Wochen mit lokal laufendem Qwen3.6 27B lässt sich festhalten:

  • Code lesen und zusammenfassen. Du fragst, was eine Funktion macht, und bekommst eine solide Antwort. Nicht so nuanciert wie Sonnet 4.6, aber gut genug, um sich in unbekanntem Code zurechtzufinden.
  • Codegenerierung für gängige Muster. Boilerplate, CRUD-Operationen, Konfigurationsdateien, Testgerüste. In den meisten Fällen ist der Code bereits im ersten Versuch funktionsfähig. Das 3.6-Release wurde auf echten gemergten PRs nachtrainiert, und das sieht man an der Qualität der Diffs.
  • Dateioperationen und einfache Refactorings. Dateien auflisten, nach Mustern suchen, Variablen innerhalb einer Datei umbenennen. Mechanische Aufgaben, die kein tiefes Nachdenken erfordern.
  • Agentisches Tool Calling. Qwen3.6 hat die Messlatte bei der Function-Calling-Zuverlässigkeit höher gelegt – der Wert von 59,3 % im Terminal-Bench 2.0 entspricht exakt Claude Opus 4.5. Für den Tool-Loop von OpenClaw bedeutet das weniger Fehler der Art „falsche Funktion mit falschen Argumenten aufgerufen”.

Wo lokale Modelle Schwächen zeigen

  • Refactorings über mehrere Dateien. Alles, was Kontext über mehr als fünf Dateien erfordert, wird unzuverlässig. Das Modell verliert den Faden oder ändert Dinge inkonsistent. Cloud-Modelle mit Kontextfenstern von 200.000+ Tokens sind hier weiterhin im Vorteil, auch wenn Qwen3.6 die Lücke verkleinert hat.
  • Komplexes Debugging. Wenn der Bug ein Verständnis über mehrere Abstraktionsebenen verlangt, schlagen lokale Modelle oberflächige Fixes vor, obwohl das Problem tiefer liegt. Claude Opus 4.8 schneidet auf SWE-bench Verified noch etwa 11 Punkte besser ab als Qwen3.6 27B, Claude Fable 5 etwa 18.
  • Tempo von Dense-Modellen auf älterer Hardware. Das 27B-Modell erreicht auf einer einzelnen RTX 5090 etwa 70 Token/s, auf einem M5 Max rund 22 t/s. Wer noch eine 3090 oder 4090 nutzt, muss eher mit 30–40 t/s rechnen. Ausnahme: das 35B-A3B-MoE mit über 180 t/s.
  • Sehr langer Kontext. Qwen3.6 unterstützt theoretisch bis zu 256K Tokens, aber auf Consumer-Hardware lässt die Inferenzqualität jenseits von 32K nach. Halte contextWindow in deiner Konfiguration realistisch.

Der Hybrid-Ansatz

Die meisten, die lokale Modelle ausprobieren, landen am Ende bei einem Hybrid-Setup: lokal für die Routineaufgaben, Cloud für die schwierigen Fälle.

{
  agents: {
    defaults: {
      model: {
        primary: "ollama/qwen3.6:27b",
        thinking: "anthropic/claude-sonnet-4-6-20260514"
      }
    }
  }
}

Das lokale Modell übernimmt Dateizugriffe, einfache Änderungen und Boilerplate – vielleicht 60–70 % einer typischen Coding-Session. Sonnet kümmert sich um Debugging, Architekturentscheidungen und die Arbeit über mehrere Dateien. Deine API-Rechnung sinkt auf wenige Dollar pro Tag statt 20–50 US-Dollar.

Wenn du weißt, dass eine Aufgabe mehr Leistung braucht, wechsle manuell:

/model sonnet

Oder nutze den haimaker Auto-Router, um das Routing automatisch zu übernehmen. Der Auto-Router erkennt die Komplexität einer Aufgabe und schickt schwierige Probleme automatisch an Cloud-Modelle – du musst also nicht mehr selbst entscheiden, wann ein Wechsel sinnvoll ist.

Fehlerbehebung

Modell lädt langsam oder stürzt ab. Wahrscheinlich ist der Speicher knapp. Versuche eine kleinere Quantisierung: ollama pull qwen3.6:27b-q4_K_M verbraucht weniger Speicher und kostet nur wenig Qualität. Q4_K_M ist für die meisten Nutzer der Sweet Spot – minimaler Qualitätsverlust, deutlich geringerer Speicherbedarf.

Tool Calls schlagen fehl. Setze in deiner Modellkonfiguration "reasoning": false und bleib bei Qwen3.6-Modellen. Sie verarbeiten das Tool-Calling-Format von OpenClaw zuverlässiger als Mistral oder ältere Llama-Modelle. Wenn Tool Calls weiter fehlschlagen, bring Ollama auf den neuesten Stand. Die offizielle Provider-Integration hat mehrere Edge-Cases behoben.

Fehler beim Kontextfenster. Setze contextWindow in deiner Konfiguration auf einen passenden Wert. Für Qwen3.6-Modelle ist 131072 (128K) auf Hardware mit 24 GB+ VRAM ein sicherer Standard (eine einzelne RTX 5090 verkraftet das problemlos). Auf 16-GB-Hardware bleib bei 32768, um Qualitätseinbußen zu vermeiden.

Langsame Generierung. Wenn du mit dem 27B-Modell auf einer 5090 unter 40 t/s oder auf einem M5 Max unter 18 t/s liegst, prüfe, ob andere Prozesse deine GPU beanspruchen. Schließe Browser-Tabs mit WebGL oder Video. Auf dem Mac zeigt die Aktivitätsanzeige → GPU-Verlauf, welche Prozesse um den Unified Memory konkurrieren. M5-Nutzer sollten außerdem sicherstellen, dass Ollama das MLX-Backend nutzt (v0.21+). Der Geschwindigkeitsunterschied zwischen dem reinen Metal- und dem MLX-Pfad beträgt bei der Prompt-Verarbeitung ungefähr Faktor 2.

HAIMAKER FÜR CLOUD-ROUTING TESTEN

Preisvergleiche für Modelle findest du unter Günstige Modelle für OpenClaw. Wie du Token-Kosten bei Cloud-Modellen um 96 % senkst, zeigt Kosten um 96 % senken mit QMD.