top of page

Un test de LLM local d’OpenClaw révèle un démarrage à froid de 70 secondes

il y a 1 jour
14 min de lecture

OpenClaw a mis 70 secondes à fournir sa première réponse dans l’expérience sur un seul GPU du développeur Talha Anwar, malgré des réponses bien plus rapides lors des échanges suivants. Le test de LLM local d’OpenClaw révèle une tension concrète : une génération de texte rapide ne garantit pas un assistant réactif. Un LLM local, c’est-à-dire un modèle de langage exécuté sur le matériel de l’opérateur, a toujours besoin de mémoire, d’instructions et d’un accès fiable aux outils.

Anwar a décrit l’expérience dans un article de SitePoint publié le 13 novembre 2026. Sa configuration associait OpenClaw, un framework d’assistant reliant les modèles à des outils et à des canaux de messagerie, à Ollama, un logiciel permettant de servir des modèles de langage. Une interface Discord privée fournissait le canal de conversation.

Ces résultats remettent en question un raccourci d’achat courant : choisir le modèle d’un agent principalement selon sa vitesse de génération et sa compatibilité matérielle. L’exigence concurrente est d’accomplir utilement des tâches sur l’ensemble d’une session. Les observations d’Anwar offrent un cas concret pour examiner cette différence, même si elles n’établissent pas de classement général des assistants locaux et hébergés.

Ce que le test de LLM local d’OpenClaw a réellement mesuré

Il s’agissait du rapport de déploiement d’un développeur individuel, avec des mesures réalisées sur une seule machine et un ensemble limité de tâches.

Anwar a exécuté l’assistant sur une NVIDIA RTX 3090 dotée de 24 Go de mémoire graphique. Le modèle de chat était qwen3.5:9b, servi via Ollama. Ici, l’étiquette 9B désigne un modèle comptant environ neuf milliards de paramètres, les valeurs apprises qui façonnent ses réponses.

Son expérience d’agent sur un seul GPU a signalé une différence frappante entre les réponses initiales et suivantes. La première réponse a pris 70 secondes, dont 59 secondes pour charger le modèle et environ 10 secondes pour traiter son entrée. Les échanges ultérieurs mis en cache ont pris de 1,9 à 5 secondes.

Le même rapport a enregistré une génération de sortie de 91 à 96 tokens par seconde. Les tokens sont les unités de texte qu’un modèle traite et génère. Ces chiffres décrivent la génération après les autres opérations ; ils ne doivent donc pas être interprétés comme des temps de réponse complets.

Cette distinction change la manière dont les lecteurs doivent interpréter l’expérience. Un modèle peut écrire rapidement une fois prêt tout en faisant attendre l’utilisateur avant que cette rédaction ne commence. La vitesse perçue d’un assistant dépend donc du chemin menant à la génération autant que de la génération elle-même.

Anwar a également testé des comportements allant au-delà de la conversation ordinaire, notamment des tâches sur des fichiers d’espace de travail. L’assistant a exécuté certaines demandes, mais répondait parfois sans vérifier les informations disponibles via ses outils. Une instruction explicite d’utiliser un outil de lecture a corrigé une défaillance signalée.

Cette observation ajoute une seconde dimension aux résultats de chronométrage. Le résultat pertinent est de savoir si l’assistant termine correctement la tâche demandée, dans un délai acceptable. Un temps de réponse court a une valeur limitée lorsque la réponse exige une instruction supplémentaire avant que l’agent ne vérifie ses éléments de preuve.

Le rapport doit aussi être distingué d’un lancement de produit ou d’une annonce de benchmark formel. Il documente une configuration existante dans les conditions d’un seul opérateur. Il n’établit pas que chaque déploiement d’OpenClaw présente la même taille de prompt, le même délai ou le même schéma de défaillance.

Sa contribution immédiate est plus précise : il identifie les mesures qu’il vaut la peine d’exiger lorsqu’une personne affirme qu’un GPU grand public peut prendre en charge un agent utile. La compatibilité matérielle répond à la question de savoir si un modèle fonctionne. Les mesures de session commencent à répondre à la question de savoir si l’assistant qui en résulte convient au travail de quelqu’un.

