Exécuter une IA agentique sur le Mac avec MLX

À la WWDC 2026, un ingénieur d’Apple a demandé à un agent local installé sur son Mac de récupérer les pull requests récentes du dépôt MLX, d’en résumer les changements et de signaler ce qui méritait attention. Le modèle a raisonné, appelé la CLI GitHub, lu les diffs et produit un résumé. Seules les commandes git ont touché le réseau ; le modèle s’est exécuté entièrement sur son matériel.¹ Cette démonstration résume toute la thèse de cet article : la boucle agentique, le moment où un modèle décide, appelle un outil, observe le résultat et décide à nouveau, s’exécute désormais localement sur le Mac avec MLX. Aucun cloud, aucune clé API, aucun coût par token. Et Apple a livré le reste de l’histoire en même temps : comment répartir cette boucle sur plusieurs Mac, comment sécuriser les fonctionnalités agentiques face à une nouvelle catégorie d’attaque, et comment déboguer la boucle lorsqu’elle fait silencieusement la mauvaise chose.

Cet article parcourt les quatre sessions de la WWDC 2026 qui, ensemble, font de l’IA agentique locale sur le Mac une véritable surface d’ingénierie et non une démonstration technique. Tout ce qui suit provient directement de ces sessions.

En bref

• MLX exécute l’intégralité de la boucle agentique localement sur le Mac grâce à une pile à quatre couches : MLX à la base, MLX-LM pour les modèles, MLX-LM Server comme serveur HTTP compatible OpenAI, et au sommet n’importe quel agent qui parle le protocole de chat completions d’OpenAI.¹
• L’installation se fait en trois étapes : pip install de MLX-LM, exécution de mlx_lm.server avec un modèle capable d’appeler des outils, puis pointage de l’URL de base de votre agent vers localhost.¹
• Lorsqu’un seul Mac ne suffit pas, MLX répartit un modèle sur plusieurs machines via Thunderbolt 5 en s’appuyant sur RDMA et la bibliothèque open source JACCL d’Apple, exécutant des modèles à mille milliards de paramètres et accélérant l’inférence et le fine-tuning d’environ un facteur trois sur un cluster de quatre nœuds.²
• Les fonctionnalités agentiques ouvrent une nouvelle surface d’attaque : l’injection de prompt indirecte. La stratégie d’atténuation d’Apple repose sur des garde-fous déterministes : confirmations via .onToolCall et spotlighting via .historyTransform dans Foundation Models, ainsi que des confirmations basées sur le risque et une authentification sur écran verrouillé dans App Intents.³
• L’instrument Foundation Models de Xcode 27 rend la boucle observable : des couloirs par requête, une vue arborescente de la chaîne de raisonnement du modèle, et les métriques (Time to First Token, Tokens per Second, Total Latency) nécessaires pour détecter les échecs silencieux et les inférences lentes.⁴

La pile agentique locale (Session 232)

Angelos, de l’équipe MLX, présente l’installation en trois étapes, à partir de 2:42.

L’expérience de chat que la plupart des développeurs connaissent renvoie le travail à l’humain. Comme le formule la session : « Vous envoyez un prompt au modèle de langage. Le modèle vous renvoie une réponse. Si vous devez agir sur cette réponse, exécuter une commande, vérifier un fichier ou corriger une erreur, c’est à vous de le faire. »¹ Un agent comble cet écart. L’agent dialogue avec le modèle pour décider quoi faire, appelle des outils pour le faire, observe les résultats, et revient au modèle pour l’étape suivante. De l’utilisateur à l’agent, de l’agent au modèle, de l’agent aux outils, en boucle jusqu’à ce que la tâche soit terminée.

