Executando IA agêntica no Mac com MLX

Na WWDC 2026, um engenheiro da Apple pediu a um agente local no seu Mac que buscasse os pull requests recentes do repositório do MLX, resumisse as mudanças e sinalizasse o que precisava de atenção. O modelo raciocinou, chamou a GitHub CLI, leu os diffs e produziu um resumo. Apenas os comandos git tocaram a rede; o modelo rodou inteiramente no hardware dele.¹ Essa demonstração é toda a tese deste post: o loop agêntico, a parte em que um modelo decide, chama uma ferramenta, observa o resultado e decide de novo, agora roda localmente no Mac com MLX. Sem nuvem, sem chaves de API, sem custo por token. E a Apple lançou o resto da história junto com isso: como distribuir esse loop entre vários Macs, como proteger recursos agênticos contra uma nova classe de ataque e como depurar o loop quando ele silenciosamente faz a coisa errada.

Este post percorre as quatro sessões da WWDC 2026 que, juntas, tornam a IA agêntica local no Mac uma superfície de engenharia real, e não uma demonstração técnica. Tudo o que vem a seguir vem diretamente dessas sessões.

TL;DR

• O MLX executa todo o loop agêntico localmente no Mac por meio de uma pilha de quatro camadas: o MLX na base, o MLX-LM para os modelos, o MLX-LM Server como um servidor HTTP compatível com OpenAI e, no topo, qualquer agente que fale o protocolo de chat completions da OpenAI.¹
• A configuração tem três passos: pip install do MLX-LM, executar o mlx_lm.server com um modelo que faz tool-calling e apontar a base URL do seu agente para o localhost.¹
• Quando um único Mac não basta, o MLX distribui um modelo entre vários por Thunderbolt 5 usando RDMA e a biblioteca open-source JACCL da Apple, executando modelos de um trilhão de parâmetros e acelerando a inferência e o fine-tuning em cerca de três vezes em um cluster de quatro nós.²
• Recursos agênticos abrem uma nova superfície de ataque: a injeção indireta de prompt. A estratégia de mitigação da Apple se apoia em barreiras determinísticas: confirmações com .onToolCall e spotlighting com .historyTransform no Foundation Models, além de confirmações baseadas em risco e autenticação na tela de bloqueio no App Intents.³
• O Foundation Models Instrument no Xcode 27 torna o loop observável: faixas por requisição, uma visualização em árvore da cadeia de raciocínio do modelo e as métricas (Time to First Token, Tokens per Second, Total Latency) que você precisa para detectar falhas silenciosas e inferências lentas.⁴

A pilha agêntica local (Sessão 232)

Angelos, da equipe do MLX, percorre a configuração de três passos, a partir de 2:42.

A experiência de chat que a maioria dos desenvolvedores conhece devolve o trabalho para o humano. Como a sessão coloca: “Você envia um prompt para o modelo de linguagem. O modelo devolve uma resposta. Se você precisa agir sobre essa resposta, executar um comando, verificar um arquivo ou corrigir um erro, isso é com você.”¹ Um agente fecha essa lacuna. O agente conversa com o modelo para decidir o que fazer, chama ferramentas para fazê-lo, observa os resultados e volta ao modelo para o próximo passo. Usuário para agente, agente para modelo, agente para ferramentas, em ciclos até a tarefa ser concluída.

O que torna o loop interessante no Apple silicon é que tudo isso roda localmente. O MLX apresenta a capacidade como quatro camadas, de baixo para cima: o MLX, “nosso framework open-source de arrays criado sob medida para o Apple silicon”, que cuida da computação, da aceleração via Metal e da memória; o MLX-LM para carregar, executar, quantizar e fazer fine-tuning de modelos do Hugging Face; o MLX-LM Server, “um servidor HTTP compatível com OpenAI que expõe seu modelo local por meio de uma API padrão” com tool-calling estruturado e suporte a modelos de raciocínio; e, no topo, qualquer agente que fale o protocolo de chat completions da OpenAI, seja o Xcode, o OpenCode, um agente Pi ou um script personalizado.¹ A interface padrão é a escolha que sustenta tudo: “qualquer framework de agente funciona de imediato”, e ferramentas como Ollama, LM Studio e vLLM já são construídas sobre o MLX e o MLX-LM.¹

