Needle : le modèle de 14 Mo qui veut faire tourner des agents sur des montres et des robots

Needle : le modèle de 14 Mo qui veut faire tourner des agents sur des montres et des robots

🔎 Un agent complet dans 14 Mo : le pari que personne ne prenait

En tête du GitHub Trending cette semaine : cactus-compute/needle, avec +3 838 étoiles en sept jours et environ 8 000 au total (GitHub Trending, octobre 2026). Un dépôt Python sous licence Apache-2.0, sans levée de fonds ni keynote. Juste un README qui tient une promesse qui semblait absurde il y a un an : un foundation model d'agent dans un binaire de 14 Mo.

Needle, développé par Cactus Compute, n'est pas un chatbot de poche de plus. C'est un modèle spécialisé dans une seule compétence — appeler des outils de façon fiable — pensé pour les appareils où les LLM cloud n'arriveront jamais : montres, capteurs, robots, habitacles de voiture, microcontrôleurs.

Pourquoi maintenant ? Parce que l'agentique vient de se heurter à un mur physique. Chaque appel d'outil vers le cloud coûte de la latence, de l'argent et un peu de vie privée. Pendant ce temps, la vague des micro-modèles s'accélère : un modèle de speech-to-text de 169 Mo qui bat Whisper Base, la vague des modèles 2-bit ternary. Needle pousse cette logique jusqu'au bout : et si l'agent entier tenait dans la RAM d'une montre ?

L'essentiel

• Needle (Cactus Compute) est un foundation model de tool-calling pour téléphones, wearables, maison connectée, robots, automobile et microcontrôleurs, livré en binaire unique de 8 à 29 Mo (GitHub, 2026).
• Needle 2 (45M de paramètres) tient une session complète en ~28 Mo de RAM grâce à la compression CQ2-bit — soit 5× à 70× plus petit que FunctionGemma 270M, LFM2.5 230M ou Apple FM à performance comparable.
• Needle 3 est un Laddered Simple Attention Network : chaque profondeur de 2 à 20 couches est un modèle déployable, et le modèle 121M fait l'arithmétique d'un 50M grâce à sa mémoire engram.
• Fiabilité par construction : une grammar de niveau octet, compilée depuis les schémas d'outils, contraint chaque token généré — le modèle ne peut pas inventer un appel d'outil hors schéma.
• À tester dès maintenant : démo navigateur, poids sur Hugging Face, pip install cactus-needle.

Outils recommandés

C'est quoi Needle, exactement ? — Réponse directe

Needle est un foundation model entraîné pour un unique métier : décider quand et comment appeler des outils, sur du matériel où un LLM classique ne rentre pas. Pas de rédaction d'essais, pas de brainstorming : un cerveau d'exécution.

Le paper de référence (Ndubuaku, Mosoyan, Mroz et al., « Needle: Foundation Tool-Calling Model for Tiny Devices », Cactus Compute, 2026) le positionne explicitement pour six terrains : téléphones, wearables, maison connectée, robots, automobile et microcontrôleurs.

Le livrable est aussi inhabituel que l'ambition : un binaire unique de 8 à 29 Mo selon la variante, plus un engine précompilé de moins de 1 Mo par plateforme. Pour situer l'ordre de grandeur : un LLM cloud grand public pèse des centaines de gigaoctets côté datacenter.

Needle 2 et Needle 3 : ce que change chaque génération

(Sources : README du dépôt officiel et paquet Python, octobre 2026.)

Si vous ne devez retenir qu'une version, c'est Needle 3 qui compte. La « ladder » — le fait que chaque profondeur de 2 à 20 couches soit un modèle déployable — change la manière de déployer, pas seulement la taille du fichier. J'y reviens plus bas.

L'architecture : pourquoi un modèle de 121M fait le travail d'un 50M

Needle tient dans 14 Mo parce qu'il ne ressemble pas à un LLM : la couche FFN, qui concentre la majorité des paramètres d'un transformer classique, a été remplacée par un Monarch Hadamard MLP qui ne stocke presque rien.

Dans un transformer standard, les couches feed-forward absorbent typiquement les deux tiers des paramètres. Ce sont d'énormes matrices de poids, lues en mémoire à chaque token. Sur un microcontrôleur, où la bande passante mémoire est le vrai goulot, ce simple fait disqualifie l'architecture classique.