Ce qui rend cette boucle intéressante sur Apple silicon, c’est que tout s’exécute localement. MLX présente cette capacité sous forme de quatre couches, de bas en haut : MLX, « notre framework de tableaux open source spécialement conçu pour Apple silicon », qui gère le calcul, l’accélération Metal et la mémoire ; MLX-LM pour charger, exécuter, quantifier et affiner les modèles issus de Hugging Face ; MLX-LM Server, « un serveur HTTP compatible OpenAI qui expose votre modèle local via une API standard », avec appel d’outils structuré et prise en charge des modèles de raisonnement ; et au sommet, n’importe quel agent qui parle le protocole de chat completions d’OpenAI, qu’il s’agisse de Xcode, d’OpenCode, d’un agent Pi ou d’un script personnalisé.¹ L’interface standard est le choix porteur : « n’importe quel framework d’agent fonctionne immédiatement », et des outils comme Ollama, LM Studio et vLLM s’appuient déjà sur MLX et MLX-LM.¹

L’installation se fait en trois étapes. Installez MLX-LM avec un seul pip install. Démarrez le serveur avec un modèle capable d’appeler des outils :

mlx_lm.server --model <a-tool-calling-model>

Pointez ensuite votre agent vers le serveur local en réglant son URL de base sur localhost. Comme le note la session, « l’agent ne sait pas et ne se soucie pas du fait que le modèle s’exécute sur votre Mac plutôt que dans le cloud ».¹ Dans OpenCode, cela revient à définir un fournisseur local dont l’URL est localhost et dont le nom de modèle correspond à ce que le serveur attend, puis à indiquer à OpenCode d’utiliser ce modèle local pour tout.

La partie intéressante, c’est la façon dont MLX se montre à la hauteur des charges agentiques en particulier. La session nomme trois défis. Le premier est le traitement du prompt : « Les sessions agentiques comportent généralement des centaines de milliers de tokens, et la plupart ne sont pas générés. »¹ Chaque fois que le modèle reçoit la sortie d’un outil, il traite tout ce nouveau contexte avant de poursuivre son raisonnement, et ce coût se répète tout au long de la boucle. Les Neural Accelerators dédiés de la puce M5 rendent la multiplication matricielle quatre fois plus rapide que sur M4, et avec les kernels spécialisés de MLX, « cela se traduit presque exactement par une accélération du traitement du prompt », sans aucun argument particulier ni modification de code.¹ Le deuxième défi est la concurrence : les agents engendrent des sous-agents, et MLX-LM Server gère les requêtes simultanées par batching continu, en les regroupant dynamiquement afin que les sous-agents « ne restent pas bloqués en attente dans une file ».¹ Le troisième défi est la taille du modèle, et c’est là que la session suivante prend le relais.

Angelos a conclu par une démonstration qui va au-delà du lire-et-rapporter : à partir d’un projet Xcode vierge, il a demandé à l’agent de créer une application de dessin SwiftUI pour iPad. L’agent a inspecté le répertoire, élaboré un plan, écrit le code, et utilisé xcodebuild pour compiler et corriger ses propres erreurs, produisant une application fonctionnelle en environ deux minutes, puis itérant pour ajouter des extrémités arrondies à la demande.¹ Une dernière démonstration a branché le même serveur MLX en cours d’exécution dans les réglages Intelligence de Xcode en tant que fournisseur de chat hébergé localement, de sorte que Xcode lui-même pouvait trouver et corriger un bug introduit. « L’IA locale signifie que votre code ne quitte jamais votre Mac. »¹

Répartir la charge sur plusieurs Mac (Session 233)

Tatiana construit un cluster de quatre Mac étape par étape, à partir de 2:21.

À terme, une seule machine manque de place. Comme l’a formulé Tatiana, chercheuse au sein de l’équipe MLX : « À terme, la mémoire, le calcul ou la bande passante d’une seule machine devient une limite. »² Le cas phare issu de la Session 232 est un modèle qui, tout simplement, n’entre pas : le modèle DeepSeek le plus récent « comporte la bagatelle de 1,6 mille milliards de paramètres et nécessite plus de 800 Go de mémoire rien que pour les poids ».¹ La Session 233 est l’exploration approfondie de la répartition de ce travail sur les Mac que vous possédez.