Cette distinction importe aux développeurs qui évaluent aujourd’hui des déploiements similaires. L’expérience fournit un point de départ concret pour les questions de disponibilité, de demandes récurrentes et de vérification des tâches. Elle laisse les affirmations de performance plus larges à des comparaisons contrôlées avec des charges de travail équivalentes.

Une question courte transporte toujours les instructions de l’agent

Le message de l’utilisateur ne représente qu’une partie du travail qu’un agent envoie à son modèle.

Anwar a indiqué qu’une brève question produisait une entrée contenant 18 415 tokens, suivie de seulement 33 tokens de sortie. Ce déséquilibre illustre la surcharge de prompt d’OpenClaw : les instructions environnantes peuvent l’emporter sur la demande visible.

Un agent a besoin d’informations sur ses responsabilités, les outils disponibles et son environnement de travail. Ces éléments peuvent l’aider à se comporter de manière cohérente entre les tâches. Ils consomment aussi du contexte, c’est-à-dire les informations accessibles au modèle lors d’une demande particulière.

La documentation d’OpenClaw sur la comptabilisation du contexte explique que les instructions système, l’historique de conversation, les résultats d’outils et les autres éléments fournis comptent dans ce contexte. Cela étaye le mécanisme général derrière l’observation d’Anwar. Cela n’établit pas que la taille précise de son entrée soit inévitable.

La pression s’exerce en partie sur les développeurs de frameworks. Chaque instruction incluse par défaut doit justifier le traitement et le contexte qu’elle consomme. Ajouter une capacité peut étendre ce que l’assistant sait faire, même lorsque la demande en cours n’a jamais besoin de cette capacité.

Cela crée un compromis de conception concret. Des instructions larges peuvent rendre les capacités détectables, tandis que des instructions sélectives peuvent réduire la taille des demandes individuelles. Aucune des deux approches ne mérite un verdict général à partir de cette expérience, car la réussite des tâches doit accompagner toute comparaison de taille d’entrée.

Pour les développeurs intégrant un assistant, la leçon porte sur les limites de mesure. Un petit message utilisateur ne doit pas être traité comme la preuve d’une petite demande au modèle. L’application assemble la charge de travail réelle, et cette charge mérite d’être examinée.

Les compteurs de tokens signalés exigent également une manipulation prudente. Anwar a décrit une estimation OpenClaw de 24 608 tokens pour un budget de prompt de 24 576 tokens. Ollama a signalé un nombre différent pour l’entrée qu’il a traitée.

Ces chiffres ne doivent pas être combinés comme s’ils provenaient du même instrument. L’estimation d’une application et le décompte d’un serveur de modèle peuvent décrire différentes étapes de comptabilisation. Sans réconcilier ces étapes, l’écart ne peut pas établir exactement quel contenu a atteint le modèle ou ce qui a été omis.

Pour les acheteurs d’entreprise, l’implication est opérationnelle plutôt qu’abstraite. Un assistant évalué au moyen de démonstrations brèves peut se comporter différemment une fois que les instructions, les documents de travail et l’historique de conversation s’accumulent. Les évaluations doivent préserver les conditions de contexte attendues pendant le travail ordinaire.

Les travailleurs du savoir sont confrontés à une question connexe : l’assistant dispose-t-il des éléments de preuve pertinents lorsqu’il répond ? Une grande entrée ne signifie pas automatiquement que ces éléments sont actuels, complets ou correctement consultés. Le volume de contexte et la qualité des preuves nécessitent un examen distinct.

Les lecteurs qui explorent les connaissances techniques consultables rencontrent la même distinction entre stocker des informations et récupérer le bon contenu. Un agent ajoute une responsabilité supplémentaire : décider quand vérifier ce contenu avant d’agir.

La surcharge de prompt d’OpenClaw importe donc au-delà de son effet sur la vitesse. Elle façonne l’espace restant pour la tâche réelle. La comparaison utile porte sur des configurations qui accomplissent un travail équivalent, avec leurs instructions complètes et leurs éléments de preuve inclus.

