FR
Réserver un appel

IA locale

TensorFold : le moteur qui rend les LLM locaux 2 à 3× plus rapides — sans qu'un seul token ne change

Par Michael Kerkhoff, Founder & Managing Director11 min de lecture

TensorFold : le moteur qui rend les LLM locaux 2 à 3× plus rapides — sans qu'un seul token ne change

Mercredi soir, Ash Hart publie sur X : « I didn't imagine it to blow up like this. » Trois jours plus tôt, son projet TensorFold dépassait les 800 étoiles sur GitHub. Le même jour sort la version 0.6.1 — la douzième release en cinq jours. Ce qui a commencé comme une expérience d'un week-end « pour rendre Qwen 27B plus rapide » est devenu le moteur d'inférence à la croissance la plus rapide de la scène IA locale. La raison tient en une promesse que personne d'autre ne tient sous cette forme : TensorFold est plus rapide, sans qu'un seul octet de la sortie ne change.

Qu'est-ce que TensorFold ?

TensorFold est un moteur d'inférence open source (Apache-2.0) qui sert les LLM locaux derrière un point d'accès compatible OpenAI — sur Apple Silicon (Metal/MLX) comme sur les GPU NVIDIA, DGX Spark comprise. Une seule commande suffit :

bash
pip install git+https://github.com/ashhart/TensorFold.git
tensorfold serve Vontra/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-MLX-4bit --context 65536

Le serveur télécharge le modèle depuis Hugging Face, construit des kernels Metal ou CUDA propres à chaque famille et expose /v1/chat/completions. N'importe quel client OpenAI — agents de code, SDK, curl — fonctionne sans modification.

Derrière le projet se trouve Ash Hart, architecte indépendant en systèmes d'IA basé au Royaume-Uni, également auteur de MCDMA (Metal-CUDA Direct Memory Access) et d'Imprint. Il travaille sur le projet en parallèle de son emploi à temps plein, désormais épaulé par deux noms connus de la scène : MiaAI-Lab et Volatile Markets ont officiellement rejoint l'équipe centrale.

Le trait distinctif : du décodage assisté à l'octet près

Le gain de vitesse vient du décodage spéculatif : un petit modèle de brouillon (DFlash2 ou une tête MTP) devance plusieurs tokens, et le grand modèle les vérifie par lots dans des « lanes » — plusieurs lignes de brouillon en une seule passe. En soi, rien de neuf ; vLLM sait aussi faire du MTP.

Ce qui est nouveau, c'est le contrat d'exactitude. TensorFold garantit qu'une réponse assistée est identique à l'octet près à la même requête sans brouillon. Pour cela, le projet écrit ses propres kernels exacts par ligne : les bits d'une ligne ne peuvent pas dépendre du nombre de lignes qui partagent la passe de vérification. L'échantillonnage est indexé — le token à la position p est dérivé de façon déterministe à partir de la graine, de la position et de l'identifiant du token. La formule du recipe book : « Drafted decoding writes the same bytes as serial decoding. Drafts change speed only. »

Chaque release le vérifie empiriquement : chaque réponse assistée est comparée octet par octet à la même requête avec "draft": false. Le serveur rapporte un hash token_sha et min_rows par réponse. Pour le vérifier vous-même, envoyez deux fois le même prompt — avec et sans brouillon — et comparez les sorties.

Les chiffres

Sur DGX Spark (GB10), TensorFold se situe de 1,6 à 3 fois au-dessus de vLLM avec MTP selon le modèle — mesuré via le même client OpenAI, médiane sur cinq graines :

ModèleSparksvs. vLLM (MTP=3)
Qwen3.8-27B + DFlash212,70–3,05×
Qwen3.8-27B + DFlash221,94–2,49×
Qwen3.8 Flash Next11,60–1,79×
Qwen3.8 Flash Next21,74–2,24×
GLM-5.3-Flash21,78–2,06×

Concrètement : GLM-5.3-Flash sur deux Sparks décode à 63 tok/s ; Qwen3.8-27B sur un seul Spark atteint 58,3 tok/s en prose single-stream et 220 tok/s à 8 streams. Sur un M3 Ultra (sans les unités tensorielles du M5), Qwen3.8-27B est passé de 27 à 131–160 tok/s.