A configuração tem três passos. Instale o MLX-LM com um único pip install. Inicie o servidor com um modelo que faz tool-calling:

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

Depois aponte seu agente para o servidor local definindo a base URL dele para o localhost. Como a sessão observa, “o agente não sabe nem se importa que o modelo está rodando no seu Mac em vez de na nuvem.”¹ No OpenCode, isso significa definir um provedor local cuja URL é o localhost e cujo nome de modelo corresponde ao que o servidor espera, e então dizer ao OpenCode para usar esse modelo local em tudo.

A parte interessante é como o MLX justifica seu valor especificamente em cargas de trabalho agênticas. A sessão cita três desafios. O primeiro é o processamento de prompt: “Sessões agênticas geralmente compreendem centenas de milhares de tokens e a maioria deles não é gerada.”¹ Toda vez que o modelo recebe a saída de uma ferramenta, ele processa todo esse novo contexto antes de raciocinar mais, e esse custo se repete ao longo de todo o loop. Os Neural Accelerators dedicados do chip M5 tornam a multiplicação de matrizes quatro vezes mais rápida do que no M4, e, com os kernels especializados do MLX, “isso se traduz quase exatamente em aceleração do processamento de prompt”, sem nenhum argumento especial ou mudança de código necessária.¹ O segundo desafio é a concorrência: agentes geram subagentes, e o MLX-LM Server lida com as requisições simultâneas por meio de continuous batching, agrupando-as dinamicamente para que os subagentes “não fiquem travados esperando em uma fila.”¹ O terceiro desafio é o tamanho do modelo, que é onde a próxima sessão retoma.

Angelos encerrou com uma demonstração que vai além do ler-e-relatar: a partir de um projeto Xcode em branco, ele pediu ao agente que construísse um app de desenho em SwiftUI para iPad. O agente inspecionou o diretório, montou um plano, escreveu o código e usou o xcodebuild para compilar e corrigir seus próprios erros, produzindo um app funcional em cerca de dois minutos, e depois iterando para adicionar pontas arredondadas a pedido.¹ Uma demonstração final conectou o mesmo servidor MLX em execução às configurações de Intelligence do Xcode como um provedor de chat hospedado localmente, de modo que o próprio Xcode pudesse encontrar e corrigir um bug introduzido. “IA local significa que seu código nunca sai do seu Mac.”¹

Distribuindo entre Macs (Sessão 233)

Tatiana monta um cluster de quatro Macs passo a passo, a partir de 2:21.

Em algum momento, uma única máquina fica sem espaço. Como Tatiana, pesquisadora científica da equipe do MLX, colocou: “Em algum momento, a memória, a computação ou a largura de banda em uma única máquina se torna uma limitação.”² O caso de destaque da Sessão 232 é um modelo que simplesmente não cabe: o modelo mais recente da DeepSeek “tem nada menos que 1,6 trilhão de parâmetros e exige mais de 800 GB de memória só para os pesos.”¹ A Sessão 233 é o aprofundamento sobre distribuir esse trabalho entre os Macs que você possui.

A pilha por baixo do MLX distribuído tem três peças. A interconexão e o transporte: a partir do macOS 26.2, o Remote Direct Memory Access (RDMA) é suportado por Thunderbolt 5, movendo dados diretamente da memória de uma máquina para a de outra enquanto “evita a maior parte da sobrecarga da CPU e do sistema operacional.”² O backend de comunicação: o JACCL, “uma biblioteca de comunicação coletiva open-source construída pela Apple” que roda sobre RDMA por Thunderbolt e fornece primitivas coletivas sem que você precise gerenciar o transporte, e que “não se limita a machine learning” e “pode ser construído sem o MLX”, expondo uma API em C++ para qualquer carga de trabalho distribuída.² O MLX fica no topo, usando o JACCL para coordenação de baixa latência em todo o cluster.