La pile sous-jacente de MLX distribué comporte trois éléments. L’interconnexion et le transport : à partir de macOS 26.2, l’accès direct à la mémoire à distance (RDMA) est pris en charge via Thunderbolt 5, déplaçant les données directement de la mémoire d’une machine vers celle d’une autre tout en « évitant l’essentiel de la surcharge du CPU et du système d’exploitation ».² Le backend de communication : JACCL, « une bibliothèque de communication collective open source développée par Apple » qui s’exécute sur RDMA via Thunderbolt et fournit des primitives collectives sans que vous ayez à gérer le transport, qui « ne se limite pas à l’apprentissage automatique » et « peut être compilée sans MLX », exposant une API C++ pour n’importe quelle charge distribuée.² MLX se place au sommet, utilisant JACCL pour une coordination à faible latence sur l’ensemble du cluster.

Tatiana a construit un cluster à partir de quatre M3 Ultra. La topologie compte, car le temps de communication se divise en latence (un coût fixe par opération) et en temps de transfert (qui croît avec la taille du message). JACCL prend en charge un maillage (mesh), où « chaque machine se connecte directement à toutes les autres » pour la latence la plus faible, et un anneau (ring), où chaque nœud se connecte à deux voisins, libérant des ports pour faire passer plusieurs câbles par voisin et gagner en bande passante. Câblé en maillage, JACCL « choisit automatiquement la meilleure topologie selon la taille du message et l’opération de communication, le maillage quand la latence compte, l’anneau quand la bande passante compte ».² Vous activez RDMA dans les Réglages, puis lancez les tâches avec mlx.launch pointant vers un fichier d’hôtes JSON ; le script d’aide mlx.distributed_config génère ce fichier d’hôtes et, avec --auto-setup, configure lui-même le réseau Thunderbolt.²

Exécuter un modèle sur l’ensemble du cluster est presque identique à l’exécuter sur une seule machine. Vous enveloppez la même commande mlx_lm.chat avec mlx.launch --hostfile, et « MLX LM partitionne le modèle et coordonne pour vous l’inférence distribuée ».² Côte à côte, un Qwen 3.6 de 27 milliards de paramètres a généré des tokens « à un rythme presque trois fois supérieur à celui d’une seule machine » sur quatre M3 Ultra.² MLX prend en charge deux stratégies de partitionnement : le parallélisme de pipeline (par profondeur, communication simple mais aucune accélération) et le parallélisme de tenseur (par largeur, toutes les machines traitent le même token en même temps pour gagner en vitesse, au prix d’une communication fréquente couche par couche, ce qui « explique pourquoi la topologie en maillage est cruciale »).² Le parallélisme de tenseur est le réglage par défaut. La session a exécuté le Kimi 2.6 à mille milliards de paramètres (environ un téraoctet de poids en 8 bits, qui « n’entre pas sur un seul M3 Ultra, mais qui peut entrer sur quatre ») sur l’ensemble du cluster.² La même approche accélère le fine-tuning : un entraînement LoRA data-parallèle via mlx_lm.lora a fait passer un seul M3 Ultra d’environ 180 tokens par seconde à environ 600 sur le cluster, « plus de 3 fois plus rapide ».² MLX expose les mêmes primitives via Python, Swift et C++ pour intégrer des workflows distribués dans les applications.

Sécuriser la boucle (Session 347)

Willy présente l’injection de prompt indirecte à 4:01 ; Akshay couvre les API des frameworks à partir de 11:55.

Donner à un modèle la capacité d’appeler des outils ouvre une porte. Comme l’a formulé Willy : « Les LLM introduisent dans votre application un nouveau moteur probabiliste qui est à la fois puissant et susceptible d’être trompé. »³ Le nouveau risque est l’injection de prompt indirecte, que la session définit comme « des instructions intégrées dans le contexte supplémentaire fourni au modèle, dans l’intention de détourner le flux de contrôle ».³ L’application d’exemple de la session, Loose Leaf, ajoute une fonctionnalité « Organiser une réception autour du thé » qui lit votre calendrier et le fil de vos amis et peut commander des thés. L’attaque : un utilisateur demande de planifier une réception avec son calendrier joint, mais un événement du calendrier contient une instruction injectée demandant au modèle de supprimer plutôt des données utilisateur sensibles.³

