Ejecutar IA agéntica en el Mac con MLX

En la WWDC 2026, un ingeniero de Apple le pidió a un agente local en su Mac que obtuviera las pull requests recientes del repositorio de MLX, resumiera los cambios y señalara lo que requería atención. El modelo razonó, llamó a la CLI de GitHub, leyó los diffs y produjo un resumen. Solo los comandos de git tocaron la red; el modelo se ejecutó por completo en su hardware.¹ Esa demostración es toda la tesis de este artículo: el bucle agéntico, esa parte en la que un modelo decide, llama a una herramienta, observa el resultado y vuelve a decidir, ahora se ejecuta en local en el Mac con MLX. Sin nube, sin claves de API, sin costo por token. Y Apple lanzó el resto de la historia junto con ello: cómo escalar ese bucle entre varios Mac, cómo asegurar las funciones agénticas frente a una nueva clase de ataque y cómo depurar el bucle cuando hace lo incorrecto en silencio.

Este artículo recorre las cuatro sesiones de la WWDC 2026 que, en conjunto, convierten a la IA agéntica local en el Mac en una verdadera superficie de ingeniería y no en una demo técnica. Todo lo que sigue proviene directamente de esas sesiones.

En resumen

• MLX ejecuta todo el bucle agéntico en local en el Mac a través de una pila de cuatro capas: MLX en la base, MLX-LM para los modelos, MLX-LM Server como servidor HTTP compatible con OpenAI y, encima, cualquier agente que hable el protocolo de chat completions de OpenAI.¹
• La configuración son tres pasos: pip install de MLX-LM, ejecutar mlx_lm.server con un modelo capaz de llamar herramientas y apuntar la base URL de tu agente a localhost.¹
• Cuando un solo Mac no basta, MLX distribuye un modelo entre varios a través de Thunderbolt 5 usando RDMA y la biblioteca de código abierto JACCL de Apple, ejecutando modelos de un billón de parámetros y acelerando la inferencia y el fine-tuning aproximadamente tres veces en un clúster de cuatro nodos.²
• Las funciones agénticas abren una nueva superficie de ataque: la inyección de prompts indirecta. La estrategia de mitigación de Apple se apoya en barreras deterministas: las confirmaciones .onToolCall y el spotlighting .historyTransform en Foundation Models, además de las confirmaciones según el riesgo y la autenticación en la pantalla de bloqueo en App Intents.³
• El instrumento Foundation Models en Xcode 27 hace que el bucle sea observable: carriles por solicitud, una vista de árbol de la cadena de pensamiento del modelo y las métricas (Time to First Token, Tokens per Second, Total Latency) que necesitas para detectar fallos silenciosos e inferencias lentas.⁴

La pila agéntica local (sesión 232)

Angelos, del equipo de MLX, explica la configuración de tres pasos a partir del minuto 2:42.

La experiencia de chat que conocen la mayoría de los desarrolladores devuelve el trabajo a la persona. Como lo plantea la sesión: «Le envías un prompt al modelo de lenguaje. El modelo te devuelve una respuesta. Si necesitas actuar sobre esa respuesta, ejecutar un comando, revisar un archivo o corregir un error, eso corre por tu cuenta».¹ Un agente cierra esa brecha. El agente habla con el modelo para decidir qué hacer, llama a herramientas para hacerlo, observa los resultados y vuelve al modelo para el siguiente paso. Del usuario al agente, del agente al modelo, del agente a las herramientas, en un ciclo hasta que la tarea se completa.