Tatiana montou um cluster com quatro M3 Ultras. A topologia importa porque o tempo de comunicação se divide em latência (um custo fixo por operação) e tempo de transferência (que cresce com o tamanho da mensagem). O JACCL suporta uma malha (mesh), em que “cada máquina se conecta diretamente a todas as outras” para a menor latência, e um anel (ring), em que cada nó se conecta a dois vizinhos, liberando portas para usar vários cabos por vizinho e obter mais largura de banda. Conectado como uma malha, o JACCL “escolhe automaticamente a melhor topologia dependendo do tamanho da mensagem e da operação de comunicação, malha quando a latência importa, anel quando a largura de banda importa.”² Você habilita o RDMA nas configurações e, em seguida, dispara os jobs com o mlx.launch apontando para um arquivo de hosts em JSON; o script auxiliar mlx.distributed_config gera esse arquivo de hosts e, com --auto-setup, configura a própria rede Thunderbolt.²

Executar um modelo no cluster é quase idêntico a executá-lo em uma única máquina. Você envolve o mesmo comando mlx_lm.chat com mlx.launch --hostfile, e “o MLX LM particiona o modelo e coordena a inferência distribuída para você.”² Lado a lado, um Qwen 3.6 de 27 bilhões de parâmetros gerou tokens “a quase três vezes a taxa de uma única máquina” em quatro M3 Ultras.² O MLX suporta duas estratégias de particionamento: paralelismo de pipeline (por profundidade, comunicação simples mas sem ganho de velocidade) e paralelismo de tensores (por largura, todas as máquinas processam o mesmo token de uma vez para um ganho de velocidade, ao custo de uma comunicação frequente por camada que “é por isso que a topologia de malha é crucial”).² O paralelismo de tensores é o padrão. A sessão executou o Kimi 2.6 de um trilhão de parâmetros (cerca de um terabyte de pesos em 8 bits, que “não cabe em um único M3 Ultra, mas pode caber distribuído entre quatro”) no cluster.² A mesma abordagem acelera o fine-tuning: o treinamento LoRA com paralelismo de dados via mlx_lm.lora levou um único M3 Ultra de cerca de 180 tokens por segundo para cerca de 600 no cluster, “mais de 3 vezes mais rápido.”² O MLX expõe as mesmas primitivas por meio de Python, Swift e C++ para embutir fluxos de trabalho distribuídos em apps.

Protegendo o loop (Sessão 347)

Willy apresenta a injeção indireta de prompt em 4:01; Akshay cobre as APIs do framework a partir de 11:55.

Dar a um modelo a capacidade de chamar ferramentas abre uma porta. Como Willy colocou: “Os LLMs introduzem um novo mecanismo probabilístico dentro da sua aplicação que é ao mesmo tempo poderoso, mas corre o risco de ser enganado.”³ O novo risco é a injeção indireta de prompt, que a sessão define como “instruções embutidas em contexto extra fornecido ao modelo com a intenção de redirecionar o fluxo de controle.”³ O app de exemplo da sessão, o Loose Leaf, adiciona um recurso “Organizar uma festa do chá” que lê seu calendário e o feed de amigos e pode pedir chás. O ataque: um usuário pede para planejar uma festa com seu calendário anexado, mas um evento do calendário contém uma instrução injetada dizendo ao modelo para, em vez disso, deletar dados sensíveis do usuário.³