À garder en tête : ce n'est pas un tour de quantification. Mêmes checkpoints 4 bits, même qualité — le moteur exploite simplement mieux chaque lecture de poids.

La communauté fait le reste

Ce qui distingue TensorFold de projets comparables, c'est le rythme et l'ouverture. Rien que ces derniers jours : le support RTX 40 (Ada), la RTX PRO 6000 Blackwell avec checkpoints NVFP4, l'API Responses, les métriques Prometheus, le passage à Apache-2.0 — et un flot de PR communautaires remerciées nommément dans les release notes.

MiaAI-Lab a publié toute une collection de recettes sur TensorFold : GLM-5.3-Flash EXL3 sur 2× DGX Spark (avec 1M de contexte, 4 streams, un pool KV de 2,9M tokens), Qwen3.8-27B sur un seul Spark, et bientôt selon ses annonces des recettes 3× et 4× Sparks pour DeepSeek v4.1 Flash. Chaque recette arrive avec sa page dédiée et ses mesures — et nous avons déjà ajouté la recette GLM-5.3-EXL3 à notre base de données de recettes Local-AI.

Notre test de résistance : un cluster 2× GB10 (ASUS GX10) via un switch MikroTik CRS504 au lieu d'un câble direct, GPU plafonnés à 2 200 MHz, reproduction des chiffres du README avec sparkDash. Résultat : décodage à ±5 % de la référence, sorties structurées à 2 et 4 streams même +11–14 % au-dessus, prefill à 3–5 %, 1M de contexte complet. Les chiffres des recettes se reproduisent donc hors du matériel d'origine — un switch au lieu d'un câble ne coûte presque rien.

Les limites honnêtes

Trois points à connaître :

La concurrence est le compromis. Un benchmark communautaire de WescheNex1q le dit sobrement : à 16 requêtes parallèles sur un Spark, vLLM bat nettement TensorFold (253 contre 62 tok/s en agrégé) ; à une seule requête, TensorFold gagne (83 contre 57). TensorFold est le moteur mono-utilisateur le plus rapide qui existe — pour un serveur d'équipe avec des dizaines d'agents simultanés, vLLM reste le choix. Les releases actuelles travaillent précisément sur ce point (prompts qui remplissent pendant les tours de décodage, priorités en arrière-plan), mais la bataille est ouverte.

Le prefill n'accélère pas sur Mac. Le gain de vitesse vit dans le décodage ; sur Apple Silicon, le débit de prefill est comparable aux autres moteurs. Sur CUDA, c'est nettement mieux grâce aux CUDA graphs et à l'optimisation des kernels (jusqu'à 1,27× vLLM sur les longs prompts).

Un mainteneur avec un emploi du temps plein. Sept releases en 34 heures le week-end de lancement — impressionnant, mais aussi un bus factor de 1. L'arrivée de MiaAI-Lab et de Volatile Markets est la réponse directe, et les PR communautaires affluent. Pour la production, cela signifie quand même : figer les versions, lire les changelogs.

Autre point souvent négligé : TensorFold mesure sa propre qualité. Pour les checkpoints NVFP4, le projet publie la concordance top-1 contre une passe de référence fp32 (92,9 % en mathématiques du checkpoint contre 93,0 % pour vLLM) — au lieu de ne célébrer que les tok/s. C'est cohérent pour un projet dont toute la promesse est « same bits ».

À qui s'adresse TensorFold ?

  • Possesseurs de DGX Spark et de Mac : gain net, avec le même serveur et la même sortie sur les deux plateformes. Sur une configuration à 2 Sparks, GLM-5.3-Flash tourne avec 1M de contexte sur du matériel grand public.
  • Utilisateurs d'agents de code : arguments d'appels d'outils en streaming, API Responses, cache de prompt (prompts de 18k renvoyés : de plusieurs secondes à moins de 0,1 s) — exactement ce dont les boucles d'agents ont besoin.
  • Opérateurs de serveurs d'équipe : patientez encore un peu ou restez sur vLLM. Le travail sur la concurrence est en cours mais pas terminé.