Lo que hace interesante al bucle en Apple silicon es que todo se ejecuta en local. MLX presenta esta capacidad en cuatro capas, de abajo hacia arriba: MLX, «nuestro framework de arreglos de código abierto creado específicamente para Apple silicon», que gestiona el cómputo, la aceleración con Metal y la memoria; MLX-LM para cargar, ejecutar, cuantizar y hacer fine-tuning de modelos desde Hugging Face; MLX-LM Server, «un servidor HTTP compatible con OpenAI que expone tu modelo local a través de una API estándar», con llamadas a herramientas estructuradas y soporte para modelos de razonamiento; y, en la cima, cualquier agente que hable el protocolo de chat completions de OpenAI, ya sea Xcode, OpenCode, un agente Pi o un script propio.¹ La interfaz estándar es la decisión que sostiene todo: «cualquier framework de agente funciona de inmediato», y herramientas como Ollama, LM Studio y vLLM ya se construyen sobre MLX y MLX-LM.¹

La configuración son tres pasos. Instala MLX-LM con un solo pip install. Inicia el servidor con un modelo capaz de llamar herramientas:

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

Luego apunta tu agente al servidor local fijando su base URL a localhost. Como señala la sesión, «al agente no le importa, ni sabe, que el modelo se está ejecutando en tu Mac en lugar de en la nube».¹ En OpenCode, esto significa definir un proveedor local cuya URL sea localhost y cuyo nombre de modelo coincida con lo que el servidor espera, y luego indicarle a OpenCode que use ese modelo local para todo.

La parte interesante es cómo MLX se gana su lugar específicamente en las cargas de trabajo agénticas. La sesión nombra tres desafíos. El primero es el procesamiento del prompt: «Las sesiones agénticas suelen abarcar cientos de miles de tokens y la mayoría de ellos no se generan».¹ Cada vez que el modelo recibe la salida de una herramienta, procesa todo ese nuevo contexto antes de seguir razonando, y ese costo se repite a lo largo de todo el bucle. Los Neural Accelerators dedicados del chip M5 hacen que la multiplicación de matrices sea cuatro veces más rápida que en el M4 y, con los kernels especializados de MLX, «esto se traduce casi exactamente en una aceleración del procesamiento del prompt», sin necesidad de argumentos especiales ni cambios de código.¹ El segundo desafío es la concurrencia: los agentes generan subagentes, y MLX-LM Server maneja las solicitudes simultáneas con batching continuo, agrupándolas de forma dinámica para que los subagentes «no se queden atascados esperando en una cola».¹ El tercer desafío es el tamaño del modelo, y ahí es donde toma el relevo la siguiente sesión.

Angelos cerró con una demostración que va más allá de leer e informar: a partir de un proyecto de Xcode en blanco, le pidió al agente que creara una app de dibujo en SwiftUI para iPad. El agente inspeccionó el directorio, trazó un plan, escribió el código y usó xcodebuild para compilar y corregir sus propios errores, produciendo una app funcional en unos dos minutos, y luego iteró para añadir extremos redondeados cuando se le pidió.¹ Una última demostración conectó el mismo servidor MLX en ejecución a los ajustes de Intelligence de Xcode como proveedor de chat alojado localmente, de modo que el propio Xcode pudo encontrar y corregir un bug introducido. «La IA local significa que tu código nunca sale de tu Mac».¹

Escalar entre varios Mac (sesión 233)

Tatiana construye un clúster de cuatro Mac paso a paso, a partir del minuto 2:21.

Tarde o temprano, una sola máquina se queda sin espacio. Como lo planteó Tatiana, científica de investigación del equipo de MLX: «Con el tiempo, la memoria, el cómputo o el ancho de banda de una sola máquina se convierten en una limitación».² El caso emblemático de la sesión 232 es un modelo que sencillamente no cabe: el modelo más reciente de DeepSeek «tiene la friolera de 1,6 billones de parámetros y requiere más de 800 GB de memoria solo para los pesos».¹ La sesión 233 es la inmersión profunda en cómo repartir ese trabajo entre los Mac que ya tienes.