A injeção produz dois efeitos. O envenenamento de dados, “um atacante influenciando os parâmetros de uma ação executada”, transforma uma mensagem destinada à sua mãe em uma enviada ao atacante. O envenenamento de ação, em que o atacante “influencia qual ação executar”, desvia uma requisição de “resumir este e-mail” para abrir uma URL maliciosa com o e-mail anexado.³ A sessão fundamenta o perigo na Lethal Trifecta de Simon Willison: um usuário corre o maior risco quando um sistema agêntico combina acesso a dados privados, exposição a conteúdo não confiável e a capacidade de comunicar externamente, generalizada para “o risco de ações com qualquer efeito colateral.”³ O enquadramento é honesto: “resolver a injeção indireta de prompt é uma área de pesquisa ativa”, então o objetivo realista é entender o risco do seu app e mitigá-lo.³

O método é um exercício de modelagem de ameaças. Primeiro, uma análise de fluxo de dados de tudo o que alimenta o prompt, marcando como não confiável “qualquer entrada vinda de uma entidade externa”, o que, para o Loose Leaf, significa o conteúdo do calendário e o feed de amigos.³ Segundo, um inventário das ações e dos efeitos colaterais do agente: uma ferramenta de pedido de chá carrega risco financeiro, uma ferramenta de publicação no feed carrega risco de exfiltração de dados, e até um temporizador de preparo de aparência inofensiva é arriscado porque seu rótulo opcional “poderia permitir que uma injeção de prompt escrevesse mais instruções para ataques posteriores.”³ A preferência declarada da Apple é “focar em mitigações determinísticas como base, porque suas garantias de segurança são mais fáceis de auditar e raciocinar a respeito”, com mitigações probabilísticas sobrepostas por cima.³

Em seguida, Akshay mostrou as APIs. No Foundation Models, os modificadores de eventos de ciclo de vida são “callbacks que disparam deterministicamente em certos pontos do ciclo de vida da execução de uma sessão”, utilizáveis como pontos de verificação de segurança. O modificador .onToolCall roda antes de o executor rodar uma ferramenta, e “se esse callback lançar um erro, a ferramenta nunca é executada”, o que “torna este o lugar perfeito para impor confirmações”: verifique se a ferramenta atual é a financeira e, em caso afirmativo, exija a confirmação do usuário primeiro.³ O modificador .historyTransform “dispara antes de o transcript ser renderizado para o modelo para inferência”, permitindo que você envolva a saída de ferramenta não confiável em delimitadores de spotlighting e oculte PII substituindo segmentos sensíveis por um marcador [REDACTED] antes de o modelo vê-los.³ Uma ressalva: essas transformações “têm escopo apenas na iteração de inferência atual”, então você as reaplica a cada chamada, ou usa a anotação @SessionProperty para transformações que você quer que persistam.³

Para apps que se integram com a Siri por meio do App Intents, duas barreiras do sistema se aplicam. As confirmações são “baseadas em risco” e “contextuais”: quando um intent adota um schema, ele herda os metadados de risco desse schema (deletar fotos é destrutivo, exfiltrar dados é arriscado), e um sistema de Avaliação de Risco combina esses metadados estáticos com “o estado dinâmico do sistema” para decidir se deve perguntar ao usuário antes de executar.³ A autenticação na tela de bloqueio é a segunda: como a Siri é acessível em um dispositivo bloqueado, você define o authenticationPolicy de um intent como .requiresAuthentication para que ações destrutivas não possam rodar enquanto bloqueado; a política padrão de um schema pode ser sobrescrita “apenas para torná-la mais rígida”, e uma sobrescrita mais fraca gera um erro de build.³

Depurando o loop (Sessão 243)

Erik diagnostica uma falha agêntica silenciosa em seu app Craft, a partir de 1:58.