Les démarrages à froid et les réponses mises en cache décrivent des expériences différentes

La plus grande différence de temps dans l’expérience est apparue avant la génération soutenue de texte.

Un démarrage à froid d’Ollama se produit lorsqu’une demande arrive alors que le modèle nécessaire est déchargé et doit être amené en mémoire. Cette condition explique une grande partie de l’attente initiale d’Anwar. Elle fait également des temps de réponse ultérieurs un état de fonctionnement distinct.

Les métriques de performance d’Ollama distinguent le chargement du modèle, l’évaluation du prompt et la génération de sortie. Ces catégories aident à expliquer pourquoi un seul chiffre de vitesse peut déformer le comportement d’un assistant. Chaque catégorie mesure une partie différente de la demande.

L’évaluation du prompt, souvent appelée prefill, consiste à traiter l’entrée avant de générer une réponse. La grande entrée initiale d’Anwar a créé du travail pendant cette étape. Selon son rapport, les échanges suivants ont bénéficié de la réutilisation de matériel précédemment traité.

La mise en cache consiste à conserver des calculs antérieurs afin que des demandes compatibles puissent les réutiliser. Ses avantages dépendent de ce qui reste réutilisable et disponible. Les lecteurs doivent donc éviter de transformer un échange mis en cache favorable en promesse concernant chaque interaction future.

Cette distinction apparaît aussi dans des logiciels de service concurrents. La documentation du projet vLLM sur la mise en cache des préfixes décrit la réutilisation de calculs pour des débuts d’entrée partagés. Elle distingue explicitement la réduction du traitement de l’entrée du travail séparé de génération de sortie.

Cette comparaison apporte un contexte technique, et non un concours de performances. Anwar n’a pas publié de comparaison vLLM équivalente dans cette expérience. Rien ne permet ici de déclarer qu’un système de service est plus rapide sur sa charge de travail.

La question commerciale est de savoir quel état de fonctionnement ressemble à l’usage réel. Une personne menant une conversation prolongée rencontrera peut-être surtout un modèle prêt et une entrée réutilisable. Une personne envoyant des demandes occasionnelles pourrait rencontrer des conditions différentes, rendant le comportement au démarrage plus pertinent.

Aucun des deux schémas n’est intrinsèquement le benchmark correct. Le problème survient lorsque des résultats d’un schéma sont utilisés pour vendre l’autre. Une évaluation utile indique l’espacement des demandes, l’état de préparation du modèle et les conditions de réutilisation en parallèle du temps de réponse.

La documentation des paramètres de rétention en mémoire d’Ollama indique que les modèles restent chargés pendant cinq minutes par défaut. Les opérateurs peuvent modifier ce comportement via des contrôles de rétention. Anwar a déclaré ne pas avoir changé ce paramètre durant son expérience.

Maintenir un modèle disponible implique un choix de ressources. L’opérateur réserve de la mémoire pour la réactivité au lieu de rendre immédiatement cette mémoire disponible ailleurs. La pertinence de cet arrangement pour une station de travail dépend de ses autres usages et de l’utilisation attendue de l’assistant.

Cela rend le démarrage à froid d’Ollama pertinent pour la conception de produit autant que pour l’infrastructure. Une interface doit représenter fidèlement l’attente si le modèle demandé est encore en cours de chargement. Sinon, les utilisateurs ne peuvent pas distinguer une préparation attendue d’un assistant non réactif.

Le test de LLM local d’OpenClaw suggère également la prudence vis-à-vis des temps de réponse moyens. Une moyenne peut masquer des expériences différentes entre le démarrage et la conversation continue. Signaler ces conditions séparément rendrait les futurs résultats plus faciles à interpréter et à comparer.

Pour les acheteurs, la demande appropriée est simple : montrer le chemin complet de la demande dans des conditions d’utilisation réalistes. La vitesse de génération reste une information utile, mais l’utilisateur subit l’attente cumulée de la préparation, du traitement, du travail des outils et de la livraison.

La mémoire du modèle ne décrit pas l’ensemble de l’assistant

Le budget de ressources d’un déploiement doit inclure les composants qui prennent en charge le modèle de chat.