Le Monarch Hadamard MLP remplace ces matrices par une transformation structurée, calculée en O(n log n) — à la manière d'une FFT — sans poids à lire en mémoire (analyse CoddyKit, octobre 2026). On calcule au lieu de stocker : le budget mémoire s'effondre.

Deuxième idée clé : la mémoire engram, un stockage n-gram lu par gather. La majorité des paramètres du modèle vivent dans cette table de consultation, pas dans des multiplications denses. Conséquence chiffrée annoncée : le modèle 121M de Needle 3 fait l'arithmétique d'un 50M. Capacité et coût de calcul sont découplés — c'est le renversement le plus intéressant du projet.

L'attention est elle aussi retravaillée : du grouped-query attention (GQA) agrémenté de causal conv taps, de courts filtres qui donnent au modèle une mémoire locale immédiate, et des multi-lane hyper-connections qui font circuler le signal sur plusieurs pistes parallèles au lieu d'une seule.

Est-ce que ça marche ? Le design et les ablations sont documentés dans le paper arXiv de juillet 2026. Les chiffres sont bons sur le papier ; il manque encore l'évaluation indépendante, comme pour tout projet sorti du trending. Mais l'approche est cohérente, et surtout reproductible : tout est open source.

La ladder : payer le modèle à la couche

Needle 3 est entraîné pour que chaque profondeur de 2 à 20 couches soit un modèle déployable. Le même fichier de poids sert un modèle de 2 couches pour un capteur à quelques euros et un modèle de 20 couches pour un hub domotique. On choisit le curseur qualité/latence/énergie au déploiement, pas à l'entraînement.

C'est, à mon avis, l'idée la plus sous-commentée du projet. La quantisation post-entraînement coupe la précision après coup ; ici, la profondeur est un paramètre de déploiement natif. On ajuste par appareil, sans réentraîner quoi que ce soit.

256 tokens, 5 outils, zéro appel hors schéma

Needle tient le double défi RAM/fiabilité avec trois mécanismes : une fenêtre glissante de 256 tokens où les outils sont épinglés en KV sinks, une tête de retrieval qui ne rend que les 5 meilleurs outils par tour, et une grammar de niveau octet qui contraint chaque token généré.

La fenêtre glissante de 256 tokens suffit pour du tool-calling, car un appel d'outil est un échange court, pas une conversation. Les outils épinglés en KV sinks restent visibles en permanence dans le cache d'attention pendant que la fenêtre glisse sur le dialogue : le modèle ne « redécouvre » jamais ses outils, ils sont structurellement présents.

Côté sélection, pas de catalogue de 300 outils empilé dans le prompt. Une tête de retrieval dédiée ne rend que les 5 meilleurs outils candidats par tour, et la grammar contrainte ne s'applique qu'à ce sous-ensemble. Le contexte reste minuscule, la décision reste pertinente.

La grammar de niveau octet, elle, est compilée depuis vos schémas d'outils. Elle contraint chaque token : le modèle ne peut physiquement pas émettre un nom d'outil inexistant ou un argument hors type. On est loin du JSON free-form des LLM cloud, qui hallucine encore régulièrement des clés inventées.

Dernière pièce : un score de confiance calibré par une tête apprise. Le modèle sait dire « je ne suis pas sûr » — et le programme hôte peut alors escalader vers un modèle plus gros, local ou cloud.

C'est, à mon sens, la bonne interface pour l'embarqué. La fiabilité d'un agent ne vient pas d'un prompt bien écrit, mais d'une contrainte structurelle appliquée à la génération. Needle l'a compris avant la plupart des frameworks.

14 Mo contre 540 Mo : les chiffres du comparatif

Sur les benchmarks des auteurs, Needle 2 offre des performances comparables à des modèles 5× à 70× plus gros, pour un fichier de 14 Mo contre 540 Mo à 2 Go en f16.

(Sources : README du dépôt et CoddyKit, octobre 2026.)

