<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jeremy Jouvance on Medium]]></title>
        <description><![CDATA[Stories by Jeremy Jouvance on Medium]]></description>
        <link>https://medium.com/@jeremyjouvance?source=rss-a8f29a31c1df------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Szvyulrtz_m_xG82_D_KnQ.jpeg</url>
            <title>Stories by Jeremy Jouvance on Medium</title>
            <link>https://medium.com/@jeremyjouvance?source=rss-a8f29a31c1df------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:48:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jeremyjouvance/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Programmatic tool calling : pourquoi les agents doivent écrire du code]]></title>
            <link>https://jeremyjouvance.medium.com/programmatic-tool-calling-pourquoi-les-agents-doivent-%C3%A9crire-du-code-edab0c905c75?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/edab0c905c75</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Tue, 26 May 2026 22:00:54 GMT</pubDate>
            <atom:updated>2026-05-26T22:00:54.403Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o0MKyDhfR1XVXf6Vkf6cjg.png" /></figure><p>La plupart des démos d’agents IA ont l’air simples.</p><p>Un utilisateur pose une question. Le modèle choisit un outil. L’application exécute cet outil. Le résultat revient au modèle. Le modèle raisonne à nouveau. Puis il appelle un autre outil.</p><p>C’est la boucle classique du tool calling.</p><p>Elle fonctionne très bien pour des tâches simples. Si le modèle doit appeler une API météo, chercher un document ou récupérer une ligne client, le pattern est propre.</p><p>Mais dès qu’on construit de vrais workflows agentiques, cette boucle montre ses limites.</p><p>Imaginez une demande comme :</p><blockquote><em>Vérifie tous les services de production, trouve ceux qui ont dépassé leur error budget cette semaine, compare avec la semaine dernière, puis résume les trois régressions principales.</em></blockquote><p>Avec du tool calling classique, le modèle risque de faire ceci :</p><ol><li>Lister les services.</li><li>Appeler un outil de monitoring pour le service A.</li><li>Lire le résultat.</li><li>Appeler le même outil pour le service B.</li><li>Lire le résultat.</li><li>Répéter pour chaque service.</li><li>Récupérer les logs, incidents et déploiements.</li><li>Garder tous ces résultats intermédiaires dans le contexte.</li><li>Enfin raisonner sur les données accumulées.</li></ol><p>Ce n’est pas vraiment de l’intelligence.</p><p>Une grande partie de ce travail est du code exécuté à travers une conversation.</p><p>Le programmatic tool calling change cela.</p><p>Au lieu de demander au modèle d’appeler les outils un par un, on lui demande d’écrire un petit programme qui appelle des outils autorisés dans une sandbox. Ce programme peut boucler, filtrer, agréger, joindre des données, gérer des retries et retourner uniquement le résultat utile au modèle.</p><p>Le modèle décide toujours ce qu’il faut faire.</p><p>Mais l’exécution répétitive passe dans le code.</p><p>C’est ça, le vrai changement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8JzZ9pVerleyV1bT2EQlzg.png" /></figure><h3>Le tool calling classique est une boucle de conversation</h3><p>La documentation OpenAI sur le function calling décrit très bien le pattern standard : l’application envoie des outils au modèle, le modèle émet un appel d’outil, l’application exécute le code correspondant, puis renvoie le résultat au modèle pour l’étape suivante.</p><p>Ce pattern est puissant.</p><p>Il donne au modèle accès au monde extérieur sans lui laisser exécuter n’importe quelle action directement.</p><p>Mais dans des workflows multi-étapes, il crée trois problèmes.</p><p>1: la latence s’accumule.</p><p>Chaque appel d’outil peut devenir une nouvelle passe modèle. Si la tâche demande vingt appels séquentiels, l’agent passe une grande partie de son temps dans la boucle d’inférence plutôt que dans le travail utile.</p><p>2: le contexte se pollue.</p><p>Chaque résultat intermédiaire revient dans le contexte du modèle, même quand il ne sert qu’à calculer une agrégation temporaire.</p><p>3: on demande au modèle de faire du travail que le code fait mieux.</p><p>Filtrer, trier, joindre, compter, gérer des retries, paginer ou vérifier des seuils ne sont pas des problèmes de langage.</p><p>Ce sont des problèmes de programmation.</p><p>C’est là que le programmatic tool calling devient intéressant.</p><h3>Ce que signifie vraiment programmatic tool calling</h3><p>Le programmatic tool calling signifie que le modèle écrit du code exécutable qui invoque des outils approuvés dans un environnement sandboxé.</p><p>Ce code peut appeler plusieurs outils, stocker des variables, exécuter des boucles, appliquer des conditions, transformer des données et renvoyer un résultat final.</p><p>Dans la documentation Claude, Anthropic décrit ce pattern avec du Python exécuté dans un code execution container. Quand un outil est appelé depuis le code, l’exécution peut être mise en pause, l’application fournit le résultat de l’outil, puis le code continue. Le point important : les résultats intermédiaires n’ont pas besoin d’entrer dans le contexte du modèle. Seule la sortie finale du code revient au modèle.</p><p>AWS décrit le même pattern de manière plus agnostique : le modèle génère du code, la sandbox l’exécute, puis le résultat final revient dans le contexte.</p><p>Union appelle cela le “code mode” : au lieu d’émettre un seul objet JSON de tool call à chaque étape, le modèle émet un bloc de code exécutable qui peut appeler plusieurs outils et appliquer de la logique.</p><p>L’idée n’est pas totalement nouvelle.</p><p>La recherche CodeAct proposait déjà d’utiliser du Python exécutable comme espace d’action unifié pour les agents. Plus récemment, le papier CodeTool a poussé l’idée dans une direction importante : si l’agent agit par code, on peut aussi superviser les étapes plus directement.</p><p>Ce qui change aujourd’hui, c’est que ce pattern passe de la recherche et des frameworks custom vers les plateformes d’agents grand public.</p><h3>Pourquoi le code est un meilleur espace d’action pour certaines tâches</h3><p>Les modèles sont bons en code.</p><p>Ce détail compte.</p><p>Un tool call JSON est un format d’action très étroit. Il peut dire :</p><pre>{<br>  &quot;tool&quot;: &quot;get_expenses&quot;,<br>  &quot;arguments&quot;: {<br>    &quot;employee_id&quot;: &quot;123&quot;<br>  }<br>}</pre><p>Mais il n’exprime pas naturellement :</p><ul><li>appelle cet outil pour chaque employé</li><li>ignore les employés sans budget actif</li><li>retente deux fois les erreurs transitoires</li><li>normalise les devises</li><li>trie par écart</li><li>retourne seulement les cinq exceptions principales</li></ul><p>On peut faire tout cela avec une boucle de tool calling classique.</p><p>Mais dans ce cas, on utilise l’inférence comme un moteur de workflow lent.</p><p>Le code possède déjà les primitives nécessaires :</p><ul><li>variables</li><li>boucles</li><li>conditions</li><li>fonctions</li><li>gestion d’erreurs</li><li>parallélisme</li><li>structures de données</li></ul><p>La bonne question n’est donc pas :</p><blockquote><em>Est-ce que le modèle peut appeler des outils ?</em></blockquote><p>La bonne question est :</p><blockquote><em>Quelles parties du workflow doivent rester dans le raisonnement du modèle, et quelles parties doivent devenir du code ?</em></blockquote><h3>Le vrai bénéfice : moins de contexte, moins de tours modèle</h3><p>Le meilleur argument pour le programmatic tool calling n’est pas esthétique.</p><p>Il est opérationnel.</p><p>Dans son article sur l’advanced tool use, Anthropic explique que le tool calling en langage naturel force chaque appel d’outil à passer par une inférence complète, pendant que les résultats intermédiaires s’accumulent dans le contexte. La documentation Claude donne un exemple simple : vérifier la conformité budgétaire de 20 employés. Avec du tool calling classique, le modèle peut avoir besoin de 20 allers-retours et recevoir des milliers de lignes de dépenses. Avec du programmatic tool calling, un script peut faire les recherches, filtrer les résultats et ne retourner que les exceptions.</p><p>La forme de l’agent change.</p><p>Au lieu de :</p><pre>modèle -&gt; outil -&gt; modèle -&gt; outil -&gt; modèle -&gt; outil -&gt; modèle</pre><p>On obtient :</p><pre>modèle -&gt; sandbox code -&gt; outils -&gt; résultat filtré -&gt; modèle</pre><p>Le modèle ne transporte plus toutes les observations intermédiaires.</p><p>Il reçoit la partie qui mérite réellement une interprétation.</p><p>Pour des agents d’entreprise, c’est important.</p><p>La plupart des workflows réels ne sont pas un seul appel API propre. Ils impliquent des listes de records, des permissions, des retries, de la pagination, des erreurs partielles, des seuils, des jointures entre systèmes et de la mise en forme.</p><p>Mettre tout cela dans le contexte du modèle est coûteux et fragile.</p><p>Le mettre dans un programme sandboxé ressemble davantage à la manière dont on construit des logiciels fiables.</p><h3>Le code rend aussi les étapes plus vérifiables</h3><p>Il y a un autre point important, moins visible que la latence.</p><p>Quand un agent appelle des outils en texte ou en JSON, il peut produire un long chemin de raisonnement. Le problème n’est pas seulement que ce chemin est long. Le problème est qu’il devient difficile de savoir si chaque étape intermédiaire est correcte.</p><p>C’est exactement ce que le papier CodeTool attaque.</p><p>CodeTool propose une génération de code étape par étape pour l’invocation d’outils. À chaque étape, le système peut évaluer deux choses :</p><ul><li>est-ce que le code actuel s’exécute correctement ?</li><li>est-ce que cette étape aide vraiment à résoudre la tâche globale ?</li></ul><p>Les auteurs appellent cela deux rewards :</p><ul><li>On-the-spot Reward : feedback immédiat sur la validité et l’exécution de l’appel d’outil courant.</li><li>Latent Reward : estimation de la contribution de l’étape à la réussite finale, avec pénalité pour les chemins trop longs ou redondants.</li></ul><p>Ce détail est important.</p><p>Le code n’est pas seulement un moyen de faire des boucles.</p><p>C’est aussi un support d’observation.</p><p>On peut exécuter une étape. Voir si elle passe. Voir si elle produit la bonne structure. Voir si elle avance vraiment la tâche.</p><p>Dans leurs ablations sur Qwen2.5-Coder-7B, les auteurs montrent que retirer le On-the-spot Reward fait chuter la proportion moyenne d’exécution correcte des étapes de 86,86 % à 69,46 %. Ce n’est pas une preuve absolue que ce framework sera le bon en production, mais c’est un signal utile : dans les agents complexes, la supervision des étapes compte autant que le format d’action.</p><p>Dit autrement :</p><p>programmatic tool calling sans supervision, c’est juste du code généré.</p><p>programmatic tool calling avec feedback d’exécution, c’est le début d’une boucle de fiabilité.</p><h3>Quand l’utiliser</h3><p>Le programmatic tool calling est utile quand la tâche contient beaucoup d’orchestration mécanique.</p><p>Bons exemples :</p><ul><li>vérifier plusieurs endpoints</li><li>interroger beaucoup de records clients</li><li>comparer des lignes budgétaires entre équipes</li><li>traiter des lignes de spreadsheet</li><li>lancer le même diagnostic sur plusieurs services</li><li>filtrer des résultats de recherche avant résumé</li><li>agréger des sorties d’outils avant analyse</li><li>paralléliser des appels indépendants</li></ul><p>Dans ces cas, le modèle doit écrire le plan et le code.</p><p>La sandbox doit faire le travail répétitif.</p><p>Le modèle doit raisonner sur le résultat réduit.</p><p>Mais ce n’est pas le bon défaut pour tout.</p><p>Le pattern est moins utile pour :</p><ul><li>un seul appel d’outil simple</li><li>les tâches qui demandent un feedback utilisateur immédiat après chaque étape</li><li>les opérations très rapides où le coût de sandbox dépasse le gain</li><li>les écritures risquées sans validation humaine</li><li>les situations où chaque observation intermédiaire peut changer l’intention de l’utilisateur</li></ul><p>L’erreur serait de remplacer tous les tool calls par du programmatic tool calling.</p><p>La bonne architecture est hybride.</p><p>Tool calling direct pour les étapes simples, interactives ou très dépendantes du jugement.</p><p>Programmatic tool calling pour les boucles, le traitement de données, le filtrage et l’orchestration multi-étapes.</p><p>Gates humaines ou service gates pour les actions irréversibles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ngkcgIiwP1LGjpQXpCckAA.png" /></figure><h3>Le problème de sécurité ne disparaît pas</h3><p>Le programmatic tool calling peut rendre les agents plus rapides et moins chers.</p><p>Mais il ajoute aussi une surface d’ingénierie plus sérieuse.</p><p>On a maintenant du code généré qui s’exécute dans une sandbox et qui peut appeler des outils.</p><p>Il faut donc décider :</p><ul><li>quels outils sont appelables depuis du code</li><li>quels outils restent en appel direct uniquement</li><li>quels outils nécessitent une approbation</li><li>combien de temps vivent les containers</li><li>quelles données sont retenues</li><li>comment les outputs d’outils sont validés</li><li>ce qui se passe si une donnée externe contient du contenu interprétable comme du code</li><li>comment les logs et traces sont stockés</li><li>comment détecter un mauvais usage d’outil</li></ul><p>La documentation Anthropic prévient explicitement que les résultats d’outils reviennent sous forme de chaînes de caractères et peuvent contenir du contenu traité par l’environnement d’exécution. Si des données externes ou utilisateur influencent le code, la validation des outputs compte.</p><p>C’est là que beaucoup d’explications deviennent trop optimistes.</p><p>Le pattern est puissant parce qu’il rapproche l’exécution du code.</p><p>Mais il hérite donc des sujets classiques du software engineering : sandboxing, moindre privilège, validation, observabilité, retries et audit logs.</p><p>Ce n’est pas un raccourci autour de la discipline d’ingénierie.</p><p>C’est une raison d’en appliquer davantage.</p><h3>La règle d’architecture que j’utiliserais</h3><p>Ma règle serait simple :</p><p>Utiliser le modèle pour le jugement.</p><p>Utiliser le code pour la mécanique.</p><p>Le modèle est bon pour :</p><ul><li>comprendre l’objectif utilisateur</li><li>choisir la stratégie</li><li>décider quelles preuves comptent</li><li>expliquer le résultat</li><li>gérer l’ambiguïté</li><li>demander une clarification</li></ul><p>Le code est meilleur pour :</p><ul><li>boucles</li><li>filtres</li><li>jointures</li><li>seuils</li><li>retries</li><li>formatage</li><li>appels parallèles</li><li>transformations déterministes</li></ul><p>Le programmatic tool calling est intéressant parce qu’il permet de respecter cette frontière.</p><p>Cela ne veut pas dire que les agents deviennent des software engineers autonomes.</p><p>Cela veut dire que la couche d’orchestration devient plus honnête.</p><p>Certaines parties d’un workflow agentique sont du raisonnement.</p><p>Certaines parties sont juste du calcul.</p><p>Forcer les deux à passer par la même boucle conversationnelle devait forcément devenir inefficace.</p><h3>Ce que cela change pour les systèmes IA à l’échelle</h3><p>Le pattern plus large est clair : les systèmes IA ressemblent de plus en plus à des architectures runtime.</p><p>Au début, tout le monde parlait de prompts.</p><p>Ensuite, on a ajouté des outils.</p><p>Puis de la mémoire, du retrieval, des agents, des workflows et de l’évaluation.</p><p>Maintenant, la frontière bouge encore.</p><p>On se demande où placer le code dans la boucle agentique.</p><p>C’est la bonne question.</p><p>L’IA en entreprise ne passera pas à l’échelle en laissant les modèles lire tous les résultats intermédiaires et décider chaque micro-étape en langage naturel.</p><p>Elle passera à l’échelle en combinant raisonnement modèle et couches d’exécution déterministes.</p><p>Le programmatic tool calling est une version de cette idée.</p><p>Pas magique.</p><p>Pas “le tool calling est mort”.</p><p>Juste une séparation plus propre des responsabilités :</p><ul><li>le modèle raisonne</li><li>la sandbox exécute</li><li>les outils exposent des capacités</li><li>la politique contrôle le risque</li><li>seuls les résultats utiles entrent dans le contexte</li></ul><p>C’est pour ça que ce pattern compte.</p><p>Ce n’est pas une histoire de feature.</p><p>C’est une histoire d’architecture.</p><h3>Sources</h3><ul><li>Anthropic, “Introducing advanced tool use on the Claude Developer Platform”: <a href="https://www.anthropic.com/engineering/advanced-tool-use">https://www.anthropic.com/engineering/advanced-tool-use</a></li><li>Claude API docs, “Programmatic tool calling”: <a href="https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling">https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling</a></li><li>AWS Machine Learning Blog, “Implementing programmatic tool calling on Amazon Bedrock”: <a href="https://aws.amazon.com/blogs/machine-learning/implementing-programmatic-tool-calling-on-amazon-bedrock/">https://aws.amazon.com/blogs/machine-learning/implementing-programmatic-tool-calling-on-amazon-bedrock/</a></li><li>OpenAI API docs, “Function calling”: <a href="https://developers.openai.com/api/docs/guides/function-calling">https://developers.openai.com/api/docs/guides/function-calling</a></li><li>Union.ai docs, “Programmatic tool calling for agents”: <a href="https://www.union.ai/docs/v2/union/user-guide/sandboxing/code-mode/">https://www.union.ai/docs/v2/union/user-guide/sandboxing/code-mode/</a></li><li>Wang et al., “Executable Code Actions Elicit Better LLM Agents”: <a href="https://arxiv.org/abs/2402.01030">https://arxiv.org/abs/2402.01030</a></li><li>Lu et al., “CodeTool: Enhancing Programmatic Tool Invocation of LLMs via Process Supervision”: <a href="https://arxiv.org/html/2503.20840v1">https://arxiv.org/html/2503.20840v1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=edab0c905c75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Multi-token prediction : pourquoi les LLM locaux pourraient devenir beaucoup plus rapides]]></title>
            <link>https://jeremyjouvance.medium.com/multi-token-prediction-pourquoi-les-llm-locaux-pourraient-devenir-beaucoup-plus-rapides-7ea6e0972b08?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ea6e0972b08</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sat, 23 May 2026 17:12:51 GMT</pubDate>
            <atom:updated>2026-05-23T17:12:51.617Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R1UIah374yzmH_6DSmmS4g.png" /></figure><p><em>Pourquoi le multi-token prediction est plus qu’une astuce de vitesse et pourquoi il devient particulièrement intéressant pour les modèles locaux.</em></p><p>On parle beaucoup de modèles plus gros, de fenêtres de contexte plus longues, de quantization, de GPU plus rapides, de RAG, d’agents et de tool calling. On parle un peu moins d’une idée beaucoup plus discrète, mais très structurante : arrêter d’entraîner et de faire générer les modèles comme s’ils ne pouvaient penser qu’au prochain token.</p><p>C’est l’idée derrière le <strong>multi-token prediction</strong>, souvent abrégé <strong>MTP</strong>.</p><p>La version simple est celle-ci : au lieu de demander au modèle uniquement “quel est le prochain token ?”, on lui apprend aussi à anticiper plusieurs tokens futurs. Et ensuite, dans certains cas, on peut exploiter cette anticipation pour accélérer la génération.</p><p>Dit comme ça, cela peut sembler être une optimisation technique parmi d’autres. En réalité, c’est plus intéressant que ça. Le MTP touche à deux sujets très importants dans les LLM : la manière dont un modèle apprend, et la manière dont on le sert en production.</p><p>C’est aussi pour ça que le sujet revient de plus en plus dans les modèles open source et self-hosted : DeepSeek, Medusa, vLLM, SGLang, llama.cpp, et plus récemment Gemma 4 avec ses MTP drafters.</p><p>Mais pour éviter le buzzword, il faut commencer par une nuance importante.</p><h3>Le MTP, ce n’est pas une seule chose</h3><p>Le terme MTP est souvent utilisé de façon un peu floue. Selon le contexte, il peut désigner trois choses proches, mais pas identiques.</p><p>D’abord, il peut désigner un <strong>objectif d’entraînement</strong>. Un modèle classique apprend à prédire le prochain token. Un modèle entraîné avec MTP apprend aussi à prédire le token d’après, puis parfois encore celui d’après. Cela densifie le signal d’apprentissage : à chaque position dans le texte, le modèle ne reçoit pas seulement une correction sur “le prochain mot”, mais sur plusieurs étapes futures.</p><p>Ensuite, le MTP peut désigner une <strong>architecture</strong>. Pour prédire plusieurs futurs tokens, on ajoute souvent des têtes ou des modules supplémentaires au modèle. Ces modules peuvent être indépendants, comme dans certains travaux de recherche, ou plus séquentiels, comme dans DeepSeek-V3.</p><p>Enfin, le MTP peut désigner un <strong>mode d’inférence</strong>, c’est-à-dire une façon d’accélérer la génération. Le modèle, ou un module associé, propose plusieurs tokens en avance. Le modèle principal vérifie ensuite ces propositions en une seule passe. Si les propositions sont bonnes, on gagne du temps. Si elles sont mauvaises, on les jette et on continue normalement.</p><p>C’est cette dernière partie que beaucoup de gens retiennent, parce qu’elle est facile à vendre : “jusqu’à 2x ou 3x plus rapide”. Mais ce n’est pas toute l’histoire.</p><p>La phrase que je retiens est plutôt celle-ci :</p><blockquote><em>Le MTP n’est pas seulement une astuce pour faire sortir les tokens plus vite. C’est une façon d’apprendre au modèle à regarder un peu plus loin — puis, parfois, d’exploiter ce regard pour accélérer la génération.</em></blockquote><p>Cette distinction est importante, parce qu’un modèle peut bénéficier du MTP pendant l’entraînement, même si on ne garde pas les modules MTP au moment de l’inférence. DeepSeek le montre assez bien : dans certaines expériences, le module MTP améliore les scores du modèle, puis peut être retiré à l’inférence, ce qui garde le même coût de génération que le modèle de base.</p><h3>Pourquoi le prochain token est un goulot d’étranglement</h3><p>Pour comprendre pourquoi le MTP est intéressant, il faut revenir au fonctionnement standard d’un LLM.</p><p>Un modèle de langage génère du texte de manière autoregressive. Cela veut dire qu’il produit un token, puis utilise ce token pour produire le suivant, puis recommence. Même si le GPU est très puissant, cette boucle est profondément séquentielle.</p><p>C’est un peu comme si quelqu’un devait écrire une phrase en demandant une validation après chaque mot.</p><p>“Le…”</p><p>Validation.</p><p>“modèle…”</p><p>Validation.</p><p>“peut…”</p><p>Validation.</p><p>Ce mécanisme fonctionne très bien, mais il a un défaut : il crée une latence visible. Pour un chatbot, un assistant vocal, un copilote de code ou un agent qui doit faire plusieurs étapes, cette latence compte énormément.</p><p>Le problème est encore plus net en local. Quand on fait tourner un modèle sur son propre GPU, son Mac, une workstation ou une petite infra interne, on est souvent dans un régime où il n’y a pas énormément de requêtes en parallèle. Le batch size est faible. La génération se fait presque utilisateur par utilisateur. Dans ce cas, chaque token généré l’un après l’autre se ressent directement.</p><p>Et il y a un autre détail important : l’inférence LLM est souvent limitée par la bande passante mémoire. Le processeur passe beaucoup de temps à déplacer les poids du modèle depuis la mémoire vers les unités de calcul pour générer un seul token. Autrement dit, le GPU n’est pas toujours utilisé de manière optimale. Il a parfois de la capacité de calcul disponible, mais il attend la mémoire.</p><p>Le MTP et le speculative decoding essayent d’exploiter ce décalage : plutôt que d’avancer strictement un token à la fois, on propose plusieurs tokens d’avance, puis on les vérifie en lot.</p><h3>Une métaphore simple : le brouillon et le correcteur</h3><p>La meilleure manière d’expliquer le MTP à quelqu’un de non technique, c’est de parler de brouillon.</p><p>Imaginez deux personnes qui écrivent ensemble.</p><p>La première est rapide, mais pas toujours fiable. Elle écrit un petit brouillon de la suite de la phrase.</p><p>La deuxième est plus lente, mais beaucoup plus fiable. Elle relit le brouillon et décide ce qu’on garde.</p><p>Si le brouillon est bon, on avance de plusieurs mots d’un coup. Si le brouillon est mauvais, on ne garde que la partie validée, puis on continue normalement.</p><p>C’est exactement l’intuition du speculative decoding.</p><p>Dans une version classique, le brouillon peut être produit par un petit modèle séparé. On a donc un “draft model” rapide et un “target model” plus gros qui vérifie.</p><p>Avec certaines variantes MTP, le brouillon peut venir directement du modèle principal ou d’un module associé au modèle principal. C’est là que le MTP devient pratique : pas forcément besoin de maintenir un deuxième modèle séparé, avec son tokenizer, sa mémoire GPU et ses problèmes de compatibilité.</p><p>C’est une des raisons pour lesquelles vLLM présente le MTP comme intéressant quand le modèle cible supporte nativement cette capacité. SGLang et llama.cpp vont dans la même direction : si le modèle possède déjà des têtes ou modules MTP exploitables, le runtime peut s’en servir comme mécanisme de spéculation.</p><h3>Comment ça marche côté entraînement</h3><p>Côté entraînement, l’idée est assez intuitive.</p><p>Un modèle classique apprend ceci :</p><blockquote><em>“Vu tout ce contexte, quel est le prochain token ?”</em></blockquote><p>Un modèle entraîné avec MTP apprend plutôt ceci :</p><blockquote><em>“Vu tout ce contexte, quels sont les prochains tokens à plusieurs profondeurs ?”</em></blockquote><p>Dans le papier de Gloeckle et al., le modèle garde un tronc commun, puis ajoute plusieurs têtes de sortie. Chaque tête apprend à prédire un token futur différent. Une tête regarde le prochain token, une autre le token à deux pas, une autre le token à trois pas, etc.</p><p>DeepSeek-V3 reprend l’idée, mais avec une variante plus séquentielle. Au lieu de prédire tous les futurs tokens de manière complètement indépendante, DeepSeek utilise des modules qui conservent une forme de chaîne causale. En clair : la prédiction plus lointaine dépend déjà de ce qui a été prédit à une profondeur précédente.</p><p>Cette nuance peut sembler technique, mais elle dit quelque chose d’important : il n’existe pas une seule version canonique du MTP. Il existe une famille d’approches qui partagent la même intuition : pousser le modèle à mieux préparer la suite.</p><p>Côté entraînement, l’intérêt est double.</p><p>D’abord, le modèle reçoit plus de signal. Il apprend non seulement à choisir le prochain token, mais aussi à organiser ses représentations internes pour que les tokens suivants soient plus prévisibles.</p><p>Ensuite, cela peut encourager une forme de “pré-planification”. Le modèle n’est pas explicitement en train de raisonner comme un humain, mais on lui demande de construire des représentations utiles pour plusieurs étapes futures, pas seulement pour l’étape immédiate.</p><p>C’est probablement une des raisons pour lesquelles les gains apparaissent davantage sur des tâches génératives comme le code, où la structure de la sortie compte beaucoup.</p><h3>Pourquoi le code est un cas particulièrement favorable</h3><p>Le code est un exemple très parlant.</p><p>Quand un modèle écrit du code, beaucoup de séquences sont assez prévisibles. Après def, il y a souvent un nom de fonction, puis des parenthèses. Après une ouverture de parenthèse, il y a souvent une fermeture. Après un import, certains motifs reviennent souvent. Même chose pour l’indentation, les blocs, les signatures, les boucles ou le boilerplate.</p><p>Cela ne veut pas dire que le code est facile. Mais cela veut dire que, localement, la suite contient beaucoup de régularités.</p><p>Et le MTP aime les régularités.</p><p>Dans les résultats de Gloeckle et al., les gains sont particulièrement visibles sur les benchmarks de code. Les modèles 13B entraînés avec MTP résolvent davantage de problèmes sur HumanEval et MBPP que les modèles comparables entraînés uniquement en next-token prediction.</p><p>Medusa montre aussi une accélération très forte sur les tâches de code. Sur Vicuna-7B, la catégorie “Coding” atteint environ 3.29x de speedup dans leurs mesures, et la catégorie “Extraction” monte encore plus haut.</p><p>Cela donne une intuition simple : plus la sortie est structurée, répétitive ou contrainte, plus il y a de chances que le modèle propose correctement plusieurs tokens à l’avance.</p><p>C’est aussi pour ça que le MTP peut être intéressant pour les agents. Les agents produisent souvent des formats répétitifs : appels d’outils, JSON, plans d’action, réponses structurées, logs d’exécution, reformulations, étapes intermédiaires. Si le runtime sait accélérer ces séquences sans changer le comportement du modèle principal, le gain devient très concret.</p><h3>Ce que disent les chiffres</h3><p>Les chiffres doivent être lus avec prudence, parce qu’ils ne mesurent pas tous la même chose. Certains mesurent un gain de qualité à l’entraînement. D’autres mesurent un gain de vitesse à l’inférence. D’autres encore mesurent des tokens par seconde sur un hardware précis.</p><p>Mais ils donnent quand même une bonne idée du potentiel.</p><h3>Gloeckle et al. : meilleure qualité et jusqu’à 3x en inférence</h3><p>Le papier “Better &amp; Faster Large Language Models via Multi-token Prediction” est un bon point de départ.</p><p>Les auteurs montrent que l’entraînement en multi-token prediction peut améliorer les capacités du modèle, notamment sur les tâches génératives. Sur les modèles 13B, ils rapportent davantage de problèmes résolus sur HumanEval et MBPP que des modèles next-token comparables.</p><p>Ils montrent aussi que les modèles entraînés avec une prédiction à 4 tokens peuvent aller jusqu’à 3x plus vite à l’inférence dans leur configuration de self-speculative decoding.</p><p>Le point important n’est pas seulement “3x plus vite”. Le point important est que le même mécanisme peut contribuer à la fois à l’apprentissage et à l’inférence.</p><h3>DeepSeek-V3 : gains de benchmark et 1.8x de TPS</h3><p>DeepSeek-V3 est intéressant parce qu’il intègre explicitement un objectif MTP dans son entraînement.</p><p>Dans leurs ablations, DeepSeek compare des modèles baseline avec des modèles “w/ MTP”, à coût d’inférence identique lorsque le module MTP est retiré au runtime. Sur un petit MoE de 15.7B paramètres totaux, HumanEval passe de 20.7 à 26.8, GSM8K de 25.4 à 31.4, MATH de 10.7 à 12.6 et MMLU de 50.0 à 53.3.</p><p>Sur un plus grand MoE de 228.7B paramètres totaux, HumanEval passe de 44.5 à 53.7, GSM8K de 72.3 à 74.0 et MATH de 38.6 à 39.8. MMLU, en revanche, bouge légèrement dans l’autre sens, de 67.5 à 66.6.</p><p>C’est une donnée importante : le MTP n’améliore pas tout, partout, tout le temps.</p><p>Côté inférence, DeepSeek indique que la prédiction du second token est acceptée entre 85 % et 90 % selon les sujets, ce qui permet d’atteindre environ 1.8x de tokens par seconde.</p><h3>Medusa : 2x à 3x, avec une qualité souvent proche</h3><p>Medusa n’est pas exactement la même chose que le MTP de DeepSeek, mais c’est très proche dans l’esprit : ajouter des têtes de décodage pour proposer plusieurs tokens et vérifier plusieurs continuations en parallèle.</p><p>Sur Vicuna-7B, Medusa-1 atteint environ 2.18x de speedup et Medusa-2 monte à 2.83x. Sur Vicuna-13B, Medusa-2 reste aussi autour de 2.83x.</p><p>Le point intéressant est le compromis qualité/vitesse. Sur Vicuna-7B, la qualité MT-Bench reste quasiment stable : 6.18 contre 6.17 pour le baseline dans leur tableau. Sur Zephyr-7B, la qualité baisse légèrement, mais le speedup reste important.</p><p>Ce n’est pas magique : selon la méthode de fine-tuning, les seuils d’acceptation et la complexité de l’arbre de vérification, on peut gagner plus ou moins. Medusa montre aussi qu’un arbre plus complexe peut accepter plus de tokens, mais devenir moins rentable à cause de l’overhead matériel.</p><p>C’est exactement le genre de détail qui évite de raconter une histoire trop marketing.</p><h3>Gemma 4 : le MTP devient un sujet produit</h3><p>Le complément le plus récent, c’est Gemma 4.</p><p>En mai 2026, Google a publié des MTP drafters pour la famille Gemma 4. L’annonce parle d’un gain allant jusqu’à 3x, sans dégradation de qualité ou de logique de raisonnement, parce que le modèle principal garde le rôle de vérificateur final.</p><p>C’est intéressant pour deux raisons.</p><p>La première, c’est que Google positionne clairement le MTP comme une optimisation utile pour les développeurs : assistants de code, agents, applications mobiles, usage local, workstation, cloud.</p><p>La deuxième, c’est que l’écosystème suit. vLLM documente déjà un chemin MTP pour Gemma 4, avec des assistant checkpoints dédiés qui partagent le KV cache avec le modèle cible. Pour les petits modèles E2B et E4B, vLLM mentionne même une optimisation de calcul des logits qui réduit fortement le coût du lm_head via un système de sélection de candidats.</p><p>On voit donc une évolution importante : le MTP n’est plus seulement un résultat de papier ou une expérimentation de lab. Il devient une feature de runtime, avec des commandes, des checkpoints et des recommandations de configuration.</p><h3>SGLang et DeepSeek-V3.2 : le terrain du serving</h3><p>SGLang documente aussi des configurations DeepSeek-V3.2 avec speculative decoding MTP, y compris pour des déploiements Hopper et des variantes quantifiées.</p><p>Un exemple parlant : dans une recette “DP2 + MTP”, la doc mentionne un passage d’environ 4948 tokens/s à 6842 tokens/s sur leur workload de test. C’est environ 38 % de mieux dans cette configuration.</p><p>Il faut faire attention à ne pas généraliser ce chiffre. Il dépend du modèle, du hardware, de la charge, de la longueur des prompts, de la longueur des réponses, de la concurrence et des paramètres de spéculation.</p><p>Mais il montre une chose importante : le MTP n’est pas seulement une optimisation théorique. Il commence à apparaître dans les recettes de serving des grands modèles open source.</p><h3>Les avantages du MTP</h3><p>Le premier avantage est évident : la vitesse.</p><p>Quand les tokens proposés sont acceptés, le modèle avance de plusieurs tokens en une seule vérification. Pour l’utilisateur, cela peut se traduire par une réponse plus fluide, moins de latence inter-token, et une impression générale de modèle plus réactif.</p><p>Le deuxième avantage est plus subtil : le MTP peut améliorer l’apprentissage. En forçant le modèle à prédire plusieurs tokens futurs, on enrichit le signal d’entraînement. Le modèle apprend à organiser ses représentations pour mieux préparer la suite.</p><p>Le troisième avantage est opérationnel. Si le modèle supporte nativement le MTP, on peut parfois éviter de maintenir un draft model séparé. C’est très concret : moins de poids à charger, moins de risques de tokenizer incompatible, moins de complexité d’intégration, moins de friction en production.</p><p>Le quatrième avantage concerne les usages locaux. Sur un laptop, une workstation, un serveur maison ou une petite infra interne, l’expérience utilisateur dépend fortement de la fluidité. Un gain de 1.5x, 2x ou 3x peut changer la perception d’un modèle. Un modèle qui semblait “un peu lent” devient utilisable dans un copilote, un agent ou un assistant interactif.</p><h3>Les limites et les pièges</h3><p>Le premier piège est de croire que le MTP améliore toujours la qualité.</p><p>Ce n’est pas le cas.</p><p>Les résultats sont plus convaincants sur certaines tâches génératives, notamment le code, que sur des benchmarks classiques de compréhension ou de choix multiples. Certains scores montent, certains restent stables, certains peuvent légèrement baisser.</p><p>Le deuxième piège est de croire que “plus de tokens draftés” veut forcément dire “plus vite”.</p><p>Si le drafter propose beaucoup de tokens mais que le modèle principal les rejette souvent, on gaspille du calcul. À l’inverse, si on ne propose qu’un ou deux tokens, l’acceptation sera meilleure, mais le gain potentiel sera plus limité. Il faut trouver le bon équilibre.</p><p>Le troisième piège est matériel.</p><p>Les gains dépendent énormément du hardware, de la taille du modèle, de la bande passante mémoire, du batch size et du runtime. Une configuration peut gagner beaucoup, une autre très peu. Certains modèles MoE, par exemple, peuvent se comporter différemment selon le batch size et le routage des experts.</p><p>Le quatrième piège est l’overhead.</p><p>Ajouter des têtes, un drafter, un arbre de vérification ou des modules supplémentaires n’est jamais gratuit. Si la vérification devient trop lourde, si le drafter est trop lent, ou si les tokens sont souvent rejetés, le gain théorique disparaît.</p><p>Le dernier point est stratégique : le MTP n’est pas forcément la meilleure approche de spéculation dans tous les cas. vLLM et SGLang supportent aussi d’autres méthodes comme EAGLE, n-gram speculation, draft models ou MLP speculators. Dans certains contextes, EAGLE ou un bon draft model séparé peut être plus performant.</p><p>Il faut donc voir le MTP comme un outil très intéressant, pas comme une religion.</p><h3>Pourquoi c’est particulièrement important pour les modèles locaux</h3><p>C’est probablement la partie la plus intéressante du sujet.</p><p>Les modèles locaux vivent dans un monde différent des grandes API cloud.</p><p>Dans une grande API, on peut mutualiser beaucoup de requêtes, optimiser les batchs, utiliser une infra massive, absorber certains coûts. En local ou en self-hosted, on a souvent une seule machine, un GPU limité, peu de requêtes simultanées, et un utilisateur qui attend devant son écran.</p><p>Dans ce contexte, la latence est beaucoup plus visible.</p><p>Quand un modèle local passe de 25 tokens/s à 50 tokens/s, ce n’est pas seulement un benchmark. C’est la différence entre “je sens que ça rame” et “ça répond correctement”.</p><p>Le MTP est donc particulièrement intéressant pour :</p><ul><li>les copilotes de code locaux</li><li>les assistants privés d’entreprise</li><li>les agents qui tournent en self-hosted</li><li>les workflows offline</li><li>les applications mobiles ou edge</li><li>les modèles open weights servis sur une infra interne</li><li>les petites équipes qui veulent de bonnes performances sans dépendre uniquement d’API externes</li></ul><p>C’est aussi pour ça que l’arrivée du support MTP dans des outils comme vLLM, SGLang, llama.cpp, Ollama ou MLX est importante. Une idée d’architecture n’a de valeur pour les développeurs que lorsqu’elle devient facile à activer dans les runtimes qu’ils utilisent déjà.</p><h3>Le vrai message : moins de myopie, plus de fluidité</h3><p>Ce que je trouve intéressant dans le MTP, ce n’est pas seulement le chiffre de speedup.</p><p>Oui, 1.8x, 2.8x ou 3x, c’est important.</p><p>Mais le vrai sujet est ailleurs : le MTP remet en question une hypothèse très profonde des LLM modernes, celle du prochain token comme unique horizon d’apprentissage immédiat.</p><p>Bien sûr, un LLM reste un modèle statistique. Il ne “pense” pas comme un humain. Mais en lui demandant de prédire plusieurs futurs tokens, on lui donne un objectif un peu moins myope. On lui demande de construire des représentations qui ne servent pas seulement la prochaine micro-décision, mais aussi la suite proche.</p><p>Et ça colle très bien à l’évolution actuelle des usages.</p><p>Les LLM ne sont plus seulement des chatbots qui répondent une phrase. Ils écrivent du code, appellent des outils, génèrent des plans, produisent des fichiers, font des boucles agentiques, travaillent avec de longs contextes, et doivent souvent donner une expérience proche du temps réel.</p><p>Dans ce monde-là, la vitesse de génération n’est pas un détail. C’est une partie de l’expérience produit.</p><h3>Conclusion</h3><p>Le MTP n’est pas une baguette magique.</p><p>Il ne remplace pas une bonne architecture, un bon dataset, une bonne quantization, un bon runtime ou une bonne infra. Il ne garantit pas une meilleure qualité partout. Il ne garantit pas non plus un speedup identique sur tous les hardwares.</p><p>Mais il coche une case rare : il peut agir à la fois sur l’apprentissage du modèle et sur sa vitesse d’inférence.</p><p>C’est ce qui le rend important.</p><p>Pour les grands modèles open source, il devient une piste sérieuse d’optimisation. Pour les modèles locaux, il est encore plus intéressant, parce que la latence est visible, la mémoire est limitée, et l’expérience utilisateur dépend fortement du nombre de tokens par seconde.</p><p>Si vous travaillez sur des assistants internes, des agents, du code, du self-hosted ou simplement des modèles locaux plus fluides, le multi-token prediction mérite clairement d’être suivi.</p><p>Pas parce que c’est le prochain buzzword.</p><p>Mais parce qu’il pose une question simple et puissante :</p><blockquote><em>Et si nos modèles étaient plus efficaces simplement parce qu’on leur demandait de regarder un peu plus loin ?</em></blockquote><p>Source</p><ul><li><a href="https://blog.google/innovation-and-ai/technology/developers-tools/multi-token-prediction-gemma-4/">https://blog.google/innovation-and-ai/technology/developers-tools/multi-token-prediction-gemma-4/</a></li><li><a href="https://docs.vllm.ai/en/latest/features/speculative_decoding/mtp/?utm_source=chatgpt.com">https://docs.vllm.ai/en/latest/features/speculative_decoding/mtp/</a></li><li><a href="https://github.com/ggml-org/llama.cpp/blob/master/docs/speculative.md">https://github.com/ggml-org/llama.cpp/blob/master/docs/speculative.md</a></li><li><a href="https://arxiv.org/abs/2404.19737?utm_source=chatgpt.com">https://arxiv.org/abs/2404.19737</a></li><li><a href="https://arxiv.org/html/2401.10774v3">https://arxiv.org/html/2401.10774v3</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ea6e0972b08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The End of the Human Hour]]></title>
            <link>https://jeremyjouvance.medium.com/the-end-of-the-human-hour-0f6922261cb4?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f6922261cb4</guid>
            <category><![CDATA[computes]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sun, 08 Mar 2026 21:54:07 GMT</pubDate>
            <atom:updated>2026-03-08T21:54:07.559Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JUmmMGFIf3r9sNsWfKkHWg.png" /></figure><p>For more than a century, intellectual work has been priced using a simple unit:</p><p><strong>human time.</strong></p><p>Per hour.<br>Per day.<br>Consulting rates.<br>Daily rates.</p><p>Consultants, developers, analysts, lawyers, entire industries were built on a simple assumption:</p><blockquote><strong>The human brain was the only machine capable of producing intelligence.</strong></blockquote><p>So the market priced intelligence using time.</p><p>But this assumption has just changed.</p><p>Not because humans stopped being useful.</p><p>But because intelligence is no longer produced only by humans.</p><h3>A new economic unit for intelligence</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MxMwHRrbIyizJrKMw07jLw.png" /></figure><p>Until recently, producing analysis, code, reports, or strategy required hours of human effort.</p><p>Today, a large part of this production can be generated in seconds by AI systems.</p><p>This is not just a productivity improvement.</p><p>It is a <strong>change in the economic unit of intellectual work</strong>.</p><p>Yesterday:</p><blockquote><strong>Cost of intelligence = human hours</strong></blockquote><p>Today:</p><blockquote><strong>Cost of intelligence = tokens + compute</strong></blockquote><p>In other words, the production of knowledge is moving from a <strong>biological cost</strong> to a <strong>computational cost</strong>.</p><p>And computation has a very important property:</p><p>It becomes <strong>cheaper every year</strong>.</p><h3>The execution premium is disappearing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dFbFFxIwCqgFj6qoHCrcFg.png" /></figure><p>Many industries built their business models on a simple reality:</p><p>Execution was slow.</p><p>Writing reports.<br>Analyzing data.<br>Reading documents.<br>Producing code.</p><p>This slowness created value.</p><p>Companies were not paying only for the result.</p><p>They were paying for the <strong>time required to produce it</strong>.</p><p>But when the marginal cost of production approaches zero, this premium disappears.</p><p>The value does not disappear.</p><p>It moves.</p><h3>Value moves from production to orchestration</h3><p>In the AI economy, value shifts toward four capabilities:</p><ol><li><strong>Identifying the right problem</strong></li><li><strong>Designing the system that solves it</strong></li><li><strong>Orchestrating intelligent tools and agents</strong></li><li><strong>Connecting AI to real data</strong></li></ol><p>The real shift is simple:</p><p>Value moves away from execution and toward <strong>the orchestration of intelligence</strong>.</p><h3>One human, many agents</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QF6wO5_0VlOZMe-dGOFr5Q.png" /></figure><p>For most of history, human productivity had a natural limit.</p><p>One brain could only do one thing at a time.</p><p>AI systems break this limitation.</p><p>A single person can now supervise:</p><ul><li>multiple agents</li><li>multiple automated workflows</li><li>multiple production processes</li></ul><p>This does not only increase speed.</p><p>It increases <strong>leverage</strong>.</p><p>One individual can now produce what previously required an entire team.</p><h3>Three roles become more valuable</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qstLPpgmZQazjs6V-8GUWA.png" /></figure><p>As AI spreads across organizations, three profiles become increasingly important.</p><h3>The Architect</h3><p>The person who transforms a vague objective into a clear system.</p><p>They do not necessarily produce the output themselves.</p><p>They design <strong>the system that produces it</strong>.</p><h3>The Context Guardian</h3><p>AI models are excellent at solving structured problems.</p><p>But they can still produce decisions that are technically correct and strategically wrong.</p><p>The context guardian brings real-world experience and domain knowledge.</p><p>They ensure the system stays aligned with reality.</p><h3>The Integrator</h3><p>The person who connects AI systems to real data, tools, and internal processes.</p><p>Without proprietary data, AI remains generic.</p><p>With real data, it becomes a <strong>competitive advantage</strong>.</p><h3>The Tutor Rule</h3><p>Working in the age of AI requires a shift in posture.</p><p>Humans move from producing knowledge to <strong>supervising systems that produce knowledge</strong>.</p><p>Three habits become essential:</p><p>Do not write the first draft.<br> Design the system before executing the task.<br> Build systems that solve problems repeatedly, not just once.</p><h3>The real question</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R_CfXSuB8989kRQWXgzxbA.png" /></figure><p>AI is not the end of intellectual work.</p><p>But it may be the end of a model where intelligence is priced <strong>by the hour</strong>.</p><p>In the economy that is emerging, the difference will be simple.</p><p>Some people will still be paid to <strong>execute instructions</strong>.</p><p>Others will be paid to <strong>define the targets</strong>.</p><p>And in a world where machines execute almost everything, the real value will belong to those who <strong>choose the target</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f6922261cb4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agent Skills : pourquoi le futur des agents ne se joue pas dans le prompt, mais dans le context…]]></title>
            <link>https://jeremyjouvance.medium.com/agent-skills-pourquoi-le-futur-des-agents-ne-se-joue-pas-dans-le-prompt-mais-dans-le-context-13294ef0d652?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/13294ef0d652</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sat, 20 Dec 2025 12:01:30 GMT</pubDate>
            <atom:updated>2025-12-20T12:06:08.393Z</atom:updated>
            <content:encoded><![CDATA[<h3>Agent Skills : pourquoi le futur des agents ne se joue pas dans le prompt, mais dans le <em>context engineering</em></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aKbPan44-Lx9vZQ4hQjlzQ.png" /></figure><p>Ces derniers mois, un même pattern commence à apparaître dans plusieurs systèmes d’agents avancés.<br>OpenAI l’introduit aujourd’hui dans <strong>OpenAI Codex</strong> sous le nom de <em>Skills</em>.<br>Mais ce pattern n’est pas nouveau : il a été <strong>conçu, testé et industrialisé plus tôt par Claude Code</strong>.</p><p>Ce n’est pas une simple feature produit. C’est un <strong>changement fondamental dans la manière dont on conçoit le contexte des agents IA</strong>.</p><h3>Le problème fondamental : le contexte, pas le modèle</h3><p>Les agents modernes échouent rarement par manque d’intelligence brute.<br>Ils échouent parce que :</p><ul><li>le contexte devient trop <strong>large</strong>,</li><li>les instructions sont <strong>redondantes </strong>ou <strong>contradictoires</strong>,</li><li>tout est chargé en permanence,</li><li>les tâches longues perdent en <strong>cohérence</strong>.</li></ul><p>Les agents de coding ont été les premiers à heurter ce mur :</p><ul><li>conventions de code,</li><li>standards d’architecture,</li><li>règles de sécurité,</li><li>workflows CI/CD,</li><li>pratiques métier spécifiques.</li></ul><p>Impossible de tout faire tenir durablement dans un prompt ou même un long contexte.</p><h3>Claude Code : le point de bascule</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UHMRr3U_hkpZMJmR.png" /></figure><p>Claude Code a introduit une idée clé :</p><blockquote><strong><em>Toutes les capacités d’un agent ne doivent pas être présentes dans le contexte en permanence.</em></strong></blockquote><p>Au lieu d’un prompt monolithique, Claude Code a mis en place :</p><ul><li>des <strong>capacités modulaires</strong>,</li><li>déclarées à l’avance,</li><li><strong>chargées uniquement quand elles sont nécessaires</strong>.</li></ul><p>Ces modules — appelés <em>Agent Skills</em> — encapsulent :</p><ul><li>des instructions structurées,</li><li>des procédures réutilisables,</li><li>des règles implicites rendues explicites.</li></ul><p>Le contexte devient alors :</p><ul><li>dynamique,</li><li>intentionnel,</li><li>minimal par défaut.</li></ul><p>C’est une approche d’<strong>ingénierie du contexte</strong>, pas de prompting.</p><h3>Codex adopte le même pattern</h3><p>Avec l’introduction des <em>Skills</em>, Codex suit exactement cette trajectoire :</p><ul><li>les capacités ne sont plus toutes injectées au démarrage,</li><li>seules les métadonnées sont visibles en permanence,</li><li>le contenu détaillé est activé à la demande,</li><li>le modèle reste léger et cohérent sur la durée.</li></ul><p>Ce n’est pas une coïncidence.<br>C’est la reconnaissance implicite que <strong>le prompt utilisateur ne peut plus être le centre de gravité d’un agent complexe</strong>.</p><h3>AgentSkills.io : formaliser un nouveau standard</h3><p>Le site <a href="https://agentskills.io/home"><strong>AgentSkills.io</strong></a> va encore plus loin :<br>il ne présente pas les Skills comme une feature liée à un fournisseur, mais comme <strong>un pattern générique d’architecture agentique dans la même lignée que AGENTS.md</strong>.</p><p>AgentSkills propose une vision claire :</p><ul><li>une Skill est une <strong>unité de capacité autonome</strong>,</li><li>indépendante du modèle,</li><li>indépendante du framework,</li><li>portable entre systèmes.</li></ul><p>On ne parle plus d’astuces de prompt, mais de <strong>briques de raisonnement et d’action standardisées</strong>.</p><h3>Exemple minimal : un sous-agent qui simule une équipe de développement (2 Skills)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JQxMhpKntr_0DeEl" /></figure><p>On considère un <strong>sous-agent </strong><strong>SoftwareTeamAgent</strong> chargé de développer une fonctionnalité de bout en bout.</p><p>Le point clé :</p><ul><li><strong>le prompt utilisateur est volontairement pauvre</strong></li><li><strong>la structure et l’intelligence vivent dans les Skills</strong></li></ul><h4>Prompt utilisateur (inchangé, volontairement simple)</h4><pre>Ajoute la fonctionnalité d’export CSV sur la liste des utilisateurs.</pre><h3>Skill 1, tech-design</h3><p><strong>Rôle humain simulé</strong><br>Tech lead / architecte logiciel.</p><p><strong>Objectif</strong><br>Transformer une demande fonctionnelle en décisions techniques claires.</p><h4>Prompt de la Skill tech-design</h4><pre>---<br>name: tech-design<br>descritpion: You are acting as a senior technical lead.<br>---</pre><pre>Your role is to:<br>- Translate the user request into a technical design<br>- Identify impacted components<br>- Define constraints and assumptions<br>- Propose a minimal, scalable implementation approach</pre><pre>Rules:<br>- Do not write code<br>- Focus on structure and responsibilities<br>- Highlight risks and edge cases</pre><p><strong>Quand le Skill est activée</strong><br>Dès qu’une décision d’architecture ou de découpage est nécessaire.</p><h4>Skill 2, implementation-review</h4><p><strong>Rôle humain simulé</strong><br>Développeur senior / reviewer.</p><p><strong>Objectif</strong><br>Vérifier que l’implémentation respecte les standards attendus.</p><h4>Prompt de la Skill implementation-review</h4><pre>---<br>name: implementation-review<br>descritption: You are acting as a senior software engineer performing a code review.<br>---</pre><pre>Your role is to:<br>- Review the proposed implementation<br>- Check code structure, naming, and maintainability<br>- Identify missing tests or error handling<br>- Suggest concrete improvements</pre><pre>Rules:<br>- Be concise and actionable<br>- Do not rewrite the full code<br>- Focus on long-term maintainability</pre><p><strong>Quand la Skill est activée</strong><br>Une fois le code produit ou modifié.</p><h4>Comment le contexte est réellement utilisé</h4><ol><li>Le prompt utilisateur arrive<br> → <strong>aucune Skill n’est encore chargée</strong></li><li>Une réflexion technique est nécessaire<br> → tech-design est activée<br> → ses instructions entrent temporairement dans le contexte</li><li>Le code est généré<br> → tech-design disparaît du contexte</li><li>Une validation est requise<br> → implementation-review est activée<br> → le contexte contient uniquement les règles de review</li></ol><p><strong>À aucun moment les deux rôles ne cohabitent dans le contexte.</strong></p><h4>Pourquoi cet exemple est important</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o_xXOORs0R6_tOl-.png" /></figure><p>Sans Skills :</p><ul><li>le prompt devrait contenir à la fois :</li><li>des règles d’architecture</li><li>des règles de review</li><li>des conventions de style</li><li>le contexte serait plus lourd et plus fragile</li></ul><p>Avec Skills :</p><ul><li>chaque rôle humain est <strong>isolé</strong></li><li>le contexte reste <strong>court et intentionnel</strong></li><li>le comportement est plus stable sur les tâches longues</li></ul><h3>Pourquoi ce pattern dépasse largement le coding</h3><p>Si ce pattern est né dans les agents de code, ce n’est pas un hasard :</p><ul><li>le code est strict,</li><li>les erreurs sont coûteuses,</li><li>les workflows sont longs et cumulés.</li></ul><p>Mais exactement les mêmes contraintes existent ailleurs :</p><ul><li>agents métier,</li><li>agents data / BI,</li><li>agents juridiques</li><li>agents RAG complexes,</li><li>agents multi-outils en production.</li></ul><p>Partout où le contexte devient riche et persistant, <strong>le context engineering devient plus important que le prompt lui-même</strong>.</p><h3>Conclusion</h3><p>Les <em>Agent Skills</em> marquent un tournant clair :</p><ul><li>❌ ce n’est pas “meilleurs prompts”</li><li>❌ ce n’est pas “plus de tokens”</li><li>✅ c’est <strong>structurer ce qui entre (ou non) dans le contexte</strong></li></ul><p>Claude Code a montré la voie. Codex l’adopte aujourd’hui. AgentSkills.io tente d’en faire un standard transversal.</p><p>Le futur des agents n’est pas un agent qui sait tout, mais un agent qui sait <strong>quoi charger, quand, et pourquoi</strong>.</p><p>Liens: <br>- <a href="https://developers.openai.com/codex/skills/">https://developers.openai.com/codex/skills/</a><br>- <a href="https://code.claude.com/docs/en/skills">https://code.claude.com/docs/en/skills</a><br>- <a href="https://agentskills.io/home">https://agentskills.io/home</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=13294ef0d652" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agent Lightning]]></title>
            <link>https://jeremyjouvance.medium.com/agent-lightning-409455c423a5?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/409455c423a5</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sat, 08 Nov 2025 12:23:02 GMT</pubDate>
            <atom:updated>2025-11-08T12:23:02.113Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Z8mvg6N11t5pZiQA.png" /></figure><p><em>Et si vos agents d’intelligence artificielle pouvaient apprendre après leur déploiement ?</em><br>C’est la promesse d’<strong>Agent Lightning</strong>, un nouveau framework open source conçu par <strong>Microsoft Research</strong> pour rendre les agents IA véritablement évolutifs.</p><h3>Le problème : des agents brillants… mais figés</h3><p>Depuis l’explosion des agents d’intelligence artificielle, un constat s’impose : la plupart d’entre eux ne s’améliorent pas avec le temps.</p><p>Une fois déployés, ces agents restent prisonniers de leur logique initiale. Incapables d’apprendre de leurs erreurs, de s’adapter à de nouveaux contextes ou d’évoluer face à des utilisateurs qui changent leurs attentes.</p><p>En production, cela se traduit par une dégradation progressive des performances (le fameux <strong>drift</strong>), des corrections manuelles incessantes et un coût de maintenance qui explose.</p><p>En somme, nos agents sont “intelligents”, mais pas “apprenants”.</p><p>Et si on pouvait enfin briser ce cycle statique pour permettre aux agents de <strong>s’améliorer continuellement </strong>directement à partir de leurs interactions réelles ?</p><h3>Agent Lightning ?</h3><p><strong>Agent Lightning</strong> est un framework qui permet d’appliquer le <strong>Reinforcement Learning (RL)</strong> à n’importe quel agent IA, quel que soit son framework d’origine : <strong>LangChain</strong>, <strong>AutoGen</strong>, <strong>OpenAI Agents SDK</strong>, ou même un agent maison.</p><p>L’objectif : permettre aux agents <strong>de s’améliorer au fil de leur utilisation réelle</strong>, sans nécessiter de réécriture du code.</p><p><strong>En résumé</strong> : vous déployez un agent, il agit, collecte des retours, et s’entraîne automatiquement à mieux faire.</p><h3>Pourquoi c’est une avancée majeure</h3><p>Jusqu’à présent, la plupart des agents LLM étaient <strong>statiques</strong> :</p><ul><li>on les conçoit</li><li>on les déploie</li><li>puis on les laisse vieillir…</li></ul><p>Agent Lightning change cette logique en introduisant une <strong>séparation complète entre exécution et entraînement</strong>.</p><p>Grâce à cette <strong>architecture disjointe</strong>, on peut brancher un agent déjà en production sur un serveur d’apprentissage sans modifier son code.</p><h3>L’algorithme LightningRL</h3><p>Le cœur du système s’appelle <strong>LightningRL</strong>, un algorithme hiérarchique de reinforcement learning.</p><p>Il introduit deux innovations majeures :</p><ol><li><strong>Credit Assignment Module</strong><br> → Répartit la récompense globale sur chaque action ou sous-étape de l’agent.</li><li><strong>Transition-Based Training</strong><br> → Au lieu d’entraîner un long dialogue concaténé, on apprend <em>transition par transition</em>, ce qui rend l’entraînement plus stable et scalable.</li></ol><p>LightningRL est compatible avec les méthodes RL existantes :<br> <strong>PPO</strong>, <strong>GRPO</strong>, <strong>REINFORCE++</strong>, etc</p><h3>L’architecture « Training–Agent Disaggregation »</h3><p>Une des idées les plus puissantes du projet est cette <strong>séparation entre l’agent et son apprentissage</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/438/1*g28mo81TuBfTyVee35wJwQ.png" /></figure><p>Les deux communiquent via une API de type<strong> </strong>OpenAI<strong>, </strong>ce qui signifie qu’un agent LangChain ou interne peut être branché tel quel au serveur.</p><p>Cette séparation permet :</p><ul><li>de <strong>faire tourner les agents sur n’importe quelle machine</strong> (même sans GPU)</li><li>de <strong>centraliser l’entraînement</strong> sur des serveurs RL spécialisés</li><li>et d’<strong>entraîner plusieurs agents simultanément</strong>.</li></ul><h3>Fonctionnalités avancées</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jAWRpSjjD-af0f0wGUeGkQ.png" /></figure><h4>1. Observabilité native</h4><p>Agent Lightning s’intègre à <strong>OpenTelemetry</strong> et <strong>AgentOps</strong> pour instrumenter automatiquement vos agents.</p><h4>2. Récompenses intermédiaires automatiques (AIR)</h4><p>Le module <strong>Automatic Intermediate Rewarding</strong> convertit les signaux système (succès d’un appel d’API, format correct, etc.) en récompenses partielles, accélérant l’apprentissage.</p><h4>3. Résilience et scalabilité</h4><ul><li>Reprise automatique en cas de crash</li><li>Parallélisation intra et inter-nœuds</li><li>Gestion distribuée des agents et environnements</li></ul><h3>Résultats concrets</h3><p>Les chercheurs de Microsoft Research ont testé Agent Lightning sur trois cas réels :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/563/1*olUm_q3P4hoVti6sl2-iLQ.png" /></figure><p>Dans tous les cas, le modèle a montré une <strong>amélioration continue</strong> grâce à l’entraînement par LightningRL.</p><h3>Agent Lightning face au <em>drift</em></h3><p>En Machine Learning, le <strong>drift</strong> désigne la dégradation des modèles dans le temps. Les données changent, les comportements évoluent, les résultats se dégradent.</p><p>Agent Lightning transforme cette contrainte en avantage : chaque interaction devient une <strong>expérience d’apprentissage</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/1*1nWFiixe4LqAYrxIsJrWew.png" /></figure><h3>Pour qui et pour quoi ?</h3><p>Agent Lightning s’adresse à tous ceux qui exploitent des agents complexes :</p><ul><li><strong>Plateformes d’automatisation</strong> (workflow, etc)</li><li><strong>Agents multi-tâches</strong> (analyse, code, RAG, chat, reporting)</li><li><strong>Applications en production</strong> qui évoluent vite et nécessitent adaptation continue</li></ul><p>Il offre une approche systématique pour <strong>rendre les agents réellement autonomes et robustes</strong>.</p><h3>Conclusion</h3><p><strong>Agent Lightning</strong> n’est pas qu’un nouveau framework, c’est une vision.</p><p>Une façon de concevoir des agents IA <strong>qui apprennent en continu, interagissent, se corrigent et évoluent</strong>.</p><p>Dans un monde où les modèles dérivent, Agent Lightning nous rapproche d’une <strong>intelligence réellement adaptative</strong>, où chaque interaction devient une opportunité d’amélioration.</p><p>liens:</p><ul><li><a href="https://arxiv.org/pdf/2508.03680">https://arxiv.org/pdf/2508.03680</a></li><li><a href="https://www.microsoft.com/en-us/research/project/agent-lightning/">https://www.microsoft.com/en-us/research/project/agent-lightning/</a></li><li><a href="https://github.com/microsoft/agent-lightning">https://github.com/microsoft/agent-lightning</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=409455c423a5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Au-delà des limites : comment la compression contextuelle optique transforme les agents IA en…]]></title>
            <link>https://jeremyjouvance.medium.com/au-del%C3%A0-des-limites-comment-la-compression-contextuelle-optique-transforme-les-agents-ia-en-6d7b4d9d87cb?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d7b4d9d87cb</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Fri, 24 Oct 2025 23:13:15 GMT</pubDate>
            <atom:updated>2025-10-24T23:13:15.387Z</atom:updated>
            <content:encoded><![CDATA[<h3>Au-delà des limites : comment la compression contextuelle optique transforme les agents IA en entreprise</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/824/1*rPrzX94AEGAzjOn-DRRzGQ.png" /></figure><p>Les entreprises avancées sur l’IA ont déjà rencontré le même obstacle : un agent IA ne peut travailler qu’avec une <strong>fenêtre de contexte limitée</strong>. Même avec de grands modèles, dès qu’il doit assimiler un rapport de 200 pages, un historique complet d’emails ou l’ensemble d’un ticketing, <strong>il oublie</strong>. L’IA perd le fil.<br> Résultat : fragmentation des workflows, perte d’informations, réponses incomplètes… et un coût élevé de traitement.</p><p>Mais une nouvelle approche est en train de <strong>changer le game plan</strong> : la <em>compression contextuelle optique</em>.</p><h3>Comment ça marche ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VY3nNX0QtJtM-zd4AyieGg.png" /></figure><p>Une avancée technique récente combine vision et langage pour <strong>compresser du texte en images</strong>, puis l’interpréter via un modèle multimodal. Cette approche permet de représenter le même contenu avec <strong>beaucoup moins de tokens</strong>.<br> Elle repose notamment sur l’OCR multimodal, transformant documents et mises en page en un format visuel compact</p><p>Les encoders visuels génèrent des <em>vision tokens</em>, qui sont ensuite décodés en compréhension textuelle. Le gain est spectaculaire : <strong>jusqu’à 7 à 10× moins de tokens pour ~97 % de précision</strong></p><p>Et cela peut monter jusqu’à 20× selon les contenus — avec une perte progressive mais souvent acceptable selon l’usage</p><h3>Ce que cela change pour les agents IA</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/966/1*-6CCfqEH41r9D_2PUGvpPA.png" /></figure><p>En réduisant drastiquement les tokens utilisés :</p><p>- On étend <strong>massivement</strong> la mémoire des agents<br>- Les coûts d’exploitation diminuent<br>- La compréhension devient plus globale :<br> documents + tableaux + graphiques + historique d’échanges<br>- On peut automatiser des workflows entiers sans découper le contexte<br>- Les architectures se simplifient → moins de RAG, plus d’intelligence native</p><p>Cette approche capture <strong>beaucoup mieux</strong> la structure d’un document, les tableaux et les relations spatiales qui échappent aux modèles textuels classiques, ce qui améliore la compréhension documentaire</p><h3>Quelques exemples d’application concrètes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SKIXhSCkqoknxXbhBYCW6A.png" /></figure><ul><li>Finance/Juridique: Analyse Integrale de contrats, KYC, rapport d’entreprise → Decision Rapide</li><li>Support / Service client: Agents qui lisent tout l’historiques + pieces jointes → Resolution + Satisfaction client</li><li>Operations / Devops: Logs + Tickets + Spec Produit → Automatisations intelligentes des actions / reduction des incidents</li><li>Connaisance De l’entreprise: Scans, Pdf, Documents, Historique → Connaissance globale a grande echelle</li></ul><p>En clair : <strong>l’agent ne devine plus — il se souvient</strong>.</p><h3>Un tournant architectural</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mIL9wKC7ACg5YP30MHxmmA.png" /></figure><p>Jusqu’ici, le design des agents était dicté par une contrainte : Qu’elle sont les informations que l’on peut supprimer du contexte ?</p><p>Desormais avec cette architecture la question change: Qu’est ce que je peut ajouter pour que la decision soit plus precise.</p><p>Cela affecte directement les patterns d’architecture interne :</p><ul><li>Fin de la micro-chunkification systématique</li><li>Stockage/mémoire des agents repensé</li><li>Automatisation plus profonde dans les processus métiers</li><li>RAG simplifié (voire supprimé selon les cas)</li><li>Adoption rapide dans tous les métiers documentaires</li></ul><p>Le passage à des agents <strong>plus compétents, moins coûteux et réellement informés</strong> devient enfin accessible.</p><h3>Et après ?</h3><p>On entre dans une nouvelle ère :<br>celle où les agents IA <strong>comprennent l’entreprise dans son ensemble</strong>, et pas seulement la dernière question posée.</p><p>Pour les entreprises qui investissent aujourd’hui dans leurs usages IA, cette technologie ouvre la porte à une <strong>scalabilité réelle</strong> :</p><p>→ plus d’agents<br> → plus de mémoire<br> → plus de valeur business</p><p>Et surtout :<br> <strong>moins de limitations artificielles</strong>.</p><p>Links:</p><ul><li><a href="https://github.com/deepseek-ai/DeepSeek-OCR">https://github.com/deepseek-ai/DeepSeek-OCR</a></li><li><a href="https://arxiv.org/html/2510.18234v1">https://arxiv.org/html/2510.18234v1</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d7b4d9d87cb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Du texte au monde : comment Meta veut réinventer les modèles de code avec Code World Model]]></title>
            <link>https://jeremyjouvance.medium.com/du-texte-au-monde-comment-meta-veut-r%C3%A9inventer-les-mod%C3%A8les-de-code-avec-code-world-model-05bc6f90ad9e?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/05bc6f90ad9e</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sun, 28 Sep 2025 19:37:56 GMT</pubDate>
            <atom:updated>2025-09-28T19:37:56.782Z</atom:updated>
            <content:encoded><![CDATA[<h3>Du texte au monde : comment Meta veut réinventer les modèles de code avec Code World Model</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6LDoXT7oYkmikvQLyU2eyQ.png" /></figure><p>Depuis le début, les LLM (Large Language Models) ont surtout été des machines à prédire du texte. Donnez-leur le début d’une phrase, et ils complètent. Donnez-leur un bout de code, et ils écrivent la suite. Puissant, mais limité : comprendre <em>vraiment</em> ce que fait ce code n’était pas leur rôle.</p><h3>L’évolution : LLM → Reasoning LLM → World Models</h3><ol><li><strong>LLM classiques</strong> : prédire le prochain mot/token. Exemple : vous tapez for i in range( et le modèle complète avec 10):.</li><li><strong>Reasoning LLM</strong> : ils ajoutent une capacité de raisonnement explicite. Exemple : résoudre un problème de maths étape par étape avant de donner la réponse.</li><li><strong>World Models</strong> : ici, le modèle n’apprend pas seulement à prédire du texte, mais à <em>simuler un environnement</em> et à anticiper les conséquences des actions. C’est ce saut que propose Meta avec <strong>CWM (Code World Model)</strong>.</li></ol><p>Google explore une approche voisine avec <strong>Genie 3</strong>, un modèle visuel-interactif capable de transformer une simple image ou description en un environnement jouable. Comme CWM pour le code, Genie 3 illustre cette tendance à doter les IA d’une compréhension « incarnée » des mondes dans lesquels elles opèrent. <a href="https://deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/">https://deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/</a></p><h3>Un exemple concret : écrire du code qui agit</h3><p>Imaginons que vous demandez à un modèle classique :</p><blockquote><em>“Écris un script Python qui crée un fichier et y enregistre ‘Hello World’.”</em></blockquote><p>Un LLM traditionnel va générer quelque chose comme :</p><pre>with open(&quot;test.txt&quot;, &quot;w&quot;) as f:<br>    f.write(&quot;Hello World&quot;)</pre><p>C’est correct, mais le modèle n’a aucune idée de ce que fait vraiment ce code une fois exécuté.</p><p>Avec <strong>CWM</strong>, le modèle a été exposé à des trajectoires d’exécution : il a vu qu’ouvrir un fichier peut échouer si le dossier n’existe pas, qu’écrire peut générer une erreur de permission, qu’un fichier peut être relu ensuite. Autrement dit, il apprend non seulement à écrire du code, mais aussi à <em>anticiper ce qui se passera quand ce code sera lancé</em>.</p><h3>Comment ça fonctionne vraiment</h3><p>CWM est un modèle <strong>dense de 32 milliards de paramètres</strong> entraîné avec une architecture adaptée aux longs contextes. Voici les briques essentielles :</p><ul><li><strong>Grouped-Query Attention (GQA)</strong> : une variante de l’attention qui permet de gérer efficacement de très grandes séquences.</li><li><strong>Alternance local/global</strong> : certaines couches se concentrent sur les dépendances locales, d’autres sur la vue d’ensemble, pour mieux équilibrer détail et contexte.</li><li><strong>Tokenizer optimisé</strong> : conçu pour le code et le texte technique, afin de réduire la fragmentation des symboles et mots-clés.</li></ul><h3>Trois étapes d’apprentissage</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sRdVqwwmyeHca-iLUrOgHA.png" /></figure><p>Meta a entraîné CWM en trois grandes phases :</p><ol><li><strong>Pré-entraînement</strong> : sur du code open source (Python, C++, etc.) et du texte STEM, afin de donner des bases générales de programmation et de raisonnement scientifique.</li></ol><p><strong>2. World modeling training</strong> : c’est l’innovation clé. Le modèle est exposé à des <em>trajectoires observation-action</em> :</p><ul><li>Exécutions Python avec captures d’erreurs et sorties,</li><li>Interactions agentiques dans des environnements Docker (ex. lancer une commande shell, voir l’effet, continuer),</li><li>Sessions de debugging avec modifications successives du code et résultats de tests.</li></ul><p>À chaque étape, le modèle doit prédire l’action suivante et apprendre la dynamique du système.</p><p><strong>3. Post-training</strong> : affinage en deux volets :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CTeGJR6htRF3NyOfZGsyPg.png" /></figure><ul><li><strong>SFT (Supervised Fine Tuning)</strong> sur des tâches guidées, où des solutions correctes sont fournies,</li><li><strong>RL (Reinforcement Learning)</strong> avec des récompenses basées sur la réussite des programmes générés (tests qui passent, bugs corrigés, etc.).</li></ul><h3>Exemples concrets qui illustrent CWM (code)</h3><h4>1) CWM — Gestion d’erreurs fichiers (anticipation + correctif)</h4><p><strong>Contexte</strong> : un script doit écrire un log dans ./runs/output/log.txt.</p><ul><li><strong>Observation</strong> : le test d’intégration échoue, trace : FileNotFoundError: [Errno 2] No such file or directory: &#39;./runs/output/log.txt&#39;.</li><li><strong>Action proposée par CWM</strong> : créer les dossiers manquants avant l’écriture.</li></ul><pre>from pathlib import Path<br>p = Path(&quot;./runs/output&quot;)<br>p.mkdir(parents=True, exist_ok=True)<br>with open(p/&quot;log.txt&quot;, &quot;a&quot;) as f:<br>    f.write(&quot;started\n&quot;)</pre><ul><li><strong>Résultat attendu</strong> : le test passe, plus d’exception. CWM a <strong>modélisé</strong> l’effet système (structure de dossiers) et choisi l’action corrective.</li></ul><h4>2) CWM — API qui change (raisonnement multi-étapes)</h4><p><strong>Contexte</strong> : une lib passe de fetch_user(id) à get_user(user_id, *, verbose=False).</p><ul><li><strong>Observation</strong> : tests unitaires : TypeError: fetch_user() missing 1 required positional argument.</li><li><strong>Plan de CWM</strong> :</li></ul><ol><li>Chercher l’appel fautif.</li><li>Lire la doc de version (diff fournis en contexte).</li><li>Migrer les appels et adapter les mocks.</li></ol><pre># avant<br>user = fetch_user(42)<br># après<br>user = get_user(user_id=42, verbose=False)</pre><ul><li><strong>Résultat attendu</strong> : tests rétablis. CWM relie <strong>diff -&gt; code -&gt; tests</strong> et agit en conséquence.</li></ul><h4>3) CWM — Correction d’un bug algorithmique guidée par tests</h4><p><strong>Contexte</strong> : une fonction de somme cumulée off-by-one.</p><ul><li><strong>Observation</strong> : test échoue sur [1,2,3] → attendu [1,3,6], obtenu [0,1,3].</li><li><strong>Action</strong> : analyser la boucle, corriger l’initialisation.</li></ul><pre>def cumsum(xs):<br>    out, total = [], 0<br>    for x in xs:<br>        total += x<br>        out.append(total)<br>    return out</pre><ul><li><strong>Résultat</strong> : tous les tests passent. CWM utilise l’<strong>exécution</strong> comme feedback, pas seulement la prédiction de texte.</li></ul><h4>4) Pont commun : boucles “Observation → Action → Feedback”</h4><ul><li><strong>CWM</strong> : (logs/tests/diffs) → propose un patch → relance les tests → itère.</li><li><strong>Genie 3</strong> : (image/prompt) → génère un monde → reçoit l’input du joueur → ajuste la simulation.</li></ul><blockquote><em>Dans les deux cas, on s’éloigne d’un modèle “qui complète du texte” vers un système </em><strong><em>qui agit dans un monde</em></strong><em>, observe, et corrige.</em></blockquote><h3>Pourquoi c’est important</h3><p>Dans le monde réel, coder ne consiste pas seulement à écrire des lignes correctes. Il faut :</p><ul><li>comprendre l’effet d’un programme sur un système,</li><li>anticiper les erreurs et exceptions,</li><li>corriger et itérer.</li></ul><p>CWM cherche à capturer cette dimension dynamique et à transformer l’IA en un <em>agent développeur</em> capable de raisonner et d’agir dans un environnement logiciel.</p><p>De la même manière, <strong>Genie 3</strong> de Google illustre comment ces principes peuvent s’appliquer à des environnements visuels et interactifs, où l’IA ne décrit pas seulement une scène, mais peut <em>simuler</em> et <em>jouer</em> dedans. Cela renforce l’idée que les modèles du futur ne seront pas uniquement linguistiques, mais bel et bien des simulateurs de mondes.</p><h3>Quelques résultats impressionnants</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VdSeFla9CEVQUL_ptFci3w.png" /><figcaption>SWE-bench verified</figcaption></figure><ul><li><strong>65,8 %</strong> sur SWE-bench Verified (corriger automatiquement des bugs logiciels),</li><li><strong>96,6 %</strong> sur Math-500 (problèmes mathématiques de référence),</li><li><strong>76 %</strong> sur AIME 2024 (problèmes de concours de mathématiques).</li></ul><h3>Comparaison avec les modèles traditionnels</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/704/1*m3dcoUFMz6QnqTuAAPL4bA.png" /></figure><ul><li>Les modèles classiques traitent le code comme une simple séquence de tokens.</li><li>CWM va plus loin en considérant le logiciel comme un <strong>système dynamique</strong>, avec états et transitions.</li><li>Cela ouvre des capacités nouvelles : debugging, refactoring, corrections multi-étapes.</li></ul><h3>Applications potentielles</h3><ul><li><strong>Automatisation du debugging</strong> : corriger des bugs à partir de logs et de tests.</li><li><strong>Assistance dans des projets complexes</strong> : prendre en compte plusieurs fichiers, historiques de commits et tests d’intégration.</li><li><strong>Agents logiciels</strong> : modèles capables de proposer, tester et valider des patches de manière autonome.</li><li><strong>Au-delà du code</strong> : appliquer la logique de world modeling à d’autres environnements où les actions ont des effets mesurables (systèmes physiques simulés, jeux, robotique).</li></ul><h3>Limites et précautions</h3><ul><li>CWM est publié avec des <strong>poids ouverts pour la recherche</strong>, sous licence non commerciale.</li><li>Le modèle n’est pas conçu pour la production : son comportement peut rester imprévisible dans certains contextes.</li><li>Comme tout LLM, il peut halluciner ou produire des solutions incorrectes.</li><li>L’utilisation requiert des ressources massives (entraîner ou inférer un modèle de 32B paramètres n’est pas trivial).</li></ul><h3>En résumé</h3><p>L’évolution est claire :</p><ul><li>Les <strong>LLM</strong> savaient prédire du texte,</li><li>Les <strong>Reasoning LLM</strong> savaient réfléchir étape par étape,</li><li>Les <strong>World Models</strong> commencent à simuler et comprendre des environnements.</li></ul><p>Avec CWM, Meta ouvre une nouvelle voie : et si les modèles de code ne se contentaient pas d’écrire, mais devenaient capables de raisonner comme un développeur qui <em>voit</em> l’impact de ses actions ?</p><p>Links:</p><ul><li><a href="https://deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/">https://deepmind.google/discover/blog/genie-3-a-new-frontier-for-world-models/</a></li><li><a href="https://ai.meta.com/research/publications/cwm-an-open-weights-llm-for-research-on-code-generation-with-world-models/">https://ai.meta.com/research/publications/cwm-an-open-weights-llm-for-research-on-code-generation-with-world-models/</a></li><li><a href="https://huggingface.co/facebook/cwm">https://huggingface.co/facebook/cwm</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*ZT5F8q8AjvILErtenMM0XQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=05bc6f90ad9e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Persona Vectors : une nouvelle boussole pour piloter la personnalité des LLM en entreprise]]></title>
            <link>https://jeremyjouvance.medium.com/persona-vectors-une-nouvelle-boussole-pour-piloter-la-personnalit%C3%A9-des-llm-en-entreprise-63518ecf1465?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/63518ecf1465</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sun, 03 Aug 2025 14:27:46 GMT</pubDate>
            <atom:updated>2025-08-03T14:32:09.980Z</atom:updated>
            <content:encoded><![CDATA[<h3>Persona Vectors : une nouvelle boussole pour piloter la personnalité des LLM en entreprise</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m1WY2rBetwtJNZuTO-9G7w.png" /></figure><p>Les <strong>persona vectors</strong> constituent une avancée majeure pour comprendre et maîtriser la « personnalité » des grands modèles de langage (LLM) en entreprise. Ces vecteurs linéaires, extraits automatiquement à partir d’une description naturelle d’un trait de caractère (p. ex. « malveillance », « flatterie excessive », « tendance à halluciner »), permettent à la fois de <strong>surveiller</strong>, <strong>contrôler</strong> et <strong>prévenir</strong> les déviations indésirables de comportement d’un assistant conversationnel.</p><h3>Comprendre les persona vectors</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Bmaa3D4harlD2gZp" /></figure><p>Un persona vector est tout simplement une <strong>direction linéaire / une flèche, </strong>dans l’espace d’activation interne du modèle qui encode un trait de caractère donné.</p><p>Prenons l’exemple du trait « malveillance » :</p><ol><li><strong>Génération de prompts contrastés</strong>. On crée automatiquement deux types de contextes :</li></ol><ul><li>Un contexte « <strong>positif </strong>» qui incite le modèle à se comporter de manière malveillante,</li><li>Un contexte « <strong>négatif </strong>» qui le dissuade d’adopter ce comportement.</li></ul><p><strong>2. Extraction des activations</strong>. Pour chaque type de contexte, on enregistre les activations (i.e. les vecteurs internes) du modèle lors de la génération de réponses.</p><p><strong>3. Calcul du persona vector</strong>. On calcule la différence entre la moyenne des activations « malveillantes » et la moyenne des activations « non-malveillantes ». Cette différence définit le vecteur « <strong>malveillance </strong>»</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_x31ZSKEiQRzYFIlcUqSwA.png" /></figure><h3>Applications en entreprise</h3><h4>Surveillance en temps réel</h4><p>En déploiement, chaque message du système peut être projeté sur les persona vectors pour détecter <strong>instantanément</strong> une dérive. Par exemple, un chatbot de support client peut, suite à une requête délicate, partir dans un ton agressif ou défaitiste :</p><pre>Client : « Votre produit m’a gravement déçu ! »  <br>Chatbot : (projection sur vecteur “malveillance” élevée) → Alerte : ton trop hostile.</pre><p>Une alerte interne peut alors proposer une reformulation plus neutre, évitant une escalade de mécontentement.</p><h4>Contrôle par steering</h4><p>Au lieu d’attendre la dérive, on peut <strong>ajuster</strong> activement l’activation du modèle en cours de génération. Concrètement, on ajoute à chaque étape de décodage une petite quantité du persona vector « bienveillance » ou on soustrait le vecteur « malveillance », guidant la réponse vers un ton plus constructif.</p><blockquote><strong><em>Cas pratique</em></strong><em> : une entreprise de e‑commerce souhaite que son assistant soit toujours encourageant. En appliquant un steering vers le vecteur « optimisme », les messages de relance deviennent plus engageants sans céder à la flatterie excessive.</em></blockquote><h4>Prévention lors du fine-tuning</h4><p>Lorsqu’on adapte un LLM aux données internes d’une entreprise (manuel produit, FAQ, retours clients), un fine-tuning mal calibré peut <strong>involontairement</strong> rendre le modèle trop acquiesçant ou au contraire trop sec.</p><p>En analysant <strong>auparavant</strong> chaque lot de données par projection sur les persona vectors, on peut repérer et éliminer les exemples à risque:</p><ul><li><strong>Identification de datasets</strong> produisant une forte sycophancy (flatterie excessive).</li><li><strong>Filtrage des phrases</strong> trop directives ou agressives avant apprentissage.</li></ul><h3>Exemples concrets</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pKdTxM3biXUBNX5WW3RCqg.png" /></figure><h3>Pourquoi adopter les persona vectors ?</h3><ol><li><strong>Sérénité opérationnelle</strong> : les équipes produit et compliance disposent d’outils quantitatifs pour garantir la <strong>cohérence</strong> et la <strong>sécurité</strong> des assistants IA.</li><li><strong>Agilité et personnalisation</strong> : un persona vector est extrait en quelques minutes à partir d’une simple description textuelle ; l’entreprise peut définir ses propres traits cibles (ex. « langage formel », « ton humoristique ») et les contrôler finement.</li><li><strong>Économie de ressources</strong> : plutôt que de réentraîner un modèle complet pour chaque nouvelle exigence, on <strong>ajuste</strong> localement son comportement au moment de la génération.</li></ol><h3>Différences d’application entre modèles open-source et modèles propriétaires</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5JiFM_d05Wr8eZ5sFuKPBQ.png" /></figure><blockquote><strong><em>Exemple concret</em></strong><em> : pour un LLM open-source (ex. LLaMA), un data scientist peut extraire directement le persona vector « neutralité » et l’intégrer au pipeline de génération interne. Avec un modèle propriétaire (ex. GPT-4o), on utilisera plutôt un proxy : on envoie deux requêtes contrastées et on calcule la différence de log‑probabilités (logprobs=1) pour estimer le vecteur puis on applique un prompt dynamique en retour.</em></blockquote><h3>Conclusion</h3><p>Les persona vectors offrent une <strong>nouvelle boussole</strong> pour piloter les personnalités des LLM, en <strong>passant du noir / blanc au continu</strong> : plutôt que de subir des écarts imprévus, les entreprises peuvent désormais <strong>mesurer</strong>, <strong>ajuster</strong>, et <strong>prévenir</strong> les glissements de ton ou d’attitude. Que ce soit pour un chatbot, un générateur de contenu marketing ou un assistant interne, cette technologie garantit une interaction IA toujours alignée avec vos <strong>valeurs</strong> et vos <strong>objectifs</strong>.</p><p>Source:</p><ul><li><a href="https://github.com/safety-research/persona_vectors/tree/main">https://github.com/safety-research/persona_vectors/tree/main</a></li><li><a href="https://arxiv.org/abs/2507.21509">https://arxiv.org/abs/2507.21509</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63518ecf1465" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kimi K2 — The New Deepseek]]></title>
            <link>https://jeremyjouvance.medium.com/kimi-k2-the-new-deepseek-b27208d559c2?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/b27208d559c2</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Mon, 21 Jul 2025 11:12:35 GMT</pubDate>
            <atom:updated>2025-07-21T11:12:35.177Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kimi K2 — The New Deepseek</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*buF3CaEjkHVoXFcO" /></figure><p>En juillet 2025, Moonshot AI, une équipe de seulement 200 spécialistes, a dévoilé Kimi K2, un modèle d’IA open source comptant un trillion de paramètres. Plus surprenant encore : Kimi K2 n’active que 32 milliards de ces paramètres par tâche. Cet exploit technique, rendu possible par une architecture Mixture of Experts (MoE) et le stabilisateur neuronal MuonClip, promet de rendre l’IA de pointe accessible à tous — startups, chercheurs, développeurs et étudiants.</p><h3>Comment allier puissance et légèreté ?</h3><p>Kimi K2 repose sur un design modulaire ultra‑flexible, où des milliers d’« experts » sont spécialisés sur des domaines précis (programmation, analyse de données, mathématiques, etc.). Au lieu d’utiliser la totalité de ses 1 000 milliards de paramètres, le modèle sélectionne dynamiquement les 30 milliards les plus pertinents pour répondre à votre requête.</p><ul><li><strong>Sélection intelligente</strong> : Chaque prompt déclenche l’activation des experts adaptés, réduisant drastiquement la consommation de mémoire et de calcul.</li><li><strong>Scalabilité réduite</strong> : Tourne efficacement sur des clusters GPU accessibles, plutôt que sur des supercalculateurs dédiés.</li></ul><h3>Des Capacités Agentiques et Créatives Impressionnantes</h3><p>Kimi K2 ne se limite pas à fournir des réponses textuelles. Il agit, code, construit et prototyper :</p><ul><li><strong>Jeux complets</strong> : Génération en une seule passe d’un jeu Minecraft fonctionnel.</li><li><strong>Développement web</strong> : Création de pages HTML/CSS/JS responsives en un prompt.</li><li><strong>Analyse de données</strong> : Traitement de milliers de lignes Excel et génération d’interfaces web interactives.</li><li><strong>Jeux HTML5/JS</strong> : Conception rapide de jeux comme Flappy Bird en moins de 30 secondes.</li><li><strong>IA en temps réel</strong> : Détecteur de sentiments contextuel, scoring historique et visualisation.</li><li><strong>Modules 3D</strong> : Implémentation de scènes interactives avec Three.js.</li></ul><h3>Performances Benchmark Inégalées</h3><p>Sur les principaux benchmarks internationaux, Kimi K2 affiche des résultats spectaculaires :</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1DDjzSTlAiaAkhfGbYUrkw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jn7Z-Zr72UJot8HO2t3Zxg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0A5LC-Z7qLjJHuv1r0-BOg.png" /></figure><p>Ces performances classent Kimi K2 en tête des modèles open source et concurrencent directement les solutions propriétaires comme GPT‑4.1 et Claude 4.</p><h3>Open Source et Accessibilité Économique</h3><h4>Moonshot AI a mis en ligne :</h4><ul><li>Le code source complet et les poids du modèle sur GitHub (<a href="https://github.com/MoonshotAI/Kimi-K2">https://github.com/MoonshotAI/Kimi-K2</a>)</li><li>Une documentation détaillée pour l’installation locale</li><li>Des APIs à des tarifs 10 à 20 fois inférieurs à ceux de GPT‑4 et Claude 4</li><li>Un rapport de recherche détaillé (bientôt disponible)</li></ul><h4>Licence et Données d’Entraînement</h4><ul><li><strong>Licence</strong> : Kimi K2 est publié sous une <strong>licence MIT modifiée</strong>, facilitant son intégration dans des projets open source et commerciaux.</li><li><strong>Jeu de données</strong> : Entraîné sur <strong>15,5 trillions de tokens</strong> issus de corpus variés (textes web, code open source, ouvrages académiques, dialogues), garantissant une compréhension large et approfondie.</li></ul><h3>Infrastructure d’inférence : Mooncake</h3><p>Pour servir Kimi K2 à grande échelle, Moonshot AI utilise <strong>Mooncake</strong>, une plateforme serveur innovante (<a href="https://github.com/kvcache-ai/Mooncake">https://github.com/kvcache-ai/Mooncake</a>) :</p><ul><li><strong>Cache KV disaggregé</strong> : Séparation des clusters de pré-remplissage et de décodage pour maximiser le débit.</li><li><strong>Politique de rejet précoce</strong> : Rejet automatique des requêtes non prioritaires pour respecter les objectifs de latence.</li><li><strong>Efficacité supérieure</strong> : Jusqu’à <strong>525 % d’augmentation</strong> du débit en production comparé aux architectures classiques, tout en maintenant des délais de réponse optimaux.</li></ul><h3>Muon Clip : Une Stabilité Simplifiée</h3><h4>Pourquoi la stabilité compte</h4><p>Lorsqu’on entraîne un très grand modèle d’IA (comme ceux de la plupart des projets open source), on utilise souvent un algorithme nommé <strong>Adam</strong> ou sa version améliorée <strong>AdamW</strong>. Bien qu’efficace, Adam peut être capricieux :</p><ul><li><strong>Fluctuations</strong> : Parfois, les valeurs internes du modèle « sautent », rendant l’apprentissage irrégulier.</li><li><strong>Réglages complexes</strong> : Il faut ajuster manuellement plusieurs paramètres (vitesse d’apprentissage, poids de régularisation), ce qui prend du temps.</li><li><strong>Coût et durée</strong> : Ces ajustements allongent l’entraînement et peuvent nécessiter plus de ressources.</li></ul><h4>L’avantage de Muon Clip</h4><p>Avec <strong>Muon Clip</strong>, Moonshot AI a intégré directement un système de régulation des « sauts » dans l’algorithme lui-même :</p><ul><li><strong>Réglage automatique</strong> : Muon Clip adapte en continu la façon dont les valeurs évoluent, sans que l’utilisateur ait à intervenir.</li><li><strong>Apprentissage fluide</strong> : Le modèle progresse de manière régulière, même lorsque les données sont très nombreuses (15 500 milliards de mots analysés).</li><li><strong>Gain de temps et d’énergie</strong> : Moins de tâtonnements et de corrections manuelles signifient un entraînement plus rapide et moins coûteux.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*PqEIWKJfB_PrZpJZVQBpfw.png" /></figure><h3>Implications et Perspectives</h3><p>Kimi K2 inaugure plusieurs évolutions majeures :</p><ol><li><strong>Démocratisation de l’innovation</strong> : Prototypage instantané pour tous, depuis les étudiants jusqu’aux PME.</li><li><strong>Augmentation du travail humain</strong> : Les développeurs deviennent des super-visionnaires, assistés par une IA ultra-puissante.</li><li><strong>Compétition globale</strong> : Après la Silicon Valley, les meilleurs centres de recherche émergent en Chine, en Europe et ailleurs.</li></ol><p><strong>À venir</strong> : intégration du raisonnement approfondi, capacités de vision par ordinateur et modèles spécialisés (sciences, finance, médecine).</p><h3>Conclusion</h3><p>Kimi K2 n’est pas simplement une nouvelle version de modèle : c’est une révolution open source. En combinant performance, accessibilité et modularité, Moonshot AI ouvre la voie à une ère où l’IA de pointe est à la portée de chacun.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b27208d559c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Le prompt engineering, c’est (déjà) du passé. Place au context engineering !]]></title>
            <link>https://jeremyjouvance.medium.com/le-prompt-engineering-cest-d%C3%A9j%C3%A0-du-pass%C3%A9-place-au-context-engineering-cf721da78f03?source=rss-a8f29a31c1df------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf721da78f03</guid>
            <dc:creator><![CDATA[Jeremy Jouvance]]></dc:creator>
            <pubDate>Sat, 05 Jul 2025 19:34:15 GMT</pubDate>
            <atom:updated>2025-07-05T19:34:15.688Z</atom:updated>
            <content:encoded><![CDATA[<h3>Le prompt engineering, c’est (déjà) du passé. Place au <strong>context engineering</strong> !</h3><p>Et si, au lieu de chercher LA formule magique à dicter à une IA, on se penchait enfin sur tout ce qu’on lui envoie ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*3koUxiHu6gDKZOc1" /></figure><h3>L’illusion du prompt parfait</h3><p>Depuis quelques mois, on n’entend parler que de « prompt engineering ». Les réseaux sociaux débordent de threads promettant <em>la</em> phrase qui transformerait ChatGPT et les LLMs en machine surpuissante. Certaines boîtes sont même allées jusqu’à recruter des prompt engineers à… 300 000 $ l’année !</p><p>Soyons serieux: c’était pratique, presque ludique, mais aussi un peu ridicule. On a fini par croire qu’en alignant trois adjectifs et deux instructions, on pouvait décupler l’intelligence du modèle. Or, ces formules relèvent plus de la bidouille que de l’ingénierie sérieuse.</p><p>2025 remet les pendules à l’heure. Sam Altman lui-même l’a dit : bientôt, les modèles comprendront nos demandes telles quelles, sans pirouettes verbales. Gartner va plus loin : d’ici 2027, 80 % des interactions IA se joueront dans le <strong>contexte</strong>, pas dans la tournure de la question.</p><h3>Les agents IA changent la donne : le contexte devient roi</h3><p>Les nouveaux agents, capables de raisonner, d’appeler des outils, de planifier, montrent où se trouve le vrai goulot : la <strong>gestion du contexte</strong>. Pensez à la fenêtre de contexte comme à la RAM d’un ordi : trop petite, on sature ; trop remplie, on rame.</p><p>Sans stratégie, on se retrouve avec :</p><ul><li>un historique qui explose les coûts,</li><li>des temps de réponse qui s’allongent,</li><li>et des performances qui chutent quand l’IA se noie dans des infos inutiles.</li></ul><p>Les labos (Cognition, Anthropic, LangChain…) sont unanimes : le <strong>context engineering</strong> est devenu la priorité.</p><h3>Quatre piliers pour dompter le contexte</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*WputQgakY1ogJ2Y5.png" /></figure><h4>1. Ecrire</h4><p>L’agent note ses trouvailles dans une mémoire externe (scratchpad) au lieu de tout garder « en tête » dans le contexte. Pourquoi ? Cela libère la fenêtre de contexte et garde une trace fiable.</p><h4>2. Selectionner</h4><p>L’agent va chercher juste l’info utile au bon moment (retrieval). Pourquoi ? Cela evite l’amnesie et le bruit.</p><h4>3. Compresser</h4><p>L’agent résume regulièrement la conversation ou les données brutes. Pourquoi ? Afin de reduire les coûts et de maintenir un fil logique et condensé.</p><h4>4. Isoler</h4><p>L’agent compartimente les tâches et les données dans des namespaces. Pourquoi ? Cela limite les interferences et les contradictions.</p><p>Mélangez ces quatre approches et vous obtenez un agent qui exploite au mieux sa mémoire limitée, sans jamais perdre le fil.</p><h3>Pourquoi le prompt engineering ne suffit plus ?</h3><ul><li><strong>Les modèles comprennent mieux le langage naturel.</strong> les modèles récent se débrouillent très bien avec une question mal ficelée.</li><li><strong>Les IA apprennent à se prompter elles-mêmes.</strong> AutoGPT &amp; co. génèrent déjà leurs sous-prompts. Cela est également renforcé par les modèles de raisonnement.</li><li><strong>L’interface devient conversationnelle.</strong> Demain, on discutera avec une IA comme on le ferait avec un collègue, pas avec un terminal ou un robot.</li><li><strong>Les outils low-code/no-code se multiplient.</strong> Le « tweak » de prompt ne sera plus qu’une compétence de base parmi d’autres.</li></ul><p>Bref, bidouiller des prompts est en train de devenir l’équivalent moderne d’écrire du code assembleur : utile jadis, mais plus suffisant aujourd’hui.</p><h3>Conclusion : arrêtons de vénérer le prompt, construisons le contexte</h3><p>La vraie valeur n’est pas la partie émergée de l’iceberg:</p><ul><li><strong>Un seul « chat qui sait tout faire », ça n’existe pas.</strong><br>Chaque scénario mérite son agent spécialisé, pensé pour <em>une</em> stratégie claire plutôt qu’un fourre-tout généraliste.</li><li><strong>La qualité des data est le nerf de la guerre.</strong><br>Un modèle gavé de données bancales hallucine à tous les coups ; curer, nettoyer, versionner reste le pré-requis n° 1.</li><li><strong>Le raisonnement doit épouser la tâche.</strong><br>Une routine de tri de tickets n’exige pas la même chaîne de pensée qu’une analyse financière en plusieurs étapes : adaptez la logique au job, jamais l’inverse.</li><li><strong>La vraie valeur se construit sous le capot.</strong><br>Bases de connaissances bien structurées, mémoires internes/externes, chaînes d’outils cohérentes, protocoles de contrôle… c’est ce <em>contexte</em> qui décuple le QI de vos agents.</li><li><strong>Demain, on embauchera des <em>AI workflow architects</em>.</strong><br>Leur mission : orchestrer modèles, données et outils pour faire bosser une flotte d’agents complémentaires plutôt que bricoler un prompt miracle.</li></ul><p>En clair : moins de magie verbale, plus d’infra contextuelle solide, alignée sur les données et les objectifs. <strong>May the context 🖖 be with you!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf721da78f03" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>