Anwar a signalé 6,3 Go pour le modèle de chat et 5,1 Go pour un modèle d’embedding distinct, soit 11,4 Go au total. Un modèle d’embedding convertit le contenu en représentations numériques qui prennent en charge la recherche par similarité. Dans cette configuration, il contribuait au travail de l’assistant lié à la mémoire.

Ces chiffres décrivent les allocations de modèle rapportées. Ils n’établissent pas le besoin total en mémoire après le stockage du contexte et les autres surcharges d’exécution. Considérer leur somme comme un minimum de déploiement exact surestimerait ce que le rapport a mesuré.

Ce point compte, car les discussions sur le matériel commencent souvent par le seul modèle de chat. Un assistant peut mobiliser des composants supplémentaires de récupération, de stockage et de traitement. Qu’un modèle tienne confortablement à lui seul ne permet pas de conclure que l’application qui l’entoure tient tout aussi confortablement.

Pour l’achat, cela implique de demander des éléments probants propres à la charge de travail. Les acheteurs devraient demander ce qui fonctionnait en parallèle du modèle lors d’une démonstration et ce qui en était exclu. Cette question devient plus importante lorsque la même machine héberge d’autres applications.

Les développeurs doivent également distinguer les capacités installées de la consommation active de ressources. La présence d’un composant ne révèle ni quand il s’exécute ni combien de temps il conserve des ressources. Les traces d’activité constituent de meilleures preuves qu’un inventaire de logiciels.

Le rapport d’Anwar a identifié un heartbeat planifié s’exécutant toutes les 30 minutes. Un heartbeat est une vérification récurrente en arrière-plan qui peut activer un assistant sans nouveau message de l’utilisateur. Sa présence signifie qu’une conversation visible n’était pas la seule source possible de requêtes au modèle.

Toutefois, Anwar n’a pas mesuré l’effet de chargement à froid entre ces vérifications planifiées. L’intervalle du heartbeat et la période de rétention par défaut documentée d’Ollama soulèvent une question légitime. Ils n’établissent ni la durée réelle ni la consommation de ressources de chaque événement en arrière-plan.

Cette limite est importante pour un compte rendu équitable. Un mécanisme plausible peut orienter l’expérience suivante sans devenir un résultat observé. Affirmer des retards de démarrage répétés nécessiterait des mesures montrant l’état de préparation du modèle et le timing des requêtes durant ces événements.

La responsabilité incombe ici aux opérateurs d’applications et aux mainteneurs de frameworks. Le comportement en arrière-plan doit être suffisamment visible pour que quelqu’un puisse expliquer quand l’assistant s’exécute. Sinon, un service supposément inactif peut devenir difficile à comprendre.

Le déploiement local exige également une description précise de la confidentialité. Exécuter le modèle de langage sur du matériel local décrit où se produit l’inférence, c’est-à-dire le calcul qui génère les réponses. Cela ne décrit pas à lui seul chaque service participant au flux de travail.

Anwar a utilisé Discord comme canal d’interaction. L’expérience ne doit donc pas être présentée comme la preuve d’un chemin de communication entièrement hors ligne. L’emplacement où le modèle est servi et le canal de messagerie sont des parties distinctes de l’architecture.

Pour une organisation traitant des informations internes, cette distinction doit figurer dans l’examen du déploiement. La question pertinente est de savoir où chaque catégorie de données circule et persiste. Un modèle local peut répondre aux exigences d’une organisation, mais c’est le flux de travail complet qui détermine si ces exigences sont satisfaites.

Les questions de ressources et de confidentialité convergent vers la même discipline d’achat. Évaluez l’assistant tel qu’il est déployé, y compris les modèles de soutien, les tâches planifiées et les services connectés. La spécification du modèle de chat n’offre qu’une vue partielle.

Une réponse rapide nécessite toujours des preuves issues de l’espace de travail

La limite la plus importante du rapport concerne la vérification des informations par l’agent avant de répondre.

