Meilleur LLM local pour OpenClaw 2026 : 7 modèles Ollama classés

Exécuter des modèles en local, c’est se passer de clés API, de factures d’utilisation et de l’envoi de code propriétaire vers les serveurs d’un tiers. Cela implique aussi des réponses plus lentes et une qualité moindre sur les problèmes difficiles. Si ce compromis en vaut la peine dépend de ce que vous faites.

Si vous arrivez ici après avoir cherché « openclaw local model » ou « openclaw local llm », commencez par le plus simple : prenez Gemma 4 8B ou Qwen3.6 9B sur les machines à 16 Go, Qwen3.6 27B sur les GPU de 24 Go ou plus (une seule RTX 5090 ou un M5 Pro), et gardez un modèle cloud de secours pour les tâches où les modèles locaux restent bloqués. OpenClaw en local est aujourd’hui tout à fait utilisable — mais ce n’est pas magique.

Deux choses ont changé la donne en 2026. La sortie de Qwen3.6 le 22 avril a introduit un modèle dense de 27B orienté programmation qui bat un MoE de 397B sur SWE-bench. Et le M5 Max d’Apple (annoncé en mars 2026) embarque 128 Go de mémoire unifiée et des Neural Accelerators dans chaque cœur GPU — des modèles de classe 70B tournent désormais sur un ordinateur portable. Avec Ollama devenu un fournisseur officiel d’OpenClaw, la configuration n’a jamais été aussi simple.

Classement des modèles

Modèles locaux actuels classés pour le développement avec OpenClaw, à partir des scores SWE-bench Verified, de la fiabilité des appels d’outils et des performances agentiques réelles :

Modèle	Paramètres	Activation	VRAM nécessaire	SWE-bench	Vitesse (RTX 5090)	Idéal pour
Qwen3.6 27B	27B	27B (dense)	18 Go ou plus	77,2 %	~70 t/s	Meilleur rapport qualité/taille pour la programmation
Qwen3 Coder Plus	72B	72B (dense)	48 Go ou plus	70,6 %	~30 t/s	Tâches de programmation les plus lourdes, boucles d’agent complètes
Qwen3.6 35B-A3B	35B	3B (MoE)	16 Go ou plus	—	~180 t/s	Travail critique en vitesse, débit élevé
Qwen3.6 9B	9B	9B (dense)	8 Go ou plus	—	~186 t/s	Matériel d’entrée de gamme, tâches simples
Llama 3.3 70B	70B	70B (dense)	double GPU	—	~27 t/s (2× 5090)	Programmation générale, bon suivi d’instructions
gpt-oss 20B	21B	3,6B (MoE)	16 Go	—	~160 t/s	Meilleur choix sur 16 Go, effort de raisonnement ajustable
Laguna XS 2.1	33B	3B (MoE)	24 Go ou plus	—	rapide (MoE)	Programmation agentique, boucles d’appels d’outils
Gemma 4 8B	8B	8B (dense)	8 Go ou plus	—	~150 t/s	Priorité à la confidentialité, configurations légères
Qwen3 32B	32B	32B (dense)	24 Go ou plus	—	~60 t/s	Bon généraliste, largement testé

Qwen3.6 27B est la nouvelle référence. 77,2 % sur SWE-bench Verified, 59,3 % sur Terminal-Bench 2.0 (à égalité exacte avec Claude Opus 4.5), et il tourne sur 18 Go de VRAM. Si un modèle dense de 27B bat un MoE de 397B en programmation, c’est grâce aux changements architecturaux de la version 3.6 — Gated Delta Networks et un post-entraînement ciblé sur de vraies PR.

Le MoE 35B-A3B est le joker. Seuls 3B paramètres s’activent à chaque inférence, ce qui lui permet de tourner à ~180 t/s sur une seule RTX 5090. La qualité est inférieure à celle du 27B dense sur les problèmes difficiles, mais pour la lecture de fichiers, la génération de code boilerplate et les modifications simples, on se croirait sur une API cloud.

Trois nouveaux arrivants méritent l’attention. gpt-oss 20B est devenu le choix de référence de la communauté pour les machines à 16 Go — un petit MoE doté d’un effort de raisonnement ajustable. Laguna XS 2.1 (Poolside) est un MoE 33B/3B actifs conçu spécialement pour les boucles de programmation agentique. Et Kimi K2.7 Code apporte la lignée K2 de Moonshot, proche de l’état de l’art, sur Ollama pour les configurations de 48 Go ou plus — la version complète à poids ouverts Kimi K3 étant, elle, attendue fin juillet pour ceux qui disposent de matériel de classe serveur.

Exigences matérielles

La qualité des modèles locaux augmente avec leur taille, et la taille détermine les besoins matériels. Les paliers ci-dessous reposent sur le matériel 2026 — série RTX 50 côté NVIDIA, M5 côté Apple.