La pila subyacente a MLX distribuido tiene tres piezas. La interconexión y el transporte: a partir de macOS 26.2, el acceso directo a memoria remota (RDMA) se admite sobre Thunderbolt 5, moviendo los datos directamente de la memoria de una máquina a la de otra mientras «evita la mayor parte de la sobrecarga de la CPU y del sistema operativo».² El backend de comunicación: JACCL, «una biblioteca de comunicación colectiva de código abierto creada por Apple», que se ejecuta sobre RDMA a través de Thunderbolt y proporciona primitivas colectivas sin que tengas que gestionar el transporte, y que «no se limita al aprendizaje automático» y «puede construirse sin MLX», exponiendo una API de C++ para cualquier carga de trabajo distribuida.² MLX se sitúa encima y usa JACCL para una coordinación de baja latencia en todo el clúster.

Tatiana construyó un clúster con cuatro M3 Ultra. La topología importa porque el tiempo de comunicación se divide en latencia (un costo fijo por operación) y tiempo de transferencia (que crece con el tamaño del mensaje). JACCL admite una malla, donde «cada máquina se conecta directamente con todas las demás» para la menor latencia, y un anillo, donde cada nodo se conecta con dos vecinos, liberando puertos para tender varios cables por vecino y obtener más ancho de banda. Cableado como malla, JACCL «elige automáticamente la mejor topología según el tamaño del mensaje y la operación de comunicación: malla cuando importa la latencia, anillo cuando importa el ancho de banda».² Habilitas RDMA en Ajustes y luego lanzas los trabajos con mlx.launch apuntando a un archivo de hosts en JSON; el script auxiliar mlx.distributed_config genera ese archivo de hosts y, con --auto-setup, configura la propia red Thunderbolt.²

Ejecutar un modelo en el clúster es casi idéntico a ejecutarlo en una sola máquina. Envuelves el mismo comando mlx_lm.chat con mlx.launch --hostfile, y «MLX LM fragmenta el modelo y coordina la inferencia distribuida por ti».² En comparación directa, un Qwen 3.6 de 27 000 millones de parámetros generó tokens «a casi tres veces la velocidad de una sola máquina» en cuatro M3 Ultra.² MLX admite dos estrategias de fragmentación: paralelismo de pipeline (por profundidad, comunicación sencilla pero sin aceleración) y paralelismo de tensores (por anchura, todas las máquinas procesan el mismo token a la vez para acelerar, a costa de una comunicación frecuente por capa que «es la razón por la que la topología de malla es crucial»).² El paralelismo de tensores es el predeterminado. La sesión ejecutó el Kimi 2.6 de un billón de parámetros (cerca de un terabyte de pesos en 8 bits, que «no cabe en un solo M3 Ultra, pero sí puede caber repartido entre cuatro») en todo el clúster.² El mismo enfoque acelera el fine-tuning: un entrenamiento LoRA en paralelismo de datos mediante mlx_lm.lora llevó a un solo M3 Ultra de unos 180 tokens por segundo a unos 600 en el clúster, «más de 3 veces de aceleración».² MLX expone las mismas primitivas a través de Python, Swift y C++ para integrar flujos de trabajo distribuidos en las apps.

Asegurar el bucle (sesión 347)

Willy presenta la inyección de prompts indirecta en el minuto 4:01; Akshay cubre las API del framework a partir del minuto 11:55.

Darle a un modelo la capacidad de llamar herramientas abre una puerta. Como lo planteó Willy: «Los LLM introducen un nuevo motor probabilístico dentro de tu aplicación que es a la vez poderoso, pero corre el riesgo de ser engañado».³ El nuevo riesgo es la inyección de prompts indirecta, que la sesión define como «instrucciones incrustadas en contexto adicional proporcionado al modelo con la intención de redirigir el flujo de control».³ La app de ejemplo de la sesión, Loose Leaf, añade una función «Organizar una fiesta del té» que lee tu calendario y el feed de tus amigos y puede pedir tés. El ataque: un usuario pide planear una fiesta adjuntando su calendario, pero un evento del calendario contiene una instrucción inyectada que le ordena al modelo eliminar datos sensibles del usuario en su lugar.³