L’injection produit deux effets. L’empoisonnement des données, « un attaquant qui influence les paramètres d’une action exécutée », transforme un message destiné à votre mère en un message envoyé à l’attaquant. L’empoisonnement des actions, où l’attaquant « influence l’action à exécuter », détourne une requête de type résume-cet-e-mail vers l’ouverture d’une URL malveillante avec l’e-mail joint.³ La session ancre le danger dans le Lethal Trifecta de Simon Willison : un utilisateur est le plus exposé lorsqu’un système agentique combine l’accès à des données privées, l’exposition à du contenu non fiable et la capacité de communiquer vers l’extérieur, généralisée en « le risque d’actions ayant un quelconque effet de bord ».³ Le cadrage est honnête : « résoudre l’injection de prompt indirecte est un domaine de recherche actif », de sorte que l’objectif réaliste est de comprendre le risque de votre application et de l’atténuer.³

La méthode est un exercice de modélisation des menaces. D’abord, une analyse du flux de données de tout ce qui alimente le prompt, en marquant comme non fiable « toute entrée provenant d’une entité externe », ce qui, pour Loose Leaf, désigne le contenu du calendrier et le fil des amis.³ Ensuite, un inventaire des actions de l’agent et de leurs effets de bord : un outil de commande de thé comporte un risque financier, un outil de publication dans le fil comporte un risque d’exfiltration de données, et même un minuteur d’infusion d’apparence anodine est risqué, car son étiquette optionnelle « pourrait permettre à une injection de prompt d’écrire d’autres instructions en vue d’attaques ultérieures ».³ La préférence affichée d’Apple est de « privilégier les atténuations déterministes comme base de référence, car leurs garanties de sécurité sont plus faciles à auditer et à raisonner », avec des atténuations probabilistes ajoutées par-dessus.³

Akshay a ensuite montré les API. Dans Foundation Models, les modificateurs d’événements de cycle de vie sont « des callbacks qui se déclenchent de manière déterministe à certains points du cycle de vie de l’exécution d’une session », utilisables comme points de contrôle de sécurité. Le modificateur .onToolCall s’exécute avant que l’exécuteur ne lance un outil, et « si ce callback lève une erreur, alors l’outil n’est jamais exécuté », ce qui « en fait l’endroit idéal pour imposer des confirmations » : vérifiez si l’outil courant est l’outil financier et, le cas échéant, exigez d’abord une confirmation de l’utilisateur.³ Le modificateur .historyTransform « se déclenche avant que la transcription ne soit rendue au modèle pour l’inférence », ce qui vous permet d’envelopper la sortie d’outil non fiable dans des délimiteurs de spotlighting et de masquer les informations personnelles en remplaçant les segments sensibles par un marqueur [REDACTED] avant que le modèle ne les voie.³ Une réserve : ces transformations « ne s’appliquent qu’à l’itération d’inférence courante », vous les réappliquez donc à chaque appel, ou vous utilisez l’annotation @SessionProperty pour les transformations que vous souhaitez conserver.³

Pour les applications intégrées à Siri via App Intents, deux garde-fous système s’appliquent. Les confirmations sont « basées sur le risque » et « contextuelles » : lorsqu’un intent adopte un schéma, il hérite des métadonnées de risque de ce schéma (supprimer des photos est destructeur, exfiltrer des données est risqué), et un système d’évaluation des risques combine ces métadonnées statiques avec « l’état dynamique du système » pour décider s’il faut interroger l’utilisateur avant l’exécution.³ L’authentification sur écran verrouillé est le second : comme Siri est accessible sur un appareil verrouillé, vous réglez la propriété authenticationPolicy d’un intent sur .requiresAuthentication afin que les actions destructrices ne puissent pas s’exécuter en mode verrouillé ; la politique par défaut d’un schéma ne peut être remplacée « que pour la rendre plus stricte », et un remplacement plus permissif produit une erreur de compilation.³

Déboguer la boucle (Session 243)

Erik diagnostique un échec agentique silencieux dans son app Craft, à partir de 1:58.