Le rapport va de 5× (LFM2.5) à 70× (Apple FM) en paramètres, et le facteur fichier est encore plus brutal : 2 bits par poids contre 16 en f16, soit un gain de compression de 8× sur la seule précision. La précision « à performance comparable » porte sur les tâches de tool-calling, le cœur de métier du modèle — pas sur la rédaction ou le raisonnement généraliste.

DroidCall : le fine-tuning qui bouscule la hiérarchie

Le README annonce aussi des fine-tunings sur DroidCall, un jeu de données d'appels d'outils : +18 à +36 points pour chaque sous-réseau, et dès 4 couches — environ 29M de paramètres — le sous-réseau fine-tuné passe DeepSeek V4 Flash.

À lire avec discernement : ce sont des chiffres publiés par les auteurs, sur leurs propres benchmarks, dans un domaine précis. Aucune évaluation indépendante n'a encore arbitré. C'est le lot de tout projet qui sort du trending : les benchmarks maison vont dans le sens de la maison.

Mais même avec une décote de prudence, la trajectoire est claire. Un modèle de 29M de paramètres qui rivalise avec un modèle géant sur son propre terrain, dans 30 Mo de RAM, signale que la hiérarchie des capacités n'est plus alignée sur la taille.

Où un agent de 14 Mo a du sens (et où il n'en a pas)

Needle vise les contextes où le cloud est lent, coûteux ou indisponible : wearables, maison connectée, robots, automobile et microcontrôleurs.

• Wearables : sur une montre, un agent qui détecte une chute et déclenche un appel d'urgence ne peut pas se permettre un aller-retour réseau. Latence locale, batterie préservée.
• Maison connectée : un hub local qui orchestre lumières, volets et chauffage sans envoyer vos habitudes de vie chez un tiers.
• Robots : les boucles de contrôle temps réel tolèrent mal les 300 ms d'un aller-retour cloud.
• Automobile : commandes et ajustements hors réseau, là où la couverture 4G disparaît.
• Microcontrôleurs : avec un engine de moins de 1 Mo, la cible est explicite — capteurs et objets à quelques euros.

Ce que Needle n'est pas : un raisonneur généraliste. Un agent qui doit planifier une stratégie en dix étapes, rédiger un rapport ou analyser un document reste du ressort d'un LLM — notre guide des meilleurs LLM pour agents détaille ce segment.

Le pattern gagnant, à mon sens, est hybride : Needle en exécuteur local, LLM cloud en planificateur d'escalade, le score de confiance servant de déclencheur. Dans une architecture multi-agents, Needle occupe naturellement le rôle de l'agent de proximité — celui qui agit quand le réseau ne suit pas.

Comment tester Needle dès aujourd'hui

Trois portes d'entrée, toutes gratuites : une démo dans le navigateur, un paquet pip, et les poids sur Hugging Face.

pip install cactus-needle

Le paquet Python permet de monter une session complète d'agent en quelques lignes. Le README annonce ~28 Mo de RAM pour Needle 2 — soit le budget d'un onglet de navigateur.

Les poids de Needle 3 sont sur Hugging Face en fichier unique de 8 à 29 Mo, accompagnés des engines précompilés de moins de 1 Mo par plateforme.

La démo navigateur est le meilleur point de départ pour se faire une opinion en cinq minutes, sans rien installer.

Un conseil de test : partez de trois ou quatre outils avec des schémas propres plutôt que d'un catalogue exhaustif. La tête de retrieval ne rend que cinq candidats par tour — la qualité de vos schémas pèse plus que leur nombre.

Pour situer Needle dans le paysage local plus large, voir notre sélection des meilleurs LLM locaux d'octobre 2026 et le guide des agents IA en local avec Ollama.

Ce que Needle révèle de la direction de l'IA en 2026

Needle n'est pas un cas isolé : c'est la pièce la plus extrême d'une tendance de fond — la spécialisation extrême des petits modèles pour l'agentique.

La preuve par l'écosystème récent : un modèle de speech-to-text de 169 Mo qui bat Whisper Base, un modèle voix open weights facturé 0,0025 $ la minute, la vague 2-bit ternary. Et côté agents, Laya propose un « modèle de décision » de 421M de paramètres pour remplacer le LLM dans vos agents — même philosophie : le bon modèle pour le bon travail.

En face, les frameworks s'organisent : Vercel eve veut faire pour les agents ce que Next.js a fait pour le web. Quand l'orchestration se standardise en haut de la pile, la couche d'exécution se spécialise en bas. Needle est cette couche.

Mon pari : la pile agentique de 2027 ressemblera à un sandwich — raisonneurs cloud massifs en haut, exécuteurs embarqués de quelques dizaines de mégaoctets en bas, et un protocole de confiance entre les deux. Le score de confiance calibré de Needle est un candidat sérieux pour ce protocole.

Reste deux inconnues : la résistance de l'engram au fine-tuning à grande échelle, et la capacité de l'écosystème à écrire des schémas d'outils propres — car une contrainte structurelle ne vaut que par la qualité de ce qu'elle contraint.

❌ Erreurs courantes

Erreur 1 : croire que Needle remplace un LLM conversationnel

Needle est un modèle de tool-calling, pas un assistant généraliste. Lui demander de rédiger ou d'analyser, c'est l'utiliser hors de son domaine. La solution : le voir comme un membre d'une pile d'agents, avec un LLM cloud ou local au-dessus pour le raisonnement.

Erreur 2 : comparer les tailles de fichiers sans tenir compte de la précision

Les 14 Mo de Needle 2 sont en CQ2-bit (2 bits), les ~540 Mo de FunctionGemma en f16 (16 bits). Le rapport de taille inclut un facteur de compression de 8×. La solution : benchmarker sur vos propres outils et vos propres appareils, pas sur les chiffres du README.

Erreur 3 : négliger la qualité des schémas d'outils

La grammar est compilée depuis vos schémas : un schéma ambigu produit un comportement contraint mais mauvais. Et la tête de retrieval ne rend que 5 outils par tour. La solution : des schémas propres, des descriptions précises, et un outillage curaté plutôt qu'exhaustif.

Erreur 4 : déployer à la profondeur par défaut sans profiler

La ladder de 2 à 20 couches est un paramètre de déploiement, pas un détail d'implémentation. La solution : profiler par appareil, partir bas, et monter la profondeur jusqu'à ce que le score de confiance se stabilise sur vos cas réels.

❓ Questions fréquentes

Needle est-il vraiment open source ?

Oui. Le code est sous licence Apache-2.0, les poids de Needle 3 sont en téléchargement libre sur Hugging Face, et le paper d'architecture est public sur arXiv depuis juillet 2026. Rien n'est réservé à une offre payante, ce qui reste rare pour un projet de cette ambition.

Quelle différence entre Needle 2 et Needle 3 ?

Needle 2 : 45M de paramètres, binaire de 14 Mo, session complète en ~28 Mo de RAM, compression CQ2-bit. Needle 3 : 121M de paramètres (efficacité arithmétique d'un 50M), fichier de 8 à 29 Mo, ladder de 2 à 20 couches déployables et engines de moins de 1 Mo par plateforme.

Needle peut-il vraiment tourner sur un microcontrôleur ?

C'est la cible affichée, avec un engine précompilé de moins de 1 Mo par plateforme. Le budget RAM réel dépend de la profondeur choisie dans la ladder et du nombre d'outils déclarés : à valider par profiling sur votre cible, pas sur la fiche produit.

Needle remplace-t-il GPT-5.5 ou Claude Opus 4.7 ?

Non, et ce n'est pas l'objectif. Needle exécute des appels d'outils en local ; les raisonneurs cloud planifient et rédigent. Les deux sont complémentaires dans une architecture d'agent, avec le score de confiance de Needle en point de passage entre les deux mondes.

Combien coûte Needle ?

Rien. Code sous Apache-2.0, poids gratuits sur Hugging Face, engines de moins de 1 Mo par plateforme (octobre 2026). Le seul investissement, c'est votre temps d'intégration — et il peut être substantiel sur une cible embarquée réelle.

✅ Conclusion

En faisant tenir un agent de tool-calling fiable dans 14 Mo, Needle ne rivalise pas avec les géants du cloud — il leur ouvre un front en dessous, celui des milliards d'objets qui n'ont ni réseau fiable ni 2 Go de RAM. Testez la démo navigateur, lisez le paper, et si le sujet des agents vous intéresse au sens large, notre sélection des meilleurs agents IA autonomes fait le tour du paysage.