La inyección produce dos efectos. El envenenamiento de datos, «un atacante que influye en los parámetros de una acción ejecutada», convierte un mensaje destinado a tu mamá en uno enviado al atacante. El envenenamiento de acciones, donde el atacante «influye en qué acción ejecutar», desvía una solicitud de resumir este correo hacia abrir una URL maliciosa con el correo adjunto.³ La sesión ancla el peligro en la Lethal Trifecta de Simon Willison: un usuario corre el mayor riesgo cuando un sistema agéntico combina el acceso a datos privados, la exposición a contenido no confiable y la capacidad de comunicarse hacia afuera, generalizada como «el riesgo de acciones con cualquier efecto secundario».³ El planteamiento es honesto: «resolver la inyección de prompts indirecta es un área de investigación activa», así que la meta realista es entender el riesgo de tu app y mitigarlo.³

El método es un ejercicio de modelado de amenazas. Primero, un análisis del flujo de datos de todo lo que alimenta el prompt, marcando como no confiable «cualquier entrada que provenga de una entidad externa», lo que para Loose Leaf significa el contenido del calendario y el feed de los amigos.³ Segundo, un inventario de las acciones del agente y sus efectos secundarios: una herramienta para pedir té conlleva riesgo financiero, una herramienta para publicar en el feed conlleva riesgo de exfiltración de datos, e incluso un temporizador de infusión de aspecto inofensivo es riesgoso, porque su etiqueta opcional «podría permitir que una inyección de prompts escriba más instrucciones para ataques posteriores».³ La preferencia que Apple declara es «centrarse en las mitigaciones deterministas como base, porque sus garantías de seguridad son más fáciles de auditar y de razonar», con mitigaciones probabilísticas superpuestas.³

Luego Akshay mostró las API. En Foundation Models, los modificadores de eventos del ciclo de vida son «callbacks que se disparan de forma determinista en ciertos puntos del ciclo de vida de la ejecución de una sesión», utilizables como puntos de control de seguridad. El modificador .onToolCall se ejecuta antes de que el ejecutor lance una herramienta, y «si este callback lanza un error, la herramienta nunca se ejecuta», lo que «lo convierte en el lugar perfecto para imponer confirmaciones»: comprobar si la herramienta actual es la financiera y, de ser así, exigir primero la confirmación del usuario.³ El modificador .historyTransform «se dispara antes de que la transcripción se renderice al modelo para la inferencia», lo que te permite envolver la salida no confiable de las herramientas en delimitadores de spotlighting y redactar la información personal reemplazando los segmentos sensibles por un marcador de posición [REDACTED] antes de que el modelo los vea.³ Una salvedad: esas transformaciones «se limitan únicamente a la iteración de inferencia actual», así que las reaplicas en cada llamada o usas la anotación @SessionProperty para las transformaciones que quieras que persistan.³

Para las apps que se integran con Siri mediante App Intents, se aplican dos barreras del sistema. Las confirmaciones son «según el riesgo» y «contextuales»: cuando un intent adopta un esquema, hereda los metadatos de riesgo de ese esquema (eliminar fotos es destructivo, exfiltrar datos es riesgoso), y un sistema de evaluación de riesgo combina esos metadatos estáticos con «el estado dinámico del sistema» para decidir si le pregunta al usuario antes de ejecutar.³ La autenticación en la pantalla de bloqueo es la segunda: como Siri es accesible en un dispositivo bloqueado, fijas la authenticationPolicy de un intent en .requiresAuthentication para que las acciones destructivas no puedan ejecutarse mientras está bloqueado; la política predeterminada de un esquema solo puede anularse «para hacerla más estricta», y una anulación más débil produce un error de compilación.³

Depurar el bucle (sesión 243)

Erik diagnostica un fallo agéntico silencioso en su app Craft, a partir del minuto 1:58.