A flexibilidade do loop é também seu problema de depuração. Como Erik, um engenheiro de ferramentas de IA, colocou: “Código tradicional é previsível. LLMs são não determinísticos; a mesma entrada pode produzir saídas diferentes.”⁴ Ele citou três desafios ausentes no desenvolvimento tradicional: saída probabilística (de modo que “testes unitários padrão deixam de funcionar” e você avalia qualidade e intenção em vez disso), comunicação de modelo para modelo e observabilidade, “quando algo quebra em um pipeline com múltiplos modelos, pode ser muito difícil saber onde deu errado.”⁴ O Foundation Models Instrument no Xcode 27 existe para responder a esse último.

Erik demonstrou em seu app Craft, em que um recurso de brainstorming usa dois conjuntos de instruções, brainstorming e geração de tutorial, com o conjunto de brainstorming oferecendo uma GenerateCraftIdeaTool e uma SwitchToTutorialModeTool.⁴ No trace, o recurso falhou: ele ficava oferecendo ideias em vez de mudar para um tutorial. A faixa de Instructions contou a história imediatamente, mostrando que “apenas um conjunto de instruções estava ativo durante toda a sessão, mas o recurso deveria usar dois, então algo deu errado durante a transição.”⁴ A visualização em árvore, que organiza tudo em “sessões, requisições, inferências de modelo, instruções, prompts e respostas”, revelou a causa raiz: “O prompt referencia a ferramenta switchToTutorialMode, mas essa ferramenta não está de fato configurada com esta instrução.”⁴ O modelo ficou fazendo chamadas de ferramenta sem lançar um erro: “isto foi uma falha silenciosa”, o tipo mais difícil de pegar.⁴ Adicionar a ferramenta que faltava ao toolset corrigiu o problema, e o novo trace mostrou dois conjuntos de instruções distintos ativos, com a transição acontecendo corretamente após uma chamada da ferramenta switchToTutorialMode.⁴

O Instrument também torna o desempenho legível. A faixa de Model Inference usa barras amarelas para o processamento do prompt de entrada e barras laranja para a geração da resposta.⁴ Três métricas conduzem a otimização: Time to First Token (“um Time to First Token alto significa que as pessoas ficam encarando uma tela em branco; para reduzi-lo, encurte seu prompt”), Tokens per Second (para “comparar o desempenho entre diferentes configurações de prompt e detectar regressões após mudanças”) e Total Latency, “o número que as pessoas sentem mais diretamente”, reduzido na percepção ao transmitir resultados parciais mais cedo.⁴ Uma nota operacional: o Instrument “captura dados de prompt e resposta do seu dispositivo, que podem incluir informações sensíveis”, então o registro fica desligado em produção mas ligado durante o trace, e você mantém os arquivos de trace em um lugar seguro.⁴

Como começar

As quatro sessões se compõem em uma sequência que você pode seguir no hardware que já possui:

1. Levante o loop local. pip install do MLX-LM, execute o mlx_lm.server com um modelo pequeno de tool-calling primeiro para validar a configuração e aponte a base URL do seu agente para o localhost. Comece com tarefas de ler-e-relatar antes de deixar o agente escrever arquivos ou rodar builds.¹ Quando o fizer, dê a ele um lugar isolado para esse trabalho: as container machines dão a um agente um ambiente Linux rápido e persistente no Mac, isolado em VM com seu diretório home montado dentro, de modo que builds e instalações rodem atrás de uma fronteira real em vez de contra o host.
2. Distribua só quando um único Mac não basta. Se um modelo não cabe na memória ou a inferência está lenta demais, conecte Macs entre si por Thunderbolt 5, habilite o RDMA nas configurações, gere um arquivo de hosts com o mlx.distributed_config e execute os mesmos comandos sob o mlx.launch. Recorra ao paralelismo de tensores (o padrão) para velocidade e a uma topologia de malha para a baixa latência de que ele precisa.²
3. Faça a modelagem de ameaças antes de lançar recursos agênticos. Liste toda fonte de contexto não confiável e os efeitos colaterais de cada ação. Adicione confirmações com .onToolCall nas ferramentas que causam efeitos colaterais e spotlighting e ocultação com .historyTransform na saída de ferramenta não confiável; para o App Intents, revise os metadados de risco de cada intent e defina o authenticationPolicy para que ações destrutivas exijam um dispositivo desbloqueado.³
4. Faça profiling antes de confiar nele. Faça profiling do seu recurso de Foundation Models no Instrument do Xcode 27, leia as faixas de Instructions e Model Inference em busca de falhas silenciosas e use Time to First Token, Tokens per Second e Total Latency para encontrar os passos lentos.⁴