8–16 Go de VRAM (entrée de gamme)

RTX 5060 / 5070 ou 16 Go de mémoire unifiée (M5 de base, M5 Pro d’entrée de gamme). De quoi faire tourner Qwen3.6 9B et le MoE 35B-A3B. Le 9B gère les tâches simples et la synthèse de code à ~186 t/s sur une 5090 ; comptez ~120 t/s sur une 5070. Le 35B-A3B utilise bien moins de mémoire que son nombre de paramètres ne le laisse penser, car seuls 3B paramètres s’activent à chaque inférence.

Modèles : Qwen3.6 9B, Qwen3.6 35B-A3B, Gemma 4 8B

18–32 Go de VRAM (recommandé)

Une seule RTX 5090 (32 Go GDDR7, 1 792 Go/s) ou 36 à 64 Go de mémoire unifiée (M5 Pro / M5 Max de base). C’est à partir de ce niveau que les modèles locaux deviennent réellement utilisables pour du vrai travail. Qwen3.6 27B tourne confortablement sur 18 Go et son score SWE-bench (77,2 %) rivalise avec des modèles cloud que vous paieriez au token.

Le gain de bande passante de la RTX 5090 par rapport à la 4090 (1 792 Go/s contre 1 008 Go/s, soit 78 % de hausse) est le chiffre pertinent pour l’inférence, pas les FLOPS bruts. La génération de tokens est avant tout limitée par la bande passante mémoire, et une seule 5090 génère environ 186 t/s sur Qwen 8B et 124 t/s sur les modèles de classe 14B.

Modèles : Qwen3.6 27B, Qwen3 32B, Qwen3.6 Plus (si la configuration le permet)

48 Go ou plus de mémoire effective (premium)

Deux RTX 5090 (64 Go au total) ou 96 à 128 Go de mémoire unifiée sur M5 Max. C’est la catégorie de Qwen3 Coder Plus et de Llama 3.3 70B.

Deux options :

• Configuration double 5090 : 27 t/s sur Llama 70B Q4_K_M avec parallélisme tensoriel vLLM — quasiment le niveau d’une H100 pour une fraction du coût. Idéal pour un PC fixe capable d’accueillir deux cartes.
• MacBook Pro M5 Max 128 Go : un modèle 70B Q4_K_M (~40 Go sur disque) se charge entièrement en mémoire unifiée avec de la marge pour le contexte. Les Neural Accelerators d’Apple intégrés dans chaque cœur GPU traitent les prompts 3,3 à 4 fois plus vite que le M4 Max, et la génération en régime stable se situe autour de 18 à 25 t/s. La contrepartie, c’est la portabilité : c’est la seule configuration qui tient dans un sac à dos.

Modèles : Qwen3 Coder Plus, Llama 3.3 70B, Qwen3.6 Plus pleine précision

Le M5 Max avec 128 Go de mémoire unifiée est le nouveau point d’équilibre pour du travail local sérieux sur ordinateur portable. Le framework MLX d’Apple intègre désormais le support des Neural Accelerators, ce qui signifie que le GPU et le Neural Engine travaillent en parallèle sur chaque passe avant, plutôt que l’un ou l’autre.

Configuration d’Ollama

Ollama est le moyen le plus simple d’exécuter des modèles locaux. Installez-le, pull un modèle, et vous disposez d’une API compatible OpenAI sur localhost.

# 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 expose une API sur http://localhost:11434 par défaut.

Astuce de r/LocalLLaMA : plusieurs utilisateurs signalent de meilleures performances en passant d’Ollama à llama.cpp directement pour les modèles de 27B et plus. Ollama simplifie la vie, mais llama.cpp donne plus de contrôle sur la quantification et l’allocation de la mémoire. Commencez par Ollama — passez à llama.cpp si vous vous heurtez à des limites de performance.

Configuration d’OpenClaw

Puisqu’Ollama est désormais un fournisseur officiel, la configuration est simple. Lancez l’assistant d’onboarding :

openclaw onboard --auth-choice ollama

Ou ajoutez Ollama manuellement dans ~/.openclaw/openclaw.json :

{
  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" }
      }
    }
  }
}

Basculez vers votre modèle local :

/model qwen-local

Ce que les modèles locaux gèrent bien

Après avoir utilisé Qwen3.6 27B en local pendant plusieurs semaines, voici ce qui tient la route :