La flexibilidad del bucle es también su problema de depuración. Como dijo Erik, ingeniero de herramientas de IA: «El código tradicional es predecible. Los LLM son no deterministas; la misma entrada puede producir salidas diferentes».⁴ Nombró tres desafíos ausentes en el desarrollo tradicional: la salida probabilística (de modo que «las pruebas unitarias estándar se vienen abajo» y, en su lugar, evalúas la calidad y la intención), la comunicación de modelo a modelo y la observabilidad, «cuando algo se rompe en una canalización de varios modelos, puede ser muy difícil saber dónde salió mal».⁴ El instrumento Foundation Models en Xcode 27 existe para responder a ese último punto.

Erik hizo la demostración en su app Craft, donde una función de lluvia de ideas usa dos conjuntos de instrucciones, lluvia de ideas y generación de tutoriales, y el conjunto de lluvia de ideas ofrece un GenerateCraftIdeaTool y un SwitchToTutorialModeTool.⁴ En la traza, la función falló: seguía ofreciendo ideas en lugar de cambiar a un tutorial. El carril Instructions contó la historia de inmediato, mostrando que «solo un conjunto de instrucciones estuvo activo durante toda la sesión, pero se suponía que la función debía usar dos, así que algo salió mal durante el traspaso».⁴ La vista de árbol, que organiza todo en «sesiones, solicitudes, inferencias de modelo, instrucciones, prompts y respuestas», sacó a la luz la causa raíz: «El prompt hace referencia a la herramienta switchToTutorialMode, pero esa herramienta en realidad no está configurada con esta instrucción».⁴ El modelo seguía haciendo llamadas a herramientas sin lanzar un error: «este era un fallo silencioso», el tipo más difícil de detectar.⁴ Añadir la herramienta que faltaba al conjunto de herramientas lo solucionó, y la nueva traza mostró dos conjuntos de instrucciones distintos activos, con el traspaso ocurriendo correctamente tras una llamada a la herramienta switchToTutorialMode.⁴

El instrumento también hace legible el rendimiento. El carril Model Inference usa barras amarillas para el procesamiento del prompt de entrada y barras naranjas para la generación de la respuesta.⁴ Tres métricas guían la optimización: Time to First Token («un Time to First Token alto significa que la gente se queda mirando una pantalla en blanco; para reducirlo, acorta tu prompt»), Tokens per Second (para «comparar el rendimiento entre distintas configuraciones de prompt y detectar regresiones después de los cambios») y Total Latency, «el número que la gente siente de forma más directa», reducido en la percepción al transmitir los resultados parciales antes.⁴ Una nota operativa: el instrumento «captura datos de prompt y de respuesta de tu dispositivo, que pueden incluir información sensible», por lo que el registro está desactivado en producción pero activado durante la traza, y conservas los archivos de traza en un lugar seguro.⁴

Cómo empezar

Las cuatro sesiones se componen en una secuencia que puedes seguir con el hardware que ya tienes:

1. Levanta el bucle local. Haz un pip install de MLX-LM, ejecuta mlx_lm.server primero con un modelo pequeño capaz de llamar herramientas para validar la configuración y apunta la base URL de tu agente a localhost. Empieza con tareas de leer e informar antes de dejar que el agente escriba archivos o ejecute builds.¹ Una vez que lo haga, dale un lugar aislado para realizar ese trabajo: las container machines le dan a un agente un entorno Linux rápido y persistente en el Mac, aislado en una VM con tu directorio home montado dentro, de modo que las builds y las instalaciones se ejecutan tras un límite real en lugar de contra el host.
2. Escala solo cuando un Mac no baste. Si un modelo no cabe en memoria o la inferencia es demasiado lenta, conecta varios Mac por Thunderbolt 5, habilita RDMA en Ajustes, genera un archivo de hosts con mlx.distributed_config y ejecuta los mismos comandos bajo mlx.launch. Recurre al paralelismo de tensores (el predeterminado) para la velocidad y a una topología de malla por la baja latencia que necesita.²
3. Modela amenazas antes de lanzar funciones agénticas. Enumera cada fuente de contexto no confiable y los efectos secundarios de cada acción. Añade confirmaciones .onToolCall en las herramientas con efectos secundarios y spotlighting y redacción .historyTransform en la salida de herramientas no confiables; para App Intents, revisa los metadatos de riesgo de cada intent y configura authenticationPolicy para que las acciones destructivas requieran un dispositivo desbloqueado.³
4. Perfila antes de confiar en él. Perfila tu función de Foundation Models en el instrumento de Xcode 27, lee los carriles Instructions y Model Inference para detectar fallos silenciosos y usa Time to First Token, Tokens per Second y Total Latency para encontrar los pasos lentos.⁴

