Thinking Machines Lab a publié Inkling 2 Mini le 20 novembre avec une promesse inhabituelle pour un modèle ouvert aussi capable : il tourne sur un ordinateur portable. L'entreprise le prend en charge sur n'importe quel Mac doté de 32 Go de mémoire ou plus, via Ollama. Ses chercheurs l'ont même fait tourner hors ligne sur un MacBook Pro pendant un vol, où il a construit un simulateur de vol jouable. Ce guide te montre, étape par étape, comment exécuter Inkling 2 Mini avec Ollama sur un Mac 32 Go. Il commence par une installation neuve et se termine par un agent de codage local opérationnel.
La version courte, ce sont trois commandes. La version longue, c'est la raison d'être de ce guide. Sur un Mac 32 Go, le modèle occupe environ 20 Go. Par défaut, macOS garde aussi environ un tiers de ta mémoire hors de portée du processeur graphique. Ollama réagit en donnant au modèle un contexte de 4 000 tokens : parfait pour discuter, bien trop petit pour un agent de codage. Et sur la plupart des Mac 32 Go, les prompts très longs peuvent encore manquer de mémoire aujourd'hui. Rien de tout cela n'est une raison de s'en passer. C'est une raison de bien le configurer.
Tu n’as pas besoin de savoir coder. Tu copieras quelques commandes dans Terminal, l’application en ligne de commande du Mac (appuie sur Cmd-Space, tape Terminal et appuie sur Entrée). Chacune est expliquée. La prise en charge d'Inkling 2 Mini par Ollama a quelques jours et évolue vite, donc chaque fait ci-dessous a été vérifié le 21 novembre 2026.
Indépendance et divulgation d'affiliation : Aucune entreprise mentionnée ici n'a sponsorisé, relu ni approuvé ce guide. Il contient un lien d'affiliation un lien d’affiliation, vers Z.ai’s GLM Coding Plan (dans la partie 10). En t'abonnant via ce lien, tu obtiens 10 % de réduction et je peux toucher une commission, sans coût supplémentaire pour toi.
TL;DR — La version en 60 secondes
- Il te faut : un Mac Apple silicon avec 32 Go de mémoire ou plus, macOS 14 ou plus récent, environ 25 Go d'espace disque libre et Ollama 0.40.17 ou plus récent.
- Trois commandes :
ollama --version(0.40.17 ou supérieur),ollama pull inkling-2-mini(un téléchargement de 20,2 Go),ollama run inkling-2-mini. - Le piège des 32 Go : les poids occupent 18,8 GiB, et par défaut macOS ne laisse le GPU utiliser qu'environ 21,3 GiB. Ollama fixe donc un contexte 4K, trop petit pour les agents.
- Les réglages qui comptent : règle le contexte sur 16K–32K dans les paramètres d’Ollama pour les agents. Si tu veux, monte le budget GPU à 24 GiB avec
sudo sysctl iogpu.wired_limit_mb=24576(il se réinitialise au redémarrage). Garde l’effort de raisonnement à élevé pour le code, faible pour les questions rapides. Ferme d’abord les applis gourmandes en mémoire. - Ta puce compte aujourd’hui : Ollama 0.40.17 n’active sa lecture de prompt économe en mémoire que pour les M2 Pro, M2 Ultra, M3 Ultra, M4 Pro et M5 Pro, Max et Ultra. Dans le seul test 32 Go publié, un M2 Max a planté avec "Insufficient Memory" après environ 12 000 tokens.
- Agents : Pi convient le mieux au 32 Go, car ses instructions et ses outils totalisent moins de 1 000 tokens (
ollama launch pi --model inkling-2-mini). Il exécute les commandes sans demander, alors garde-le dans un dossier jetable. OpenCode démarre avec environ 6 900 tokens et demande d’abord après une modification de configuration. Claude Code demande par défaut, mais sa première requête mesurait environ 32 800 tokens : mieux à partir de 48 Go. - Vitesse : À propos de 24 tokens par seconde sur un M2 Max 32 Go, et environ 32 sur un M4 Pro 48 Go.
- Sécurité : Thinking Machines prévient que le modèle peut boucler, supprimer ou écraser des fichiers sans te demander, et rapporter ses résultats de travers. Travaille dans Git ou sur une copie, laisse les demandes de permission activées et borne les étapes de l’agent.
En bref
| Modèle | Inkling 2 Mini de Thinking Machines Lab, publié le 20 novembre 2026, licence Apache 2.0 |
| Taille | 26,4 Md de paramètres, 3,4 Md actifs par token ; 5,4 Md d’activations de poids en comptant ses couches bouclées |
| Tag Ollama | inkling-2-mini (aussi 26b-a5b et 26b-a5b-nvfp4: le même paquet de 20 Go) |
| Télécharger | 20 188 097 271 octets (20,2 Go, soit 18,8 GiB) |
| Temps nécessaire | Environ une demi-heure, plus 3 à 60 minutes pour le téléchargement |
| Version d’Ollama | 0.40.17 ou plus récent ; Apple silicon uniquement dans cette version |
| Moteur | Le runner MLX d’Ollama, bâti sur le framework d’apprentissage automatique Apple |
| Capacités | Entrées texte et image, appels d’outils, raisonnement |
| Contexte | Jusqu’à 1M tokens dans le modèle ; la valeur par défaut côté Ollama sur la plupart des Mac 32 Go : 4K |
| Minimum pris en charge | Mac Apple silicon avec 32 Go (Thinking Machines et Ollama) |
| macOS | 14 Sonoma ou plus récent (exigence d’Ollama) |
| Effort de raisonnement | aucun, minimal, faible, moyen, élevé (par défaut), xhigh, max |
| Agents en une commande | Pi, OpenCode, Claude Code, Hermes Agent et OpenClaw, via ollama launch |
| Vitesse mesurée | M2 Max 32 Go : environ 24 tok/s ; M4 Pro 48 Go : environ 32 tok/s en écriture, 279 tok/s en lecture |
Measured speeds are third-party results.
Table des matières
- Partie 1 — Avant de commencer : ton Mac est-il prêt ?
- Partie 2 — Étape 1 : Installer ou mettre à jour Ollama
- Partie 3 — Étape 2 : Télécharger Inkling 2 Mini
- Partie 4 — Étape 3 : Lancer Inkling 2 Mini dans Ollama pour la première fois
- Partie 5 — Étape 4 : Réglages recommandés pour un Mac de 32 Go
- Partie 6 — La réalité des 32 Go : ta puce compte
- Partie 7 — Étape 5 : Utiliser Inkling 2 Mini comme backend local pour un agent de codage
- Partie 8 — À quelle vitesse tourne Inkling 2 Mini sur un Mac de 32 Go ?
- Partie 9 — Dépannage d'Inkling 2 Mini dans Ollama
- Partie 10 — Quand 32 Go ne suffisent pas
- Foire aux questions
- En résumé