Anwar a décrit des cas où le petit modèle s’appuyait sur le contexte fourni au lieu d’utiliser des outils pour examiner son espace de travail. Dans un cas, le fait de nommer explicitement l’outil de lecture l’a conduit à vérifier un fichier avec succès. Cela distingue la disponibilité d’un outil de sa sélection fiable.

L’appel d’outils consiste à demander à un logiciel d’effectuer une opération, comme lire un document, puis à utiliser le résultat renvoyé. Un modèle peut prendre en charge ce mécanisme tout en choisissant de l’utiliser de manière incohérente. Une intégration réussie n’établit donc pas un comportement fiable dans l’exécution des tâches.

Cette distinction est importante, car le langage naturel peut masquer un travail incomplet. Une réponse peut sembler raisonnable même lorsque l’assistant n’a jamais vérifié la source qui détermine son exactitude. Pour l’utilisateur, l’opération manquante peut être moins évidente qu’un message d’erreur.

C’est là que la surcharge de prompts d’OpenClaw rencontre un problème d’évaluation plus difficile. Davantage d’instructions peuvent préciser quand les outils doivent être utilisés, mais le volume d’instructions ne peut à lui seul établir le respect de ces consignes. Le résultat doit toujours être vérifié au regard de ce que la tâche exigeait.

Une instruction explicite d’utiliser un outil offre un diagnostic utile. Elle peut montrer que l’opération fonctionne lorsqu’elle est directement demandée. Cependant, elle n’établit pas que l’assistant reconnaîtra le même besoin face à une demande formulée différemment.

Cela limite l’interprétation que l’on peut donner à cette correction réussie. L’observation d’Anwar étaye une affirmation plus restreinte : l’assistant pouvait lire le fichier pertinent lorsqu’il en recevait l’instruction. Elle n’établit pas un jugement indépendant fiable pour l’ensemble des tâches liées aux fichiers.

Les conseils d’OpenClaw sur les modèles locaux présentent eux aussi le déploiement local comme un choix impliquant les capacités du modèle et des contraintes opérationnelles. La documentation fournit le point de vue du framework, tandis que le récit d’Anwar apporte une expérience utilisateur particulière. Aucun des deux ne remplace une évaluation répétée des tâches.

Pour les développeurs, l’enjeu est de fournir suffisamment d’éléments pour distinguer une demande ayant reçu une réponse d’une opération effectivement réalisée. Une réponse liée à un fichier devrait pouvoir être évaluée par rapport à l’état réel du fichier. Cette norme devient particulièrement importante lorsqu’un agent peut effectuer des modifications.

Les acheteurs en entreprise devraient demander comment les démonstrations ont été supervisées. Si un opérateur fournit à plusieurs reprises l’instruction d’outil manquante, l’évaluation inclut une assistance humaine. Cette assistance peut être acceptable, mais elle doit figurer dans l’explication de la manière dont le travail est accompli.

Les travailleurs du savoir rencontrent le même problème, avec une visibilité technique moindre. Un assistant qui répond à partir d’un ancien contexte peut créer un travail de vérification supplémentaire, même s’il répond rapidement. Le temps consacré à vérifier et corriger doit entrer dans toute évaluation pratique de son utilité.

Le rapport ne montre pas que tous les petits modèles présentent le même taux d’échec. Il n’établit pas non plus que les modèles hébergés accompliraient correctement ces tâches. Une comparaison équitable devrait maintenir constantes la tâche, les outils, les autorisations et la norme de vérification.

La tension centrale demeure entre la réactivité locale et l’exécution fiable de l’ensemble du flux de travail. Une meilleure vitesse de génération répond à une partie de cette tension. La collecte fiable de preuves en traite une autre, et aucun de ces résultats ne doit se substituer à l’autre.

Les prochaines preuves doivent couvrir le temps d’inactivité, l’exécution et le contexte

Les prochains résultats utiles devraient tester les conditions que ce rapport laisse sans réponse.

Premièrement, les mesures de suivi devraient examiner les requêtes après des périodes d’inactivité, y compris l’activité planifiée en arrière-plan. Les éléments pertinents comprennent la question de savoir si le modèle est resté chargé et le temps consacré par chaque requête à la préparation. Cela établirait si le délai initial se reproduit lors d’un usage ordinaire.