La flexibilité de la boucle est aussi son problème de débogage. Comme l’a dit Erik, ingénieur outils IA : « Le code traditionnel est prévisible. Les LLM sont non déterministes ; la même entrée peut produire des sorties différentes. »⁴ Il a nommé trois défis absents du développement traditionnel : la sortie probabiliste (de sorte que « les tests unitaires standards s’effondrent » et que vous évaluez plutôt la qualité et l’intention), la communication de modèle à modèle, et l’observabilité, « lorsque quelque chose casse dans un pipeline multimodèle, il peut être très difficile de savoir où ça a déraillé ».⁴ L’instrument Foundation Models de Xcode 27 existe pour répondre à ce dernier point.

Erik a fait sa démonstration sur son app Craft, où une fonctionnalité de brainstorming utilise deux jeux d’instructions, brainstorming et génération de tutoriel, le jeu de brainstorming proposant un GenerateCraftIdeaTool et un SwitchToTutorialModeTool.⁴ Dans la trace, la fonctionnalité a échoué : elle continuait à proposer des idées au lieu de passer à un tutoriel. Le couloir Instructions a immédiatement raconté l’histoire, montrant qu’« un seul jeu d’instructions est resté actif pendant toute la session, alors que la fonctionnalité était censée en utiliser deux, donc quelque chose a mal tourné lors du passage de relais ».⁴ La vue arborescente, qui organise tout en « sessions, requêtes, inférences de modèle, instructions, prompts et réponses », a fait remonter la cause racine : « Le prompt référence l’outil switchToTutorialMode, mais cet outil n’est en réalité pas configuré avec cette instruction. »⁴ Le modèle continuait à effectuer des appels d’outils sans lever d’erreur : « c’était un échec silencieux », le type le plus difficile à détecter.⁴ Ajouter l’outil manquant au jeu d’outils a corrigé le problème, et la nouvelle trace a montré deux jeux d’instructions distincts actifs, le passage de relais s’effectuant correctement après un appel de l’outil switchToTutorialMode.⁴

L’instrument rend aussi la performance lisible. Le couloir Model Inference utilise des barres jaunes pour le traitement du prompt d’entrée et des barres orange pour la génération de la réponse.⁴ Trois métriques guident l’optimisation : le Time to First Token (« un Time to First Token élevé signifie que les gens fixent un écran vide ; pour le réduire, raccourcissez votre prompt »), les Tokens per Second (pour « comparer les performances entre différentes configurations de prompt et détecter les régressions après des changements »), et la Total Latency, « celle que les gens ressentent le plus directement », réduite en perception en diffusant plus tôt des résultats partiels.⁴ Une note opérationnelle : l’instrument « capture les données de prompt et de réponse de votre appareil, qui peuvent contenir des informations sensibles », la journalisation est donc désactivée en production mais activée pendant la durée de la trace, et vous conservez les fichiers de trace dans un endroit sûr.⁴

Par où commencer

Les quatre sessions se composent en une séquence que vous pouvez suivre sur le matériel que vous possédez déjà :

1. Mettez en place la boucle locale. pip install de MLX-LM, exécutez d’abord mlx_lm.server avec un petit modèle capable d’appeler des outils pour valider l’installation, et pointez l’URL de base de votre agent vers localhost. Commencez par des tâches de lire-et-rapporter avant de laisser l’agent écrire des fichiers ou lancer des builds.¹ Une fois que c’est le cas, donnez-lui un endroit isolé pour faire ce travail : les container machines offrent à un agent un environnement Linux rapide et persistant sur le Mac, isolé en machine virtuelle avec votre répertoire personnel monté à l’intérieur, de sorte que les builds et les installations s’exécutent derrière une véritable frontière plutôt que contre l’hôte.
2. Ne répartissez la charge que lorsqu’un seul Mac ne suffit pas. Si un modèle n’entre pas en mémoire ou que l’inférence est trop lente, reliez vos Mac via Thunderbolt 5, activez RDMA dans les Réglages, générez un fichier d’hôtes avec mlx.distributed_config, et exécutez les mêmes commandes sous mlx.launch. Optez pour le parallélisme de tenseur (le réglage par défaut) pour la vitesse et une topologie en maillage pour la faible latence dont il a besoin.²
3. Modélisez les menaces avant de livrer des fonctionnalités agentiques. Dressez la liste de chaque source de contexte non fiable et des effets de bord de chaque action. Ajoutez des confirmations .onToolCall sur les outils à effet de bord, ainsi que du spotlighting et du masquage via .historyTransform sur la sortie d’outil non fiable ; pour App Intents, examinez les métadonnées de risque de chaque intent et réglez authenticationPolicy afin que les actions destructrices exigent un appareil déverrouillé.³
4. Profilez avant de lui faire confiance. Profilez votre fonctionnalité Foundation Models dans l’instrument de Xcode 27, lisez les couloirs Instructions et Model Inference pour repérer les échecs silencieux, et servez-vous du Time to First Token, des Tokens per Second et de la Total Latency pour identifier les étapes lentes.⁴