Partie 1 — Avant de commencer : ton Mac est-il prêt ?
Quatre éléments déterminent si tu peux faire tourner Inkling 2 Mini avec Ollama : ta puce, ta mémoire, ta version de macOS et ton espace disque libre. Les trois premiers tiennent sur un seul écran : ouvre le menu Apple et choisis À propos de ce Mac. Pour l'espace disque, ouvre Réglages Système → Général → Stockage.
| Exigence | Minimum | Pourquoi |
|---|---|---|
| Puce | Apple silicon (n'importe quelle puce de la série M) | Ollama 0.40.17 ne fait tourner Inkling 2 Mini que sur Apple silicon. Sur les Mac Intel, Ollama ne peut utiliser que le processeur, pas le GPU |
| Mémoire | 32 Go | Le minimum pris en charge par Thinking Machines et par Ollama ; le modèle seul occupe environ 20 Go |
| macOS | 14 Sonoma ou version ultérieure | L’exigence propre à Ollama |
| Espace disque libre | Environ 25 Go | 20,2 Go pour le modèle, plus de la marge pour que macOS respire |
| Ollama | 0.40.17 ou plus récent | La première version qui connaît le modèle (partie 2) |
Et les Mac de 16 Go et 24 Go ? Pas avec le paquet d’Ollama, qui est un seul fichier de 20 Go sans version plus petite. Des copies compressées existent : Unsloth publie des fichiers 2 bits et 3 bits d’environ 9 à 14 Go qui tournent avec sa propre compilation de llama.cpp. C’est une autre voie, plus technique, que j’ai traitée dans Inkling 2 Mini vs Qwen3.8-27B, ainsi que ce que tu perds en qualité.
Quel Mac de 32 Go as-tu ?
Ta puce compte pour deux raisons. La première est la vitesse. Un modèle comme celui-ci écrit chaque mot en lisant ses poids actifs depuis la mémoire. La vitesse d'écriture dépend donc fortement de bande passante mémoire: de la rapidité avec laquelle la puce lit la mémoire. Les M1 Max et M2 Max ont deux fois la bande passante des M1 Pro et M2 Pro, et environ trois fois celle des M4 et M5 de base.
La seconde raison est nouvelle et propre à Ollama 0.40.17 (la partie 6 l'explique). Ollama dispose d'une manière économe en mémoire de lire les longs prompts pour ce modèle, mais elle n’est activée que pour certaines puces. Parmi les Mac livrés avec exactement 32 Go, seul le M2 Pro en bénéficie aujourd’hui.
| Puce | Livré avec 32 Go ? | Bande passante mémoire | Lecture économe en mémoire des prompts dans Ollama 0.40.17 |
|---|---|---|---|
| M1 Pro | Oui | 204,8 Go/s | Non |
| M1 Max | Oui | 409.6 GB/s | Non |
| M2 Pro | Oui | 204,8 Go/s | Oui |
| M2 Max | Oui | 409.6 GB/s | Non |
| M4 | Oui | 120 GB/s | Non |
| M5 | Oui | 153.6 GB/s | Non |
| M3 Pro, M3 Max, M4 Max | versions 36 GB | 153.6 / 307.2 / 409.6 GB/s | Non |
| M5 Max | version 36 GB | 460.8 GB/s | Oui |
Débits et options de mémoire d’après les spécifications d’Apple telles que recueillies par Wikipédia. Prise en charge de la lecture de prompt d’après le code source d’Ollama 0.40.17, qui l’active pour les M2 Pro, M2 Ultra, M3 Ultra, M4 Pro et les M5 Pro, Max et Ultra. Les M4 Pro et M5 Pro ne sont pas vendus avec 32 GB.
Les machines dotées de 36 GB disposent d’environ 4 GB de marge en plus par rapport à ce que suppose ce guide, donc les mêmes étapes fonctionnent avec un peu plus de mou.

Partie 2 — Étape 1 : Installer ou mettre à jour Ollama
Ollama est une application gratuite qui télécharge des modèles ouverts et les exécute sur ton propre Mac. Elle lance aussi un petit serveur en arrière-plan, auquel les agents de codage s’adressent ensuite.
Si tu n’as pas encore Ollama
- Aller à ollama.com/download et télécharge la version Mac,
Ollama.dmg. - Ouvre le fichier et fais glisser Ollama dans le dossier Applications dossier.
- Ouvre Ollama depuis Applications. Au premier démarrage, il vérifie si sa
ollamacommande est disponible dans Terminal. Sinon, il demande la permission de l’ajouter à/usr/local/bin. Réponds oui et saisis le mot de passe de ton Mac si on te le demande. Une petite icône de lama apparaît dans ta barre de menus pendant qu’Ollama tourne. - Ouvre Terminal et tape :
ollama --version
Tu veux 0.40.17 ou plus récent.
Si tu as déjà Ollama
Courir ollama --version. Si elle est plus ancienne que 0.40.17, mets-la à jour :
- L’application : Ollama télécharge les mises à jour tout seul. Clique sur l’icône de lama dans la barre de menus et choisis Redémarrer pour mettre à jour si elle est proposée. Sinon, retélécharge Ollama depuis ollama.com/download et remplace l’application. Tes modèles téléchargés restent là où ils sont.
- Homebrew : courir
brew upgrade ollama. Le paquet Ollama de Homebrew était déjà en 0.40.17 le 21 novembre.
Vérification de version, 21 novembre 2026 : Ollama a annoncé la prise en charge d’Inkling 2 Mini dans 0.40.17 le 20 novembre, en préversion. La version finale 0.40.17 a été taguée sur GitHub en moins d’un jour, et Homebrew la fournit déjà. Si la page de téléchargement te donne encore 0.40.16, prends 0.40.17 ou plus récent depuis la page des versions GitHub. Une version plus ancienne d’Ollama refuse le téléchargement avec
pull model manifest: 412: The model you are attempting to pull requires a newer version of Ollama.
Deux réglages qui méritent un coup d’œil (facultatif)
Ouvre les Paramètres d’Ollama depuis l’icône du lama ou la fenêtre de l’application.
- Cloud. Ce bouton active les modèles cloud d’Ollama et la recherche web. Inkling 2 Mini tourne entièrement sur ton Mac dans les deux cas ; la FAQ d’Ollama dit elle-même que, quand tu exécutes un modèle en local, il ne voit ni tes prompts ni tes données. Désactive Cloud si tu veux être certain que rien ne puisse basculer vers un modèle cloud. Note toutefois que les outils de recherche web de certains agents passent par le cloud d’Ollama.
- Emplacement du modèle. Si ton disque interne manque de place, fais pointer ce réglage vers un SSD externe avant de tu télécharges 20 Go.
Partie 3 — Étape 2 : Télécharger Inkling 2 Mini
Une seule commande :
ollama pull inkling-2-mini
Le téléchargement pèse 20 188 097 271 octets, soit un peu plus de 20 Go. Voici environ combien de temps cela prend à pleine vitesse ; les vrais téléchargements sont d’ordinaire plus lents :
| Ta connexion | Temps de téléchargement |
|---|---|
| 50 Mbit/s | environ 54 minutes |
| 100 Mbit/s | environ 27 minutes |
| 250 Mbit/s | environ 11 minutes |
| 500 Mbit/s | environ 5½ minutes |
| 1 Gbit/s | environ 3 minutes |
Si le téléchargement s’arrête, relance la même commande et il reprend là où il s’était arrêté.
Voici ce qu’il faut savoir sur ce que tu viens de télécharger :
- Une seule version, rien d’autre. Les trois tags de la page bibliothèque d’Ollama,
latest,26b-a5bet26b-a5b-nvfp4, sont le même paquet de 20 Go. Aucune version d’Ollama plus petite n’est proposée. - C’est l’original, pas une copie compressée. Thinking Machines a entraîné la plupart des poids du modèle dans un format 4 bits appelé NVFP4, et ses quatre dernières couches dans un format 8 bits, MXFP8. Il les livre tels quels. Le paquet d’Ollama contient ces poids, donc rien n’a été perdu lors d’une conversion.
- Il peut voir. Le paquet gère les images comme le texte, et il peut appeler des outils, ce qui permet aux agents de codage de l’utiliser.
Vérifie qu’il est bien arrivé :
ollama ls
Tu devrais voir inkling-2-mini:latest d’une taille de 20 GB.
Partie 4 — Étape 3 : Lancer Inkling 2 Mini dans Ollama pour la première fois
Lance une conversation dans Terminal :
ollama run inkling-2-mini --verbose
Le premier démarrage prend un peu de temps, car Ollama charge 20 GB depuis ton disque vers la mémoire. Tu obtiens ensuite une >>> invite. Essaie quelque chose comme :
Explique en trois phrases ce qu’est un transformer à boucles.
Inkling 2 Mini réfléchit avant de répondre, tu verras donc son raisonnement apparaître d’abord, suivi de la réponse. Si tu préfères ne pas le regarder réfléchir, lance-le avec --hidethinking à la place.
Lis les chiffres
Comme tu as ajouté --verbose, Ollama affiche des statistiques après chaque réponse. Deux lignes comptent :
| Ligne | Ce que ça veut dire |
|---|---|
| prompt eval rate | À quelle vitesse le modèle lit lire ton message, en tokens par seconde |
| eval rate | À quelle vitesse il a écrit la réponse, en tokens par seconde. Un token représente environ les trois quarts d’un mot anglais |
Pour référence, le seul test Ollama publié sur un Mac de 32 GB, un M2 Max, mesurait environ 24 tokens par seconde. La partie 8 contient les autres mesures.
Quelques choses à faire ensuite
- Quitte la conversation : type
/byeou appuie sur Ctrl-D. Le modèle reste en mémoire pendant cinq minutes au cas où tu reviendrais. - Libère la mémoire tout de suite :
ollama stop inkling-2-mini. - Pose une question sur une image : tape ta question, puis fais glisser un fichier image depuis le Finder dans la fenêtre Terminal, ce qui colle son chemin complet. Appuie sur Entrée.
- Utilise plutôt l’application : ouvre l’application Ollama, choisis
inkling-2-minidans le menu des modèles et discute là. Tu peux aussi déposer des images dans la fenêtre.
Vérifie qu’Inkling 2 Mini fonctionne correctement
Pendant que le modèle est chargé, ouvre une seconde fenêtre Terminal et lance :
ollama ps
| Colonne | Ce que tu veux voir |
|---|---|
| NAME | inkling-2-mini:latest |
| SIZE | La mémoire que le modèle occupe |
| PROCESSOR | 100 % GPU. Sur Apple silicon, cela veut dire qu’il tourne sur le processeur graphique, dans la mémoire unifiée |
| CONTEXTE | Combien de tokens de conversation il peut contenir. Sur la plupart des Mac 32 GB, cela affiche 4096 jusqu’à ce que tu le changes à la partie 5 |
| MOTEUR | mlx, le moteur d’Ollama pour Apple silicon |
| JUSQU’À | Quand Ollama le déchargera si tu ne l’utilises pas |
Tu peux aussi demander à Ollama ce qu’il a détecté au démarrage :
grep "vram-based default context" ~/.ollama/logs/server.log | tail -1
Sur un Mac 32 GB, tu devrais voir un total_vram d’environ 21 GiB et default_num_ctx=4096. Cette seule ligne explique l’essentiel de la partie 5.
Partie 5 — Étape 4 : Réglages recommandés pour un Mac de 32 Go
Le chat fonctionne sans aucun changement. Les agents de codage et les longs documents, non, à cause de la façon dont un Mac 32 GB répartit sa mémoire. Tous les chiffres de mémoire de cette partie sont en GiB, les gigaoctets binaires que rapportent macOS et Ollama ; un Mac "32 GB" a 32 GiB.
Voici le budget. Les poids d’Inkling 2 Mini prennent 18,8 GiB. Sur un Mac 32 GB, macOS laisse le processeur graphique utiliser environ deux tiers de la mémoire, environ 21,3 GiB, sauf si tu le modifies. VisualInference a mesuré ces mêmes poids d’origine dans une autre appli MLX, mlx-vlm, sur un M4 Pro de 48 GB. La mémoire a culminé à 20,3 GiB avec un prompt court, 21,4 GiB à 4 000 tokens et 22,1 GiB à 16 000 tokens. Autrement dit, dès que le prompt s’allonge, le modèle seul atteint la limite du budget GPU par défaut. Et c’est avant que macOS et tes autres applis prennent leur part.

Quatre réglages font la différence.
Réglage 1 : la longueur de contexte (le plus important)
Le longueur de contexte correspond à la quantité de texte que le modèle peut contenir d’un coup. Cela inclut tes messages et ses réponses et, pour un agent, le prompt système, les définitions d’outils et chaque fichier qu’il a lu. Trop courte, et un agent perd silencieusement ses instructions et se met à faire d’étranges erreurs. Trop grande, et tu réserves de la mémoire que tu n’utiliseras jamais.
Ollama choisit une valeur par défaut d’après la mémoire GPU qu’il détecte :
| Mémoire GPU détectée par Ollama | Contexte par défaut |
|---|---|
| Moins de 23 GiB (la plupart des Mac 32 GB : environ 21,3 GiB) | 4K tokens |
| 23 à 47 GiB | 32K tokens |
| 47 GiB ou plus | 256 000 jetons |
La documentation d’Ollama donne les paliers ainsi : moins de 24, 24–48 et 48 GiB ou plus. Le code de la version 0.40.17 utilise 23 et 47 GiB, pour absorber les petites différences dans ce que chaque Mac rapporte.
Ce qu’un contexte plus grand coûte en mémoire à Inkling 2 Mini, calculé d’après sa configuration :
| Contexte | Mémoire supplémentaire pour le contexte |
|---|---|
| 4K | 0,28 GiB |
| 8K | 0,41 GiB |
| 16K | 0,66 GiB |
| 32K | 1,16 GiB |
| 64K | 2,16 GiB |
| 128 K | 4,16 GiB |
Inkling 2 Mini a besoin de moins de mémoire par token de contexte que la plupart des modèles de sa taille. Seules quatre de ses 24 couches examinent toute la conversation. La mémoire de travail utilisée pendant la lecture d’un prompt vient en plus ; les pics mesurés ci-dessus l’incluent.
Ce qu’il faut régler
| Ce que tu fais | Contexte | Pourquoi |
|---|---|---|
| Discuter et poser des questions courtes | 4K–8K (la valeur par défaut convient) | Utilise le moins de mémoire |
| Coller de longs documents ou des fichiers de code | 16K | Environ 12 000 mots d’anglais |
| Agent Pi | 16K (8K sur les puces dépourvues de la lecture de prompt économe en mémoire de la partie 6) | Les instructions propres à Pi sont minuscules (partie 7) |
| OpenCode | 32K, sur un M2 Pro | Le maximum que tu peux lui accorder confortablement sur 32 GB. Ollama recommande 64K ou plus pour les agents, ce que ce Mac ne peut pas vraiment s’offrir à côté d’un modèle de 20 GB. Sur d’autres puces, lis d’abord la partie 6 |
| Claude Code | 64K ou plus, selon Ollama | Pas réaliste sur 32 GB ; voir la partie 7 |
Comment le régler
Le plus simple pour changer la longueur de contexte d’Ollama, c’est l’application : ouvre Réglages → Longueur du contexte et déplace le curseur, qui a des crans à 4k, 8k, 16k, 32k, 64k, 128k et 256k. Ollama redémarre son serveur pour l’appliquer, et le réglage survit à un redémarrage de ton Mac.
Il existe trois autres méthodes, utiles plus tard :
# Pour une seule session de chat, dans `ollama run` :
/set parameter num_ctx 16384
# Pour l'application Ollama, jusqu'au redémarrage de ton Mac (ensuite, quitte et rouvre Ollama) :
launchctl setenv OLLAMA_CONTEXT_LENGTH 32768
Si tu as déjà déplacé le curseur de l’application, le curseur l’emporte sur le réglage launchctl .
Ou crée une copie du modèle avec son propre contexte intégré, pratique quand tu veux 8K pour le chat mais 32K pour un agent. Colle ceci dans Terminal ; cela crée un petit fichier texte appelé Modelfile puis le nouveau modèle :
cat > Modelfile <<'EOF'
FROM inkling-2-mini
PARAMETER num_ctx 32768
EOF
ollama create inkling-2-mini-32k -f Modelfile
La copie ne télécharge pas et ne duplique pas les 20 Go de poids. Tu utilises ensuite inkling-2-mini-32k partout où tu utiliserais inkling-2-mini. Quelle que soit la méthode choisie, vérifie-le dans la CONTEXTE colonne de ollama ps.
Réglage 2 : donner plus d’espace au GPU (facultatif)
macOS limite la quantité de mémoire que le GPU peut garder pour lui, et Ollama traite cette limite comme ta "VRAM". Sur un Mac de 32 Go, elle est d’environ 21,3 GiB. Trois choses en découlent. Ollama en déduit sa fenêtre de contexte par défaut (réglage 1). Le moteur MLX d’Ollama garde le modèle chargé en mémoire jusqu’à cette limite. Si le modèle est plus gros, il consigne un avertissement indiquant que les performances peuvent être dégradées. Et quand une seule étape de travail demande plus de mémoire GPU que disponible, macOS l’arrête. C’est le Insufficient Memory crash de la partie 6. La documentation d’Apple indique que cela signifie que le GPU n’avait pas assez de mémoire pour exécuter un tampon de commandes.
Tu peux relever cette limite jusqu’à ton prochain redémarrage ; la documentation MLX d’Apple donne la commande prévue exactement pour cela. Vérifie d’abord la valeur actuelle ; 0 signifie la valeur par défaut de macOS :
sysctl iogpu.wired_limit_mb
Relève-la à 24 GiB, ce qui laisse 8 GiB à macOS et à tes apps :
sudo sysctl iogpu.wired_limit_mb=24576
Quitte ensuite Ollama depuis la barre des menus et rouvre-le, car Ollama ne lit la limite qu’au démarrage. Lance la grep commande de la partie 4 à nouveau et total_vram devrait maintenant indiquer environ 24 GiB.
Quatre choses à savoir
- Cela change aussi ta fenêtre de contexte par défaut. Avec 24 GiB détectés, la valeur par défaut d’Ollama passe de 4K à 32K (le tableau ci-dessus), donc tu n’as peut-être pas besoin du réglage 1 du tout.
- Cela donne plus d’espace au GPU, pas plus de mémoire. Cela déplace la frontière entre le GPU et macOS ; cela n’en ajoute pas. Si tes autres apps manquent alors de mémoire, macOS passe en swap.
- Elle se réinitialise au redémarrage de ton Mac. C’est un filet de sécurité, pas un bug. Pour annuler plus tôt :
sudo sysctl iogpu.wired_limit_mb=0. - Ce n’est pas un réglage officiel de macOS. Il est très répandu pour l’IA locale, mais si ton Mac swappe beaucoup, se fige ou redémarre de façon inattendue pendant une session, remets-le à 0. Ne monte pas beaucoup plus haut que 24 GiB sur un Mac de 32 Go.
Réglage 3 : effort de raisonnement
Inkling 2 Mini décide de l’intensité de sa réflexion en fonction d’un réglage d’ effort de raisonnement . Par défaut, Ollama utilise élevé. Voici comment Ollama 0.40.17 traduit ces noms en la valeur que le modèle reçoit réellement :
| Réglage Ollama | Effort reçu par le modèle | Idéal pour |
|---|---|---|
aucun ou false |
0 (réflexion masquée) | Recherches simples |
minimal |
0.1 | Faits rapides |
faible |
0.2 | Réponses courtes, résumés, reformulations |
moyen |
0.7 | Questions du quotidien |
élevé ou vrai (default) |
0.9 | Codage et travail d’agent |
xhigh ou max |
0.99 | Problèmes difficiles, quand tu peux attendre |
D’après le moteur de rendu d’Inkling 2 Mini dans Ollama 0.40.17. Thinking Machines note que même le minimum ne désactive pas complètement le raisonnement.

xhigh et max envoient la même valeur. La valeur par défaut, high, est le bon réglage pour coder.Pour le régler pour une discussion :
ollama run inkling-2-mini --think=low
Dans une discussion, /set nothink le fait descendre au niveau le plus bas et masque la réflexion, et /set think le réactive. Dans l'API d’Ollama, les mêmes noms vont dans le think champ.
Ma recommandation : laisse-le sur élevé pour le code et les agents, où la réflexion se rentabilise. Utilise faible ou moyen pour les questions rapides, pour ne pas attendre un long raisonnement pour une réponse d’une ligne.
Réglage 4 : le garder chargé, et le décharger quand tu n’en as plus besoin
Ollama décharge un modèle après cinq minutes sans utilisation, et recharger 20 GB prend du temps. Pendant une session d'agent avec des pauses, ça devient pénible. Pour le garder chargé 30 minutes après chaque utilisation :
launchctl setenv OLLAMA_KEEP_ALIVE 30m
Ensuite, quitte et rouvre Ollama. Pour une seule discussion, ollama run inkling-2-mini --keepalive 30m fait la même chose. Le revers : quand tu n’en as plus besoin, rends la mémoire avec ollama stop inkling-2-mini.
Deux autres réglages, pour les curieux
- Le générateur d'ébauche intégré. Thinking Machines livre Inkling 2 Mini avec un petit réseau auxiliaire, DSpark, qui devine quelques mots à l'avance. Le modèle principal les vérifie ensuite d'un seul coup. Ollama le prend en charge et active l'ébauche par défaut pour tout modèle qui inclut un générateur d'ébauche. Dans des tests MLX publiés hors d'Ollama, DSpark a fait passer la vitesse d’écriture d'Inkling de 43,6 à 70,9 jetons par seconde sur un M5 Max. Sur un M4 Pro, elle est tombée de 31,1 à 18,7. Alors teste-le sur ton Mac : dans une discussion,
/set parameter draft_num_predict 0le désactive ; compare les eval rate avec et sans. - Requêtes parallèles. Depuis la 0.40.17, Ollama sur Apple silicon peut répondre à plusieurs requêtes à la fois, et chacune a besoin de sa propre mémoire de contexte. Ollama choisit une valeur par défaut prudente selon ta mémoire libre. Si un agent qui lance des assistants en parallèle fait encore basculer ton Mac dans le swap, limite-le à une seule avec
launchctl setenv OLLAMA_NUM_PARALLEL 1. Ensuite, quitte et rouvre Ollama.
Des réglages qui n’aideront pas ici
Les guides pour d'autres modèles suggèrent souvent OLLAMA_KV_CACHE_TYPE=q8_0 de diviser par deux la mémoire qu'utilise un contexte, avec flash attention. Dans Ollama 0.40.17, ces réglages appartiennent à son llama.cpp moteur ; Inkling 2 Mini tourne sur le MLX moteur, et rien dans le code de ce moteur ne les lit. Il en va de même pour les réglages de couches GPU comme num_gpu. Et laisse temperature tranquille : le paquet d’Ollama utilise la valeur par défaut de Thinking Machines, 1.0, celle que recommande aussi Unsloth.
Avant une longue session : libère de la mémoire
Recharger Moniteur d’activité (dans Applications → Utilitaires) et clique sur l’onglet Mémoire Mémoire. En bas, tu vois le Pression mémoire graphique et Échange utilisé. Vert, tout va bien ; jaune, macOS compresse la mémoire ; rouge, il échange sur ton disque, et tout ralentit. Avant une session d’agent, ferme les gros consommateurs : navigateurs avec beaucoup d’onglets, Docker Desktop, simulateurs iPhone, éditeurs vidéo et photo. Sur un portable, branche le chargeur pour les longues sessions.
Partie 6 — La réalité des 32 Go : ta puce compte
Cette partie compte si ton Mac a une autre puce que la M2 Pro (ou une M5 Max de 36 Go), ce qui est le cas de la plupart des Mac de 32 Go. C’est aussi la partie que les notes de version d’Ollama ne mentionnent pas.
Ce qui se passe quand Inkling 2 Mini lit un long prompt
Avant d’écrire quoi que ce soit, un modèle lit tout ton prompt. Le moteur MLX d’Ollama le fait 2 048 tokens à la fois. Pour chaque bloc, Inkling 2 Mini calcule comment chaque nouveau token se rapporte à tous les tokens précédents, à l’aide d’une mesure de distance apprise entre eux. Cette étape a besoin d’une table temporaire qui grandit avec tout ce que le modèle a lu jusque-là dans la conversation.
Ollama 0.40.17 contient un moyen d’économiser la mémoire pour le faire, qui traite le prompt en petits carreaux pour que la table ne grossisse jamais. Son code source ne l’active que pour ces puces : M2 Pro, M2 Ultra, M3 Ultra, M4 Pro, et les M5 Pro, Max et Ultra. Toute autre puce retombe sur une méthode générale dont l’usage mémoire croît avec le prompt. Cela inclut les M1 Pro et Max, la M2 Max, la M4 de base et la M5 de base.
Ce que cela a donné sur un M2 Max de 32 Go
Le seul test publié d’Ollama 0.40.17 sur un Mac de 32 Go vient des développeurs de Genex. Ils ont essayé Inkling 2 Mini sur un M2 Max de 32 Go :
- Le téléchargement a fonctionné, et une courte requête d’appel d’outil a renvoyé une réponse correcte à environ 24 tokens par seconde.
- Une requête de 18 003 tokens a planté après 12 288 tokens avec l’erreur
mlx: [METAL] Command buffer execution failed: Insufficient Memory. Régler le contexte sur 32 768 et la taille de lot sur 512 n’a rien changé. - Leur vrai prompt de 15 089 tokens a planté de la même façon.
- Une boucle d’utilisation d’ordinateur pilotée par de vraies captures d’écran a fonctionné.
Ils ont conclu que le modèle tient sur un Mac de 32 Go pour des prompts courts, mais pas pour les longs de leur application. Ils ont donc modifié leur application pour ne recommander Inkling 2 Mini qu’à partir de 48 Go.
Que faire
| Ta puce | À quoi t’attendre aujourd’hui | Quoi faire |
|---|---|---|
| M2 Pro (32 Go) ou M5 Max (36 Go) | Les longs prompts utilisent une mémoire bornée | Agents avec un contexte de 16K–32K, budget GPU relevé (partie 5) |
| M1 Pro, M1 Max, M2 Max, M4, M5 (32 Go) | Une session qui dépasse nettement les 10 000 tokens risque un plantage "Insufficient Memory" | Utilise-le pour le chat et les documents courts ; pour les agents, utilise Pi avec un contexte de 8K et démarre une nouvelle session pour chaque tâche ; augmente le budget GPU ; mets Ollama à jour à chaque nouvelle version |
| M3 Pro, M3 Max, M4 Max (36 GB) | Même repli, avec environ 4 GB de marge en plus | Comme ci-dessus, avec un peu plus de marge |
Deux choses à garder en tête. D’abord, c’est une limite logicielle, pas une limite matérielle. Le code qui économise la mémoire existe ; il n’est simplement pas encore activé pour chaque puce, et Ollama publie de nouvelles versions presque chaque semaine. Consulte les notes de version quand tu mets à jour. Ensuite, ce qui compte, c’est la quantité de texte que le modèle doit traiter en une session, pas le nombre affiché sur le curseur de contexte. Chaque nouveau morceau est comparé à tout ce qui précède, donc une longue conversation pèse autant qu’un long prompt, et les agents de codage construisent vite de longues conversations. Un contexte réduit garde les sessions courtes ; démarrer de nouvelles sessions les garde encore plus courtes.
Partie 7 — Étape 5 : Utiliser Inkling 2 Mini comme backend local pour un agent de codage
Un agent de codage est un programme qui donne des outils à un modèle, comme lire des fichiers, les modifier et exécuter des commandes. Il permet au modèle de traiter une tâche étape par étape. Normalement, le modèle tourne dans un centre de données. Ici, Inkling 2 Mini sur ton Mac devient le backend local: l’agent envoie ses requêtes à Ollama à la place.

Comment cela fonctionne-t-il ?
Quand Ollama tourne, il écoute sur http://localhost:11434, une adresse que seuls les programmes de ton Mac peuvent atteindre. Il parle les formats d’API que les agents connaissent déjà : un compatible OpenAI un sur http://localhost:11434/v1, un compatible Anthropic un pour Claude Code, et le sien. L’agent envoie son prompt et ses définitions d’outils, et Inkling 2 Mini décide quel outil appeler. L’agent exécute cet outil sur ton Mac et renvoie le résultat. La boucle se répète jusqu’à ce que la tâche soit terminée.
Tu n’as rien de tout cela à configurer à la main. La ollama launch commande installe les agents pris en charge s’ils manquent, les pointe vers Ollama et les démarre.
Avant de lancer un agent
- Règle d’abord le contexte (Partie 5). Cela compte plus qu’il n’y paraît : quand tu démarres OpenCode via
ollama launch, Ollama lit le contexte avec lequel le modèle s’est réellement chargé et indique ce nombre à OpenCode. Si Ollama est encore à 4K, OpenCode le croit. - Travaille dans un dossier de test sous Git, pour que tu puisses voir et annuler chaque changement :
mkdir -p ~/Projects/inkling-test
cd ~/Projects/inkling-test
git init
La première fois que tu utilises git, macOS peut te proposer d’installer les outils de développement en ligne de commande d’Apple. Accepte ; cela prend quelques minutes.
- Ferme les applis gourmandes en mémoire (Partie 5).
Quel agent utiliser sur 32 GB ?
| Pi | OpenCode | Claude Code | |
|---|---|---|---|
| Installation en une commande | ollama launch pi --model inkling-2-mini |
ollama launch opencode --model inkling-2-mini |
ollama launch claude --model inkling-2-mini |
| Tu installes d’abord | Node.js | Rien ; Ollama propose de l’installer | Rien ; Ollama propose de l’installer |
| Instructions et outils envoyés avant ton premier mot | Moins de 1 000 tokens | Environ 6 900 tokens | Environ 32 800 tokens |
| Demande avant d'exécuter des commandes | Non, c'est voulu | Pas par défaut; un seul changement de configuration l'active | Oui, pour la plupart des actions |
| Contexte à définir sur 32 Go | 16K (8K sur les puces dépourvues de la lecture de prompt économe en mémoire) | 32K sur un M2 Pro | Ollama recommande 64K ou plus |
| Idéal sur | N'importe quel Mac 32 Go, dans un dossier jetable | M2 Pro avec 32 Go, ou 48 Go et plus | 48 Go et plus |
Le chiffre de Pi vient de l’auteur. Les chiffres d’OpenCode et de Claude Code viennent de la mesure réalisée par Systima en juillet 2026 sur la première requête de chaque agent. Systima a utilisé un projet vide, sans serveurs MCP, OpenCode 1.17 et Claude Code 2.1 avec un modèle Claude. Les deux agents ont été mis à jour depuis, alors lis ces chiffres comme des ordres de grandeur. Le conseil général d’Ollama pour les agents est un contexte d’au moins 64K.

Option A : Pi, le plus léger
Pi est un agent de codage volontairement minimal avec quatre outils : read, write, edit et bash. Son auteur affirme que son prompt système et les définitions de ses outils totalisent à eux deux moins de 1 000 tokens. Cela en fait le meilleur choix pour un Mac de 32 Go, et c’est l'agent qu'Ollama a suggéré dans sa propre annonce d'Inkling 2 Mini.
- Installer Node.js: télécharge l'installateur LTS depuis nodejs.org et lance-le.
ollama launch pinécessite lenpmde Node pour installer Pi. - Va dans ton dossier de test et lance :
cd ~/Projects/inkling-test
ollama launch pi --model inkling-2-mini
Ollama installe Pi, le configure pour utiliser ton modèle local et ouvre une session.
⚠️ Pi ne demande rien. Son auteur le décrit comme fonctionnant en "full YOLO mode" : aucune demande d'autorisation pour les opérations sur fichiers ou les commandes, et un accès sans restriction à tes fichiers. Thinking Machines avertit aussi qu'Inkling 2 Mini peut supprimer ou écraser des fichiers sans confirmation. Mis bout à bout, cela signifie : ne lance Pi que dans un dossier jetable, jamais dans ton dossier personnel ni dans un projet sans sauvegarde. Son auteur suggère de le lancer dans un conteneur si tu veux une vraie frontière ; mon guide des conteneurs Apple explique comment en configurer un sur un Mac.
Un dernier détail : quand Pi est lancé via Ollama, son outil de recherche web utilise la recherche web cloud d’Ollama. Cela nécessite un compte Ollama et le réglage Cloud activé. Tout le reste demeure sur ton Mac.
Option B : OpenCode, le juste milieu soigné
OpenCode est un agent de codage open source populaire, doté d'une interface terminal plein écran, d'instantanés à chaque étape et d'un système d'autorisations que tu peux resserrer.
cd ~/Projects/inkling-test
ollama launch opencode --model inkling-2-mini
Si OpenCode n’est pas installé, Ollama te demande s’il faut l’installer ; réponds oui. Ollama transmet ensuite à OpenCode ses réglages pour cette session, sans écraser les tiens ~/.config/opencode/opencode.json. Il dimensionne les limites d’OpenCode selon la fenêtre de contexte avec laquelle le modèle a été chargé, et en réserve un quart, jusqu’à 8K tokens, pour la réponse. Depuis 0.40.17, il transmet aussi les options de réflexion d’Inkling 2 Mini.
La requête d’ouverture d’OpenCode reste modérée : environ 6 900 tokens dans la mesure de Systima en juillet. Mais chaque fichier lu et chaque sortie de commande reçue s’ajoutent à la conversation. Sur un Mac de 32 Go sans la lecture de prompt économe en mémoire de la partie 6, c’est le chiffre à surveiller. Il ne faut pas beaucoup de fichiers pour dépasser les 12 000 tokens où le M2 Max a planté.
OpenCode v2 repère aussi les modèles d’Ollama tout seul au démarrage, tu peux donc simplement lancer opencode puis choisir le modèle avec /models. Passer par Ollama reste la meilleure voie sur 32 Go, parce qu’il indique à OpenCode la fenêtre de contexte dont tu disposes réellement.
Fais-lui demander avant d’agir et limite ses étapes
Par défaut, OpenCode v2 laisse le modèle exécuter des commandes shell et modifier des fichiers sans demander ; ses règles par défaut ne demandent qu’avant la lecture .env de fichiers. Avec un modèle dont le créateur met en garde contre les actions destructrices, change ça. Thinking Machines recommande aussi de limiter les tours d’agent, parce que le modèle se bloque parfois dans de longues boucles de raisonnement, surtout pendant le débogage, et l’option steps d’OpenCode s’en charge. Mets les deux dans ~/.config/opencode/opencode.json (crée le fichier s’il n’existe pas) :
{
"$schema": "https://opencode.ai/config.json",
"permissions": [
{ "action": "shell", "resource": "*", "effect": "ask" },
{ "action": "edit", "resource": "*", "effect": "ask" }
],
"agents": {
"build": { "steps": 40 }
}
}
Le permissions obligent OpenCode à demander avant chaque commande shell et chaque modification. L’ construire agent est celui par défaut d’OpenCode ; à sa dernière étape autorisée, OpenCode retire les outils et demande au modèle de résumer. Vérifie que le réglage a bien pris en demandant à OpenCode de créer un fichier : il devrait maintenant te demander d’abord. Si ce n’est pas le cas, la documentation des permissions d’OpenCode explique comment les agents peuvent ajouter leurs propres règles. Pour tout le reste sur OpenCode, des plans aux serveurs MCP, vois mon guide OpenCode.
Option C : Claude Code, le plus lourd
Claude Code fonctionne avec Ollama via l’API compatible Anthropic d’Ollama, donc ses requêtes vont vers ton Mac au lieu des serveurs d’Anthropic. Par défaut, il demande la permission avant la plupart des actions, ce qui en fait le plus prudent des trois.
cd ~/Projects/inkling-test
ollama launch claude --model inkling-2-mini
Ollama te propose d’installer Claude Code s’il manque. Si tu préfères le lancer toi-même plus tard, voici les réglages ollama launch dont il s’occupe :
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model inkling-2-mini
Ollama 0.40.17 permet aussi à Claude Code de ne charger les outils MCP que lorsqu’ils sont nécessaires, plutôt que tous d’un coup, ce qui garde les prompts plus courts. Il ne touche pas aux outils intégrés de Claude Code, en revanche, et ce sont eux qui le rendent lourd. Dans la mesure de Systima en juillet, sans serveur MCP, la toute première requête de Claude Code était d’environ 32 800 tokens, en grande partie des définitions d’outils. C’est plus qu’une fenêtre de 32K ne peut contenir, et bien au-delà des 12 000 tokens où le M2 Max a planté. Ollama recommande une fenêtre de 64K ou plus pour lui. Sur un Mac de 32 Go, essaie si la curiosité te tient ; compte dessus à partir de 48 Go.
Autres agents et applications
La page de bibliothèque d’Ollama liste des lancements en une seule commande pour deux autres agents, et le même schéma fonctionne pour Codex :
ollama launch hermes --model inkling-2-mini # Hermes Agent
ollama launch openclaw --model inkling-2-mini # OpenClaw
ollama launch codex --model inkling-2-mini # OpenAI's Codex CLI
Tout autre outil qui parle l’API OpenAI peut aussi utiliser Inkling 2 Mini. Donne-lui l’URL de base http://localhost:11434/v1, le nom du modèle inkling-2-mini et n’importe quel texte comme clé d’API. Ollama ne vérifie pas la clé, mais beaucoup d’outils refusent une clé vide.
Ta première tâche d’agent
Commence par quelque chose de petit et de visible, dans ton dossier de test :
Crée une page web de liste de tâches en un seul fichier, appelée index.html, qui enregistre les tâches dans le navigateur. Reste simple et explique comment l’ouvrir quand tu as fini.
Regarde ce qu’il fait : quels fichiers il lit, ce qu’il écrit, quelles commandes il lance. Quand il a fini, ouvre la page avec open index.html, et vérifie la modification avec Git :
git status # quels fichiers ont changé ou sont apparus
git diff # ce qui a changé dans les fichiers que Git connaissait déjà
Si le résultat ne te plaît pas, supprime le dossier et recommence. C’est justement l’intérêt d’un dossier de test.
Cinq règles pour exécuter un agent local en sécurité
La fiche de modèle de Thinking Machines est étonnamment franche sur les modes de défaillance d’Inkling 2 Mini. Il peut se bloquer dans de longues boucles de raisonnement. Il peut supprimer ou écraser des fichiers sans confirmation, et il peut ne pas rapporter fidèlement le résultat de son travail. Il est aussi plus susceptible que des modèles plus gros d’énoncer des faits faux avec assurance. Rien de tout cela n’est inhabituel pour un modèle de cette taille. Cela veut juste dire :
- Git ou une copie, toujours. Ne laisse jamais un agent s’attaquer à des fichiers que tu ne peux pas restaurer.
- Active les demandes d’autorisation là où l’agent les propose (OpenCode a besoin du changement de configuration ci-dessus), et lis ce que tu approuves.
- Limite les étapes et la sortie. Utilise le paramètre d’OpenCode
steps; dans un chat Ollama,/set parameter num_predict 4096limite une seule réponse. - Vérifie ses affirmations. Lance les tests toi-même avant de croire que "tous les tests passent".
- Ne pointe jamais un agent vers ton dossier personnel. Et pour Pi, utilise un dossier jetable ou un conteneur.
Si tu veux aller plus loin, mon guide sur les compétences d’agents et les serveurs MCP explique comment limiter ce que les outils d’un agent peuvent atteindre. Tous les harnais de codage IA comparés examine les agents eux-mêmes en profondeur.
Partie 8 — À quelle vitesse tourne Inkling 2 Mini sur un Mac de 32 Go ?
La vitesse a deux volets : la vitesse à laquelle le modèle lit ton prompt et celle à laquelle il écrit sa réponse. Voici les mesures pertinentes publiées au 21 novembre, avec l’environnement d’exécution utilisé pour chacune :
| Mac | Durée d'exécution | Vitesse d’écriture | Vitesse de lecture | Notes |
|---|---|---|---|---|
| M2 Max, 32 GB | Ollama 0.40.17 | Environ 24 tok/s | Non publié | Requête courte avec appel d’outils |
| M4 Pro, 48 GB | Ollama 0.40.17 | Environ 32 tok/s | 279 tok/s | Un prompt de 12 000 tokens, contexte de 64K ; 65 secondes au total |
| M4 Pro, 48 GB | mlx-vlm, mêmes poids d’origine | 25,9 tok/s | Non publié | VisualInference |
| M5 Pro, 48 GB | MLX-VLM, version communautaire 4/8 bits | Environ 27 tok/s | Environ 123–144 tok/s sur des prompts très courts | ModelFit ; les prompts très courts sont lus lentement, donc ce n’est pas comparable avec le 279 ci-dessus |
Third-party measurements, collected on 21 November 2026. No published Ollama runs yet for the M1 Pro, M1 Max, M2 Pro, base M4 or base M5.

Ce que ces chiffres signifient en pratique
- Pour le chat, à environ 24 tokens par seconde, c’est plus rapide que ta lecture. Une réponse de 300 mots après mille tokens de réflexion, environ 1 400 tokens en tout, prend à peu près une minute à cette vitesse. Baisse l’effort de raisonnement pour les questions rapides et c’est bien plus court.
- Pour les agents, la vitesse de lecture compte autant que la vitesse d’écriture, car un agent envoie un long prompt à chaque tour. Sur le M4 Pro 48 Go, un prompt de 12 000 tokens a mis environ 43 secondes à être lu. Ollama réutilise son cache du début partagé d’une conversation entre les tours, donc les tours suivants ne lisent en grande partie que ce qui’est nouveau.
- Pour comparer, sur ce même M4 Pro, Qwen3.8-27B a mis 122 secondes pour la tâche de 12 000 tokens qu’Inkling 2 Mini a terminée en 65. Qwen lisait à 107 et écrivait à 27 tokens par seconde. Ma comparaison des deux modèles explique pourquoi, et le seul piège : Inkling 2 Mini a tendance à écrire plus de tokens par tâche.
À quoi t’attendre sur les autres Mac 32 Go
Personne n’a encore publié de chiffres Ollama pour les M4 et M5 de base. Leur bande passante mémoire est de 120 et 153,6 Go/s, contre 409,6 Go/s pour le M2 Max qui atteignait environ 24 tokens par seconde. Attends-toi à ce qu’ils soient nettement plus lents. Difficile de dire à l’avance à quel point, car avec les logiciels actuels, Inkling 2 Mini ne s’accélère pas proportionnellement à la bande passante. Si tu en as un, lance le --verbose test de la partie 4 et tu sauras en une minute.
Partie 9 — Dépannage d'Inkling 2 Mini dans Ollama
Trouve ton symptôme ci-dessous. S’il n’y est pas, le journal d’Ollama dit généralement ce qui a cloché ; la dernière section de cette partie montre comment le lire.

Si Inkling 2 Mini ne se télécharge pas ou ne démarre pas
| Symptôme | Cause probable | Fixer |
|---|---|---|
ollama pull inkling-2-mini échoue avec 412 et "requires a newer version" |
Ollama plus ancien que 0.40.17 | Mets à jour (partie 2), puis relance le pull |
ollama: command not found |
Le lien de la ligne de commande n’a pas été créé | Ouvre l’application Ollama et accepte sa proposition d’installer la commande, ou réinstalle l’application |
PROCESSOR en ollama ps n’affiche pas 100% GPU |
Un problème dans la configuration du GPU | Quitte et rouvre Ollama ; vérifie que tu es sur Apple silicon et macOS 14 ou plus récent |
| Tu es sous Windows ou Linux | Ollama 0.40.17 ne prend en charge Inkling 2 Mini que sur Apple silicon ; les modèles réservés au Mac d’Ollama ont refusé de se télécharger ailleurs avec 412: this model requires macOS |
Attends une version ultérieure, ou utilise llama.cpp ou vLLM |
Si Inkling 2 Mini plante, oublie ou ralentit ton Mac
| Symptôme | Cause probable | Fixer |
|---|---|---|
Le modèle s’arrête en pleine réponse, avec Insufficient Memory ou Command buffer execution failed dans le journal |
Le prompt était trop long pour la mémoire de ta puce aujourd’hui (partie 6), ou d’autres apps ont pris la mémoire | Ferme des apps, raccourcis le prompt ou les documents que tu colles, utilise Pi plutôt qu’un agent plus lourd, augmente le budget GPU (partie 5) et mets Ollama à jour |
| L’agent oublie les instructions, les appels d’outils échouent, les modifications s’arrêtent à mi-chemin | Le contexte est trop petit : probablement la valeur par défaut de 4K | Règle 16K–32K (partie 5) et vérifie la colonne CONTEXT dans ollama ps. Puis relance l’agent |
| Ton Mac ralentit à l’extrême, les ventilateurs tournent, le swap grossit | graphique Pression mémoire | Vérifie le Moniteur d’activité ; ferme des apps ; réduis le contexte ; ollama stop tout autre modèle chargé |
| La première réponse après une pause est lente | Ollama a déchargé le modèle après cinq minutes d’inactivité | Ensemble OLLAMA_KEEP_ALIVE (Partie 5) |
Si un agent de codage se comporte mal
| Symptôme | Cause probable | Fixer |
|---|---|---|
| Le modèle réfléchit pendant une éternité ou se répète | De longues boucles de raisonnement, contre lesquelles Thinking Machines met en garde | Donne des tâches plus petites, limite les étapes et les tokens de sortie, utilise un effort plus faible pour les questions simples |
| L’agent dit que le modèle n’existe pas | Une faute de frappe dans le nom du modèle | Utilise exactement inkling-2-mini; ollama ls liste ce que tu as |
| La recherche web de Pi ne fonctionne pas | Elle utilise la recherche web cloud d’Ollama | Connecte-toi à Ollama et active Cloud, ou travaille sans recherche web |
| OpenCode modifie des fichiers sans demander | OpenCode v2 autorise les modifications et les commandes shell par défaut | Ajoute les permissions règles de la partie 7 |
Vérifie le journal d’Ollama
Les journaux d’Ollama se trouvent dans ~/.ollama/logs/server.log. Pour voir les dernières lignes après un problème :
tail -n 40 ~/.ollama/logs/server.log
Partie 10 — Quand 32 Go ne suffisent pas
Tu sauras que tu as atteint le plafond quand les longs prompts plantent, quand les agents n’arrêtent pas de compacter leur conversation, ou quand ton Mac échange sur le disque à chaque chargement du modèle. Les trois premières options ne coûtent rien ; les trois dernières coûtent de l’argent, de la confidentialité, ou les deux.
Sur le Mac que tu as
- Garde-le et utilise-le pour ce qui tient. Le chat, les documents courts, les questions sur des images et Pi sur de petites tâches fonctionnent bien sur tous les Mac 32 GB. Surveille les notes de version d’Ollama : si la lecture de prompt économe en mémoire de la partie 6 arrivait sur plus de puces, la donne changerait du jour au lendemain.
- Un fichier plus petit dans un autre runtime. La version 4 bits d’Unsloth fait 17,6 GB, environ 2,6 GB de moins que le paquet d’Ollama, et tourne avec la compilation maison de llama.cpp d’Unsloth. C’est plus technique, et le support au premier jour y était plus chaotique ; mon article de comparaison couvre le sujet.
- Un autre modèle local. Qwen3.8-27B obtient le même score qu’Inkling 2 Mini sur l’index d’Artificial Analysis, tourne partout et est meilleur sur les questions de connaissances, mais il est plus lent sur le même Mac. Même article.
Au-delà de ton Mac
- Plus de mémoire. À partir de 48 Go, Inkling 2 Mini fait tourner des agents confortablement, et à partir de 64 Go tu peux le garder chargé à côté d’un autre modèle. Si tu hésites sur quoi acheter, mes guides sur si un MacBook pour LLM locaux vaut le coup et le MacBook Pro M5 Pro avec 64 GB passer en revue les compromis.
- Le grand frère, dans le cloud. Inkling 2 Small, le modèle à 594 milliards de paramètres de Thinking Machines’, est sur le cloud d’Ollama sous
inkling-2-small:cloud. Il fonctionne avec les mêmes commandes de lancement, par exempleollama launch opencode --model inkling-2-small:cloud. Il faut un compte Ollama, et tes prompts quittent alors ton Mac. - Un plan de codage pour les 10 % les plus difficiles. Beaucoup de gens font tourner un modèle local pour le travail privé et quotidien et envoient la planification et le débogage les plus difficiles à un grand modèle cloud. Une option abordable est le GLM Coding Plan de Z.ai, qui fonctionne dans OpenCode, Claude Code et d’autres agents. Tu peux obtenir 10 % de réduction sur le GLM Coding Plan via mon lien d'affiliation. (Lien d’affiliation — voir la mention en haut.)
Foire aux questions
Oui. Thinking Machines et Ollama prennent tous deux en charge Inkling 2 Mini sur les Mac Apple silicon avec 32 Go ou plus, via Ollama 0.40.17 ou plus récent. Le modèle occupe environ 20 Go, donc le chat et les documents courts fonctionnent bien. Les prompts longs sont la limite. Sur la plupart des puces 32 Go, Ollama 0.40.17 n’utilise pas encore sa lecture de prompt économe en mémoire. Un test sur un M2 Max a planté après environ 12 000 tokens.
Ollama 0.40.17 ou plus récent. Ollama a annoncé la prise en charge d’Inkling 2 Mini dans la 0.40.17 le 20 novembre 2026 en préversion, et la 0.40.17 finale a suivi en moins d’un jour. Vérifie avec ollama --version. Les versions plus anciennes refusent le téléchargement avec une erreur 412. Dans la 0.40.17, Inkling 2 Mini n’est pris en charge que sur Apple silicon.
20 188 097 271 octets, environ 20,2 Go ou 18,8 Gio. Les trois tags, latest, 26b-a5b et 26b-a5b-nvfp4, sont le même paquet : les poids NVFP4 et MXFP8 originaux de Thinking Machines’, avec prise en charge des images. Il n’y a pas de version Ollama plus petite. À 100 Mbit/s, le téléchargement prend environ 27 minutes.
Ollama définit son contexte par défaut d’après la mémoire GPU qu’il détecte : 4K en dessous d’environ 23 Gio, 32K jusqu’à environ 47 Gio et 256K au-delà. Sur un Mac, ce chiffre correspond au budget GPU que macOS autorise, qui sur un Mac 32 Go est d’environ 21,3 Gio, donc tu obtiens 4K. Modifie-le avec le curseur Context length dans les réglages d’Ollama, ou en portant le budget GPU à 24 Gio.
16K pour Pi, et 32K pour OpenCode sur un M2 Pro, soit le maximum qu’un Mac 32 Go peut offrir confortablement à côté d’un modèle de 20 Go. Sur les puces sans la lecture de prompt économe en mémoire d’Ollama, utilise 8K et des sessions courtes. Ollama recommande 64K ou plus pour les agents de codage, ce qui fonctionne à partir de 48 Go. Règle-le avant de lancer l’agent, car ollama launch opencode transmet le contexte chargé à OpenCode.
Sur un Mac 32 Go, ça aide. Lancer sudo sysctl iogpu.wired_limit_mb=24576 fait passer le budget GPU d’environ 21,3 Gio à 24 Gio et laisse 8 Gio à macOS. Ollama passe alors à un contexte de 32K par défaut. Quitte puis rouvre Ollama ensuite. Le réglage est réinitialisé quand tu redémarres ton Mac ; sudo sysctl iogpu.wired_limit_mb=0 rétablit le défaut plus tôt. Ce n’est pas un réglage officiel de macOS, donc annule-le si ton Mac recourt beaucoup au swap ou devient instable.
Utilise le --think option : ollama run inkling-2-mini --think=low. Ollama accepte aucun, minimal, faible, moyen, élevé (par défaut), xhigh et max, qu’il envoie au modèle sous forme de valeurs d’effort de 0 à 0,99. Dans un chat, /set nothink définit le niveau le plus bas et masque le raisonnement. Même le minimum ne désactive pas complètement le raisonnement.
Pi, car son prompt système et ses outils font moins de 1 000 tokens, ce qui garde les prompts courts : ollama launch pi --model inkling-2-mini. Mais Pi exécute des commandes sans demander, donc ne l’utilise que dans un dossier jetable. OpenCode démarre avec environ 6 900 tokens et fonctionne avec un contexte de 32K, idéal sur un M2 Pro. Il demande avant d’agir une fois que tu ajoutes deux règles de permission à sa config. Claude Code demande par défaut, mais sa première requête mesurait environ 32 800 tokens, plus qu’un contexte de 32K ne peut contenir, donc c’est mieux à partir de 48 Go.
Très probablement, le prompt ou la conversation était trop long pour la mémoire GPU de ton Mac. Ollama 0.40.17 ne lit les prompts longs avec une méthode économe en mémoire que sur les M2 Pro, M2 Ultra, M3 Ultra, M4 Pro et M5 Pro, Max et Ultra. Sur les autres puces, l’usage de mémoire croît avec tout ce que le modèle a lu, et un M2 Max 32 Go a planté après 12 288 tokens. Ferme les autres applis, garde des sessions courtes, utilise Pi, augmente le budget GPU et tiens Ollama à jour.
Dans le seul test Ollama publié sur un Mac 32 Go, un M2 Max, une requête courte a tourné à environ 24 tokens par seconde. Sur un M4 Pro 48 Go avec Ollama 0.40.17, il a écrit à environ 32 tokens par seconde et lu un prompt de 12 000 tokens à 279 tokens par seconde. Les Mac M4 et M5 de base ont une bande passante mémoire bien plus faible et devraient être plus lents ; aucune mesure n'a encore été publiée.
Pas avec le paquet d’Ollama, qui est une version unique de 20 Go, et Thinking Machines considère 32 Go comme le minimum. Unsloth publie des fichiers 2 bits et 3 bits d’environ 9 à 14 Go qui tournent avec sa propre compilation de llama.cpp sur des Mac plus petits. Ils coûtent un peu de qualité et demandent plus de configuration.
Pas quand il tourne en local. Ollama exécute le modèle sur ton Mac, et sa FAQ indique qu’il ne voit pas tes prompts ni tes données quand tu l’exécutes en local. Les agents de codage lancés avec ollama launch communiquent avec Ollama à localhost:11434, sur ta propre machine. Les modèles cloud et la recherche web sont différents : ils envoient des données aux serveurs d’Ollama, et tu peux les désactiver avec le réglage Cloud. Les agents sont des programmes séparés avec leurs propres outils réseau, comme le web fetch d’OpenCode, donc vérifie leurs réglages si tu dois travailler entièrement hors ligne.
Pas dans Ollama 0.40.17, dont les notes de version indiquent qu’Inkling 2 Mini n’est pris en charge que sur Apple silicon dans cette version. Sur du matériel NVIDIA, Thinking Machines prend en charge vLLM et SGLang, et la compilation llama.cpp d’Unsloth fait tourner ses fichiers GGUF. Une version ultérieure d’Ollama pourrait ajouter d’autres plateformes.
Courir ollama rm inkling-2-mini. Supprime toutes les copies que tu as créées avec ollama create, comme inkling-2-mini-32k, de la même façon : les 20 Go de poids sont libérés dès qu’aucun modèle ne les utilise. Pour supprimer Ollama lui-même, quitte-le, supprime-le du dossier Applications et supprime le .ollama dossier dans ton dossier personnel ; la documentation macOS d’Ollama répertorie chaque fichier.
En résumé
Inkling 2 Mini est un modèle ouvert performant que son créateur prend en charge sur un Mac de 32 Go, et Ollama rend l’essentiel vraiment simple : installer, récupérer, lancer. Pour le chat, les documents et les questions sur des images, un Mac de 32 Go suffit.
C’est avec les agents que 32 Go deviennent justes, pour deux raisons. Ollama démarre la plupart des Mac de 32 Go avec une fenêtre de contexte de 4K, ce qui casse discrètement les agents tant que tu ne la changes pas. Et sur la plupart des puces 32 Go, les longs prompts peuvent encore manquer de mémoire, car la lecture de prompt économe en mémoire d’Ollama ne couvre que certaines puces. Alors règle la fenêtre de contexte, augmente le budget GPU et ferme ton navigateur. Commence avec Pi dans un dossier jetable, et mets Ollama à jour souvent.
Si tu as un M2 Pro, tu es dans la meilleure position possible pour un Mac de 32 Go aujourd’hui. Si tu as 48 Go ou plus, la plupart des réserves ici disparaissent. Et quel que soit le Mac que tu as, ollama run inkling-2-mini --verbose t’en dit plus sur ta propre machine en cinq minutes que n’importe quel tableau de ce guide.
Tu fais tourner Inkling 2 Mini sur un Mac de 32 Go ? Partage ta puce, ta version d’Ollama, ton réglage de contexte et --verbose tes chiffres dans les commentaires, surtout depuis un M1, M4 ou M5. J’ajouterai les résultats les plus utiles à la partie 8, avec crédit. Les corrections sont bienvenues aussi : avec un support aussi récent, certains détails d’aujourd’hui changeront vite.
Mention légale : Ce guide contient un seul lien d'affiliation, vers Z.ai’s GLM Coding Plan (dans la partie 10). En t'abonnant via ce lien, tu obtiens 10 % de réduction et je peux toucher une commission, sans coût supplémentaire pour toi. Aucun autre produit ni aucune autre entreprise cité dans ce guide n'est sponsorisé, et aucun d'eux ne l'a relu avant publication.
Faits vérifiés : 21 novembre 2026.