Tudo na Sessão 232 é “open-source e está disponível agora mesmo.”¹

FAQ

Eu realmente consigo rodar um agente de IA inteiramente no meu Mac?

Sim. A Sessão 232 da WWDC 2026 demonstra o loop agêntico completo rodando localmente por meio do MLX: um modelo raciocina, chama ferramentas, observa resultados e itera, com apenas as chamadas de ferramenta que genuinamente precisam da rede saindo da máquina. A pilha é o MLX, o MLX-LM, o MLX-LM Server compatível com OpenAI e, no topo, qualquer agente que fale o protocolo de chat completions da OpenAI.¹

Como conecto meu agente a um modelo MLX local?

Três passos. Instale o MLX-LM com o pip, inicie o mlx_lm.server com um modelo que suporte tool-calling e defina a base URL do seu framework de agente para o endereço do seu servidor local no localhost. O agente trata o servidor local exatamente como trataria uma API de LLM na nuvem, porque o MLX-LM Server é um servidor HTTP compatível com OpenAI do tipo drop-in.¹

E se o modelo for grande demais para um único Mac?

O MLX distribui um modelo entre vários Macs conectados por Thunderbolt 5, usando RDMA (suportado a partir do macOS 26.2) e a biblioteca de comunicação open-source JACCL da Apple. Você dispara os jobs com o mlx.launch e um arquivo de hosts; o MLX particiona o modelo automaticamente. A sessão da Apple executou um modelo de um trilhão de parâmetros em quatro M3 Ultras e observou ganhos de cerca de três vezes na inferência e no fine-tuning em comparação com uma única máquina.²

Qual é o principal novo risco de segurança para apps Mac agênticos?

A injeção indireta de prompt: instruções maliciosas escondidas em contexto não confiável (um evento do calendário, um feed social, o resultado de uma ferramenta) que redirecionam o modelo para ações que o usuário nunca pediu, como deletar dados ou exfiltrá-los. A Apple recomenda uma etapa de modelagem de ameaças mais barreiras determinísticas: confirmações com .onToolCall e spotlighting com .historyTransform e ocultação de PII no Foundation Models, e confirmações baseadas em risco e autenticação na tela de bloqueio no App Intents.³

Como depuro um agente que falha silenciosamente?

Use o Foundation Models Instrument no Xcode 27. Ele captura cada inferência de modelo, conjunto de instruções, prompt e resposta em faixas de timeline e em uma visualização em árvore, para que você possa ver exatamente quais ferramentas estavam disponíveis em cada passo e onde uma transição deu errado, mesmo quando o modelo nunca lança um erro. Ele também revela Time to First Token, Tokens per Second e Total Latency para o ajuste de desempenho.⁴

Rodar seu próprio modelo no Apple silicon é a base sobre a qual este loop se apoia: veja MLX no Apple Silicon: quando você precisa do seu próprio modelo, não do da Apple e executando modelos no Apple silicon com Core AI. A distinção entre runtime e tooling que molda como os agentes tocam um app Swift está em o fluxo de trabalho agêntico do Foundation Models. Uma vez que o loop roda, medir sua qualidade é o próximo passo, coberto em o framework de Evaluations da Apple. O hub completo da série é a Apple Ecosystem Series, e o contexto de construção mais amplo está no guia de iOS Agent Development.

References