TensorFold montre à quelle vitesse l'inférence locale progresse quand quelqu'un écrit lui-même les kernels au lieu de configurer les défauts d'un framework. En 2025, la scène IA locale a appris à faire tourner les modèles en local. En 2026, elle apprend à les faire tourner vite — et TensorFold en est l'exemple le plus visible. Quels checkpoints et quelles recettes existent pour quel matériel : notre hub Local-AI le met en lumière avec sa base de recettes publique — des mesures testées plutôt que des chiffres marketing.

FAQ

TensorFold est-il un modèle ou un moteur ? Un moteur. TensorFold remplace le serveur d'inférence (vLLM, SGLang ou ollama par exemple) et charge des checkpoints existants depuis Hugging Face. Le modèle lui-même — Qwen3.8-27B, GLM-5.3-Flash, Nemotron 3.5 Lightning, Qwen3.8 Flash Next — reste inchangé ; les poids, et donc l'intelligence, sont exactement les mêmes que sur n'importe quel autre serveur. Seule la façon dont les kernels les calculent change.

Comment un décodage accéléré peut-il être identique à l'octet près ? L'astuce tient dans la vérification : le modèle de brouillon ne fait que deviner, le grand modèle contrôle et ne garde que les tokens devinés qu'il aurait lui-même choisis. TensorFold écrit des kernels où une ligne du lot produit les mêmes bits qu'un décodage pas à pas, et rend l'échantillonnage déterministe à partir de la graine, de la position et de l'identifiant du token. Le résultat est automatiquement comparé au décodage sans brouillon à chaque release ; le serveur rapporte en plus un hash de token par réponse.

Faut-il une DGX Spark ? Non. TensorFold tourne sur Apple Silicon (du M1 au M5, chaque génération couverte par ses propres kernels) et sur les GPU NVIDIA de la série RTX 40 à la RTX PRO 6000 Blackwell en passant par la DGX Spark (GB10). Sur Mac, un pip install suffit ; sous Linux, c'est le plus propre dans le conteneur PyTorch de NVIDIA. Les chiffres de recettes les plus spectaculaires viennent de la communauté Spark, mais une RTX 4090 seule fait déjà tourner Qwen3.8-27B avec DFlash2 dans une fenêtre de 40k de contexte.

Qu'en est-il de la qualité avec la quantification ? Les checkpoints qu'utilise TensorFold (MLX 4-bit, EXL3/TR3 4bpw, NVFP4) sont créés par des tiers et indépendants du moteur. TensorFold n'y touche pas — le même fichier de checkpoint donne la même qualité que sous vLLM. Le projet se mesure aussi lui-même : en NVFP4, la concordance top-1 contre une référence fp32 est de 92,9 % (vLLM : 93,0 %), et de 98,9 % en mode pleine précision. Pour une qualité maximale, lancez --precision full sur les mêmes poids.

Puis-je faire tourner TensorFold pour plusieurs utilisateurs à la fois ? Dans une certaine limite. L'accent est mis sur quelques flux à faible latence — 4 à 8 sessions parallèles sont le point idéal sur DGX Spark, et les recettes sont accordées là-dessus. Avec des dizaines de requêtes simultanées, l'agrégat perd actuellement contre vLLM, dont le batching continu est optimisé pour la haute densité. Les releases actuelles (« prompts fill inside the decode rounds », priorités en arrière-plan) s'attaquent précisément à ce goulot, et l'écart se réduit de release en release.

Comment l'installer sur une DGX Spark ? Le plus confortable est une recette communautaire toute prête : MiaAI-Lab maintient un setup Docker (ghcr.io) qui configure TensorFold avec le parallélisme tensoriel sur deux Sparks, le réseau RoCE et le pool KV — il suffit de mettre ses identifiants SSH dans un local.sh et de lancer start.sh. À la main : démarrez le conteneur PyTorch de NVIDIA, installez TensorFold via pip, chargez les checkpoints avec tensorfold pull, puis lancez rank 1 (d'abord) et rank 0 sur les deux Sparks. Les runbooks pour agents IA du dépôt décrivent chaque étape pour qu'un agent de code puisse mener l'installation seul.

Sources

Un sujet pour votre équipe ? Parlons-en 30 minutes.

Nous identifions ce qui fonctionne vraiment dans votre entreprise — concret, sans avalanche de slides.

Réserver un appel Voir les formats

Sans engagement · 30 minutes · Devis sous 48 h