• Lecture et synthèse de code. Demandez-lui ce que fait une fonction et vous obtenez une réponse solide. Pas aussi nuancé que Sonnet 4.6, mais suffisant pour naviguer dans des bases de code inconnues.
• Génération de code pour les patterns courants. Boilerplate, opérations CRUD, fichiers de configuration, scaffolding de tests. Il écrit du code fonctionnel du premier coup dans la plupart des cas. La version 3.6 a été post-entraînée sur de vraies PR fusionnées, et cela se voit dans la qualité des diffs.
• Manipulation de fichiers et refactorisations simples. Lister des fichiers, rechercher des patterns, renommer des variables dans un fichier. Des tâches mécaniques qui ne demandent pas de raisonnement profond.
• Appels d’outils agentiques. Qwen3.6 a relevé la barre en matière de fiabilité des appels de fonctions — Terminal-Bench 2.0 à 59,3 % égale exactement Claude Opus 4.5. Pour la boucle d’outils d’OpenClaw, cela se traduit par moins d’erreurs du type « le modèle a appelé la mauvaise fonction avec les mauvais arguments ».

Là où les modèles locaux montrent leurs limites

• Refactorisations multi-fichiers. Tout ce qui exige de conserver le contexte sur plus de 5 fichiers devient peu fiable. Le modèle perd le fil ou produit des modifications incohérentes. Les modèles cloud dotés de fenêtres de contexte de 200K ou plus gardent ici un avantage, même si l’écart s’est réduit avec Qwen3.6.
• Débogage complexe. Si le bug nécessite de raisonner à travers plusieurs couches d’abstraction, les modèles locaux proposent des corrections superficielles alors que le problème est plus profond. Claude Opus 4.8 bat encore Qwen3.6 27B d’environ 11 points sur SWE-bench Verified, et Claude Fable 5 d’environ 18 points.
• Vitesse des modèles denses sur du matériel plus ancien. Le modèle 27B tourne à environ 70 tokens/s sur une seule RTX 5090 et à ~22 t/s sur un M5 Max. Si vous êtes encore sur une 3090 ou une 4090, attendez-vous plutôt à 30-40 t/s. (Le MoE 35B-A3B à 180+ t/s fait exception.)
• Contexte très long. Qwen3.6 supporte jusqu’à 256K tokens en théorie, mais la qualité d’inférence se dégrade sur le matériel grand public au-delà de 32K. Définissez contextWindow à une valeur réaliste dans votre configuration.

L’approche hybride

La plupart des personnes qui essaient les modèles locaux finissent par adopter une configuration hybride : le local pour le travail courant, le cloud pour les tâches difficiles.

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

Le modèle local gère les lectures de fichiers, les modifications simples et le boilerplate — soit peut-être 60 à 70 % d’une session de programmation classique. Sonnet gère le débogage, les décisions d’architecture et le travail multi-fichiers. Votre facture API descend à quelques dollars par jour au lieu de 20 à 50 $.

Basculez manuellement quand vous savez qu’une tâche exige davantage de capacité :

/model sonnet

Ou utilisez l’auto-router de Haimaker pour gérer le routage à votre place. L’auto-router détecte la complexité de la tâche et envoie automatiquement les problèmes difficiles aux modèles cloud, pour que vous n’ayez pas à vous demander quand basculer.

Dépannage

Le modèle se charge lentement ou plante. Vous manquez probablement de mémoire. Essayez une quantification plus légère : ollama pull qwen3.6:27b-q4_K_M utilise moins de mémoire pour une légère perte de qualité. Q4_K_M est le bon compromis pour la plupart des gens — perte de qualité minimale, économies de mémoire significatives.

Les appels d’outils échouent. Définissez "reasoning": false dans la configuration de votre modèle et restez sur les modèles Qwen3.6 — ils gèrent le format d’appels d’outils d’OpenClaw de manière plus fiable que Mistral ou les anciens modèles Llama. Si les appels d’outils échouent encore, mettez à jour Ollama vers la dernière version. L’intégration officielle du fournisseur a corrigé plusieurs cas limites.

Erreurs de fenêtre de contexte. Définissez contextWindow avec précision dans votre configuration. Pour les modèles Qwen3.6, 131072 (128K) est une valeur sûre sur le matériel doté de 24 Go ou plus de VRAM (une seule RTX 5090 gère cela confortablement). Sur 16 Go, restez à 32768 pour éviter la dégradation de qualité.

Vitesse de génération lente. Si vous obtenez moins de 40 t/s sur le modèle 27B sur une 5090, ou moins de 18 t/s sur M5 Max, vérifiez si d’autres processus utilisent le GPU. Fermez les onglets de navigateur qui exécutent WebGL ou des vidéos. Sur Mac, Moniteur d’activité → Historique GPU vous montre ce qui mobilise la mémoire unifiée. Les utilisateurs de M5 doivent aussi confirmer qu’Ollama utilise le backend MLX (v0.21+) — l’écart de vitesse entre le backend Metal seul et MLX est d’environ un facteur 2 sur le traitement des prompts.

ESSAYER HAIMAKER POUR LE ROUTAGE CLOUD

---

Pour comparer les prix des modèles, voir les modèles les moins chers pour OpenClaw. Pour réduire les coûts de tokens sur les modèles cloud, voir réduire les coûts de 96 % avec QMD.