Todo lo de la sesión 232 es «de código abierto y está disponible ahora mismo».¹

Preguntas frecuentes

¿De verdad puedo ejecutar un agente de IA por completo en mi Mac?

Sí. La sesión 232 de la WWDC 2026 demuestra el bucle agéntico completo ejecutándose en local a través de MLX: un modelo razona, llama a herramientas, observa los resultados e itera, y solo las llamadas a herramientas que realmente necesitan la red salen de la máquina. La pila es MLX, MLX-LM, el MLX-LM Server compatible con OpenAI y, encima, cualquier agente que hable el protocolo de chat completions de OpenAI.¹

¿Cómo conecto mi agente a un modelo MLX local?

Tres pasos. Instala MLX-LM con pip, inicia mlx_lm.server con un modelo que admita llamadas a herramientas y fija la base URL de tu framework de agente a la dirección de tu servidor local en localhost. El agente trata al servidor local exactamente como trataría a una API de LLM en la nube, porque MLX-LM Server es un servidor HTTP compatible con OpenAI listo para usar.¹

¿Qué pasa si el modelo es demasiado grande para un solo Mac?

MLX distribuye un modelo entre varios Mac conectados por Thunderbolt 5, usando RDMA (admitido a partir de macOS 26.2) y la biblioteca de comunicación de código abierto JACCL de Apple. Lanzas los trabajos con mlx.launch y un archivo de hosts; MLX fragmenta el modelo automáticamente. La sesión de Apple ejecutó un modelo de un billón de parámetros en cuatro M3 Ultra y observó aceleraciones de aproximadamente tres veces en la inferencia y el fine-tuning frente a una sola máquina.²

¿Cuál es el principal nuevo riesgo de seguridad para las apps de Mac agénticas?

La inyección de prompts indirecta: instrucciones maliciosas ocultas en contexto no confiable (un evento del calendario, un feed social, el resultado de una herramienta) que desvían al modelo hacia acciones que el usuario nunca pidió, como eliminar datos o exfiltrarlos. Apple recomienda una pasada de modelado de amenazas más barreras deterministas: las confirmaciones .onToolCall y el spotlighting y la redacción de información personal con .historyTransform en Foundation Models, y las confirmaciones según el riesgo y la autenticación en la pantalla de bloqueo en App Intents.³

¿Cómo depuro un agente que falla en silencio?

Usa el instrumento Foundation Models en Xcode 27. Captura cada inferencia de modelo, conjunto de instrucciones, prompt y respuesta en carriles de línea de tiempo y una vista de árbol, de modo que puedes ver exactamente qué herramientas estaban disponibles en cada paso y dónde salió mal un traspaso, incluso cuando el modelo nunca lanza un error. También muestra Time to First Token, Tokens per Second y Total Latency para el ajuste del rendimiento.⁴

Ejecutar tu propio modelo en Apple silicon es el cimiento sobre el que se sostiene este bucle: consulta MLX en Apple Silicon: cuando necesitas tu propio modelo, no el de Apple y ejecutar modelos en Apple silicon con Core AI. La distinción entre runtime y tooling que determina cómo los agentes tocan una app de Swift está en el flujo de trabajo agéntico de Foundation Models. Una vez que el bucle funciona, medir su calidad es el siguiente paso, tratado en el framework Evaluations de Apple. El centro de toda la serie es la Apple Ecosystem Series, y el contexto de construcción más amplio está en la iOS Agent Development guide.

Referencias