Tout ce qui figure dans la Session 232 est « open source et disponible dès maintenant ».¹

FAQ

Puis-je vraiment exécuter un agent d’IA entièrement sur mon Mac ?

Oui. La Session 232 de la WWDC 2026 démontre la boucle agentique complète s’exécutant localement grâce à MLX : un modèle raisonne, appelle des outils, observe les résultats et itère, seuls les appels d’outils qui ont réellement besoin du réseau sortant de la machine. La pile se compose de MLX, MLX-LM, du serveur MLX-LM Server compatible OpenAI, et au sommet de n’importe quel agent qui parle le protocole de chat completions d’OpenAI.¹

Comment connecter mon agent à un modèle MLX local ?

Trois étapes. Installez MLX-LM avec pip, démarrez mlx_lm.server avec un modèle prenant en charge l’appel d’outils, et réglez l’URL de base de votre framework d’agent sur l’adresse de votre serveur local sur localhost. L’agent traite le serveur local exactement comme il le ferait avec une API LLM cloud, car MLX-LM Server est un serveur HTTP compatible OpenAI installable sans modification.¹

Que faire si le modèle est trop volumineux pour un seul Mac ?

MLX répartit un modèle sur plusieurs Mac connectés via Thunderbolt 5, en s’appuyant sur RDMA (pris en charge à partir de macOS 26.2) et la bibliothèque de communication open source JACCL d’Apple. Vous lancez les tâches avec mlx.launch et un fichier d’hôtes ; MLX partitionne le modèle automatiquement. La session d’Apple a exécuté un modèle à mille milliards de paramètres sur quatre M3 Ultra et a observé des accélérations d’environ un facteur trois sur l’inférence et le fine-tuning par rapport à une seule machine.²

Quel est le principal nouveau risque de sécurité pour les apps Mac agentiques ?

L’injection de prompt indirecte : des instructions malveillantes cachées dans du contexte non fiable (un événement de calendrier, un fil social, le résultat d’un outil) qui détournent le modèle vers des actions que l’utilisateur n’a jamais demandées, comme supprimer des données ou les exfiltrer. Apple recommande une passe de modélisation des menaces, accompagnée de garde-fous déterministes : confirmations .onToolCall, spotlighting et masquage des informations personnelles via .historyTransform dans Foundation Models, ainsi que des confirmations basées sur le risque et une authentification sur écran verrouillé dans App Intents.³

Comment déboguer un agent qui échoue silencieusement ?

Utilisez l’instrument Foundation Models de Xcode 27. Il capture chaque inférence de modèle, jeu d’instructions, prompt et réponse dans des couloirs chronologiques et une vue arborescente, ce qui vous permet de voir exactement quels outils étaient disponibles à chaque étape et où un passage de relais a mal tourné, même lorsque le modèle ne lève jamais d’erreur. Il fait aussi remonter le Time to First Token, les Tokens per Second et la Total Latency pour l’optimisation des performances.⁴

Exécuter votre propre modèle sur Apple silicon est le socle sur lequel repose cette boucle : voir MLX sur Apple Silicon : quand vous avez besoin de votre propre modèle, pas de celui d’Apple et exécuter des modèles sur Apple silicon avec Core AI. La distinction entre runtime et outillage qui façonne la manière dont les agents touchent une app Swift est traitée dans le workflow agentique de Foundation Models. Une fois la boucle en place, mesurer sa qualité est l’étape suivante, couverte dans le framework Evaluations d’Apple. Le hub complet de la série est la série Apple Ecosystem, et le contexte de développement plus large est le guide iOS Agent Development.

Références