Un modèle prêt pendant des périodes d’inactivité représentatives renforcerait l’argument en faveur d’une utilisation occasionnelle réactive. Des retards de chargement répétés limiteraient cet argument, à moins que l’opérateur n’accepte une politique de rétention en mémoire différente. Dans les deux cas, le résultat serait préférable à une inférence du comportement à partir de la seule configuration.

Le heartbeat planifié mérite une attention particulière, car il introduit des requêtes en dehors d’une conversation active. Son comportement réel devrait être observé plutôt que reconstruit à partir du calendrier. Cela inclut la détermination de son effet éventuel sur l’état de préparation pour la prochaine requête utilisateur.

Deuxièmement, les évaluations futures devraient rapporter l’exécution vérifiée des tâches sous des formulations variées. Les questions portant sur l’espace de travail constituent de bons candidats, car les preuves attendues peuvent être inspectées directement. Les résultats devraient distinguer la sélection indépendante d’outils du succès obtenu après une instruction corrective explicite.

Une exécution constante sans sollicitation corrective renforcerait l’argument en faveur d’une délégation plus large. Une dépendance persistante à la supervision soutiendrait un rôle plus restreint avec des contrôles humains. Les deux résultats seraient utiles, à condition que l’évaluation décrive le travail et ses limites.

Cette mesure devrait préserver les échecs autant que les réussites. Ne montrer que la réponse finale corrigée masque l’interaction nécessaire pour l’obtenir. Les lecteurs ont besoin de suffisamment de contexte pour comprendre si un résultat rapporté reflète le comportement initial de l’assistant ou une récupération supervisée.

Troisièmement, les changements de framework qui réduisent le contexte inutile méritent des comparaisons correspondantes sur les mêmes tâches. Une entrée plus courte serait encourageante si la qualité des tâches restait stable. Des prompts plus courts associés à davantage d’instructions manquées révéleraient un compromis différent.

Ce signal compte, car la gestion du contexte se situe entre les capacités du modèle et la conception de l’application. Les améliorations dans ce domaine peuvent modifier la charge de travail sans nécessiter un GPU différent. Leur valeur pratique dépend toutefois de la préservation des informations nécessaires à des décisions correctes.

Ensemble, ces observations transformeraient un rapport utile sur un déploiement personnel en preuves plus solides pour les choix de déploiement. Elles rendraient également les comparaisons entre systèmes de service locaux plus significatives. L’objectif est une charge de travail équivalente, avec des hypothèses visibles et des résultats vérifiables.

Le test de LLM local d’OpenClaw donne déjà aux lecteurs une raison d’examiner l’assistant au-delà de l’étiquette de son modèle. Sa contribution la plus forte est un récit concret des endroits où l’attente et les erreurs sont apparues. Ses limites empêchent ce récit de devenir un verdict universel.

Avant de choisir un assistant local, demandez des preuves correspondant au travail que vous prévoyez. Demandez des mesures de démarrage après des périodes d’inactivité réalistes, vérifiez si les réponses dépendantes d’outils ont utilisé les preuves pertinentes et tenez compte des composants de soutien. Conservez les prompts correctifs dans l’évaluation au lieu de juger uniquement la réponse finale. Pour les flux de travail documentaires, vérifiez que l’assistant consulte le contenu actuel avant d’accepter sa réponse. Ces contrôles relient les affirmations de performance à un travail que vous pouvez inspecter. Ils facilitent également la comparaison des configurations sans confondre une conversation mise en cache avec un usage occasionnel. Le déploiement répondrait-il toujours à vos besoins lorsque le modèle démarre déchargé, que la conversation s’allonge et que la tâche demandée exige de vérifier un fichier ?

 
 

Commencez pour Gratuit

Un premier assistant IA local avec gestion des connaissances personnelles

Pour une meilleure expérience IA,

remio ne supporte que Windows 10+ (x64) et M-Chip Macs actuellement.

Votre partenaire IA au travail
Faites-en plus avec remio

Planifiez. Créez. Livrez.
Tout au même endroit.

bottom of page