Agentische KI auf dem Mac mit MLX betreiben

Auf der WWDC 2026 bat ein Apple-Ingenieur einen lokalen Agenten auf seinem Mac darum, die jüngsten Pull Requests aus dem MLX-Repository abzurufen, die Änderungen zusammenzufassen und zu kennzeichnen, was Aufmerksamkeit erforderte. Das Modell überlegte, rief das GitHub CLI auf, las die Diffs und erzeugte eine Zusammenfassung. Nur die git-Befehle berührten das Netzwerk; das Modell lief vollständig auf seiner Hardware.¹ Diese Demo ist die ganze These dieses Beitrags: Der agentische Loop, also jener Teil, in dem ein Modell entscheidet, ein Werkzeug aufruft, das Ergebnis beobachtet und erneut entscheidet, läuft nun lokal auf dem Mac mit MLX. Keine Cloud, keine API-Schlüssel, keine Kosten pro Token. Und Apple lieferte den Rest der Geschichte gleich mit: wie sich dieser Loop über mehrere Macs skalieren lässt, wie sich agentische Funktionen gegen eine neue Klasse von Angriffen absichern lassen und wie sich der Loop debuggen lässt, wenn er stillschweigend das Falsche tut.

Dieser Beitrag geht die vier WWDC-2026-Sessions durch, die zusammen lokale agentische KI auf dem Mac zu einer echten technischen Oberfläche machen und nicht bloß zu einer Tech-Demo. Alles Folgende stammt direkt aus diesen Sessions.

TL;DR

• MLX führt den gesamten agentischen Loop lokal auf dem Mac über einen vierschichtigen Stack aus: MLX als Fundament, MLX-LM für Modelle, MLX-LM Server als OpenAI-kompatibler HTTP-Server und darüber jeder beliebige Agent, der das OpenAI-Chat-Completions-Protokoll spricht.¹
• Die Einrichtung umfasst drei Schritte: MLX-LM per pip install installieren, mlx_lm.server mit einem Tool-Calling-Modell starten und die Basis-URL Ihres Agenten auf localhost richten.¹
• Wenn ein Mac nicht ausreicht, verteilt MLX ein Modell über Thunderbolt 5 auf mehrere Macs, mithilfe von RDMA und Apples Open-Source-Bibliothek JACCL, führt dabei Modelle mit einer Billion Parametern aus und beschleunigt Inferenz und Fine-Tuning auf einem Vier-Knoten-Cluster um etwa das Dreifache.²
• Agentische Funktionen eröffnen eine neue Angriffsfläche: indirekte Prompt-Injection. Apples Antwort darauf setzt auf deterministische Schutzmechanismen: .onToolCall-Bestätigungen und .historyTransform-Spotlighting in Foundation Models sowie risikobasierte Bestätigungen und Sperrbildschirm-Authentifizierung in App Intents.³
• Das Foundation Models Instrument in Xcode 27 macht den Loop beobachtbar: Spuren pro Anfrage, eine Baumansicht der Gedankenkette des Modells und die Metriken (Time to First Token, Tokens per Second, Total Latency), die Sie benötigen, um stille Fehler und langsame Inferenzen aufzuspüren.⁴

Der lokale agentische Stack (Session 232)

Angelos vom MLX-Team führt ab 2:42 durch die dreistufige Einrichtung.

Die Chat-Erfahrung, die die meisten Entwickler kennen, schiebt die Arbeit auf den Menschen zurück. Wie die Session es formuliert: „Sie senden einen Prompt an das Sprachmodell. Das Modell sendet eine Antwort zurück. Wenn Sie auf diese Antwort hin handeln, einen Befehl ausführen, eine Datei prüfen oder einen Fehler beheben müssen, liegt das an Ihnen.”¹ Ein Agent schließt diese Lücke. Der Agent spricht mit dem Modell, um zu entscheiden, was zu tun ist, ruft Werkzeuge auf, um es zu tun, beobachtet die Ergebnisse und geht für den nächsten Schritt zum Modell zurück. Vom Benutzer zum Agenten, vom Agenten zum Modell, vom Agenten zu den Werkzeugen, im Kreislauf, bis die Aufgabe erledigt ist.

Was den Loop auf Apple silicon interessant macht, ist, dass alles davon lokal läuft. MLX stellt diese Fähigkeit als vier Schichten dar, von unten nach oben: MLX, „unser quelloffenes Array-Framework, das eigens für Apple silicon gebaut wurde”, übernimmt Berechnung, Metal-Beschleunigung und Speicher; MLX-LM zum Laden, Ausführen, Quantisieren und Fine-Tunen von Modellen aus Hugging Face; MLX-LM Server, „ein OpenAI-kompatibler HTTP-Server, der Ihr lokales Modell über eine Standard-API bereitstellt”, mit strukturiertem Tool-Calling und Unterstützung für Reasoning-Modelle; und ganz oben jeder beliebige Agent, der das OpenAI-Chat-Completions-Protokoll spricht, sei es Xcode, OpenCode, ein Pi-Agent oder ein eigenes Skript.¹ Die standardisierte Schnittstelle ist die tragende Entscheidung: „Jedes Agent-Framework funktioniert sofort”, und Werkzeuge wie Ollama, LM Studio und vLLM bauen bereits auf MLX und MLX-LM auf.¹

Die Einrichtung umfasst drei Schritte. MLX-LM mit einem einzigen pip install installieren. Den Server mit einem Tool-Calling-Modell starten:

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

Anschließend richten Sie Ihren Agenten auf den lokalen Server, indem Sie dessen Basis-URL auf localhost setzen. Wie die Session anmerkt: „Der Agent weiß nicht und kümmert sich nicht darum, dass das Modell auf Ihrem Mac läuft und nicht in der Cloud.”¹ In OpenCode bedeutet das, einen lokalen Anbieter zu definieren, dessen URL localhost ist und dessen Modellname dem entspricht, was der Server erwartet, und OpenCode dann anzuweisen, für alles dieses lokale Modell zu verwenden.

Der interessante Teil ist, wie sich MLX speziell bei agentischen Workloads bewährt. Die Session nennt drei Herausforderungen. Die erste ist die Prompt-Verarbeitung: „Agentische Sitzungen umfassen üblicherweise Hunderttausende von Tokens, und die meisten davon werden nicht generiert.”¹ Jedes Mal, wenn das Modell eine Werkzeugausgabe erhält, verarbeitet es diesen gesamten neuen Kontext, bevor es weiter überlegt, und diese Kosten wiederholen sich durch den gesamten Loop. Die dedizierten Neural Accelerators des M5-Chips machen die Matrixmultiplikation viermal schneller als auf dem M4, und mit den spezialisierten Kerneln von MLX „überträgt sich das fast exakt auf die Beschleunigung der Prompt-Verarbeitung”, ohne dass besondere Argumente oder Codeänderungen erforderlich sind.¹ Die zweite Herausforderung ist Nebenläufigkeit: Agenten erzeugen Subagenten, und MLX-LM Server bewältigt die gleichzeitigen Anfragen mit kontinuierlichem Batching, indem er sie dynamisch gruppiert, sodass Subagenten „nicht in einer Warteschlange hängenbleiben.”¹ Die dritte Herausforderung ist die Modellgröße, und genau dort setzt die nächste Session an.

Angelos schloss mit einer Demo jenseits von Lesen und Berichten: Aus einem leeren Xcode-Projekt bat er den Agenten, eine SwiftUI-Zeichen-App für das iPad zu bauen. Der Agent inspizierte das Verzeichnis, erstellte einen Plan, schrieb den Code und nutzte xcodebuild, um seine eigenen Fehler zu kompilieren und zu beheben, und erzeugte in etwa zwei Minuten eine funktionierende App, die er auf Wunsch dann um abgerundete Linienenden erweiterte.¹ Eine abschließende Demo band denselben laufenden MLX-Server als lokal gehosteten Chat-Anbieter in die Intelligence-Einstellungen von Xcode ein, sodass Xcode selbst einen eingebauten Bug finden und beheben konnte. „Lokale KI bedeutet, dass Ihr Code Ihren Mac niemals verlässt.”¹

Skalierung über mehrere Macs (Session 233)

Tatiana baut Schritt für Schritt ein Cluster aus vier Macs auf, beginnend bei 2:21.

Irgendwann geht einer Maschine der Platz aus. Wie Tatiana, eine Research Scientist im MLX-Team, es formulierte: „Irgendwann werden Speicher, Rechenleistung oder Bandbreite auf einer einzelnen Maschine zur Beschränkung.”² Der Paradefall aus Session 232 ist ein Modell, das schlicht nicht hineinpasst: Das jüngste DeepSeek-Modell „hat satte 1,6 Billionen Parameter und benötigt allein für die Gewichte mehr als 800 GB Speicher.”¹ Session 233 ist der Tiefgang dazu, wie sich diese Arbeit über Macs verteilen lässt, die Ihnen gehören.

Der Stack unter dem verteilten MLX besteht aus drei Teilen. Die Verbindung und der Transport: Ab macOS 26.2 wird Remote Direct Memory Access (RDMA) über Thunderbolt 5 unterstützt und bewegt Daten direkt aus dem Speicher einer Maschine in den einer anderen, während es „den größten Teil des CPU- und Betriebssystem-Overheads vermeidet.”² Das Kommunikations-Backend: JACCL, „eine quelloffene kollektive Kommunikationsbibliothek, die von Apple gebaut wurde”, läuft über RDMA über Thunderbolt und stellt kollektive Primitive bereit, ohne dass Sie den Transport verwalten müssen, und ist „nicht auf maschinelles Lernen beschränkt” und „lässt sich ohne MLX bauen”, da es für jeden verteilten Workload eine C++-API bereitstellt.² MLX sitzt obenauf und nutzt JACCL für latenzarme Koordination über das Cluster hinweg.

Tatiana baute ein Cluster aus vier M3 Ultras. Die Topologie ist entscheidend, weil sich die Kommunikationszeit in Latenz (ein fester Kostenanteil pro Operation) und Übertragungszeit (die mit der Nachrichtengröße wächst) aufteilt. JACCL unterstützt ein Mesh, bei dem „jede Maschine direkt mit jeder anderen verbunden ist”, für die geringste Latenz, sowie einen Ring, bei dem jeder Knoten mit zwei Nachbarn verbunden ist und dabei Ports freigibt, um pro Nachbar mehrere Kabel für mehr Bandbreite zu verlegen. Als Mesh verdrahtet, „wählt JACCL automatisch die beste Topologie, je nach Nachrichtengröße und Kommunikationsoperation: Mesh, wenn Latenz zählt, Ring, wenn Bandbreite zählt.”² Sie aktivieren RDMA in den Einstellungen und starten dann Jobs mit mlx.launch, das auf eine JSON-Hostdatei verweist; das Hilfsskript mlx.distributed_config erzeugt diese Hostdatei und konfiguriert mit --auto-setup das Thunderbolt-Netzwerk selbst.²

Ein Modell über das Cluster auszuführen ist nahezu identisch dazu, es auf einer einzelnen Maschine auszuführen. Sie umschließen denselben mlx_lm.chat-Befehl mit mlx.launch --hostfile, und „MLX LM zerlegt das Modell und koordiniert die verteilte Inferenz für Sie.”² Im direkten Vergleich generierte ein Qwen 3.6 mit 27 Milliarden Parametern Tokens „mit nahezu dem Dreifachen der Rate einer einzelnen Maschine” auf vier M3 Ultras.² MLX unterstützt zwei Sharding-Strategien: Pipeline-Parallelität (nach Tiefe, einfache Kommunikation, aber keine Beschleunigung) und Tensor-Parallelität (nach Breite, alle Maschinen verarbeiten dasselbe Token gleichzeitig für eine Beschleunigung, um den Preis häufiger Kommunikation pro Schicht, „weshalb die Mesh-Topologie entscheidend ist”).² Tensor-Parallelität ist die Voreinstellung. Die Session führte das Kimi 2.6 mit einer Billion Parametern (etwa ein Terabyte Gewichte bei 8 Bit, das „nicht auf einen einzelnen M3 Ultra passt, aber über vier hinweg passen kann”) über das Cluster aus.² Derselbe Ansatz beschleunigt das Fine-Tuning: Datenparalleles LoRA-Training über mlx_lm.lora brachte einen einzelnen M3 Ultra von rund 180 Tokens pro Sekunde auf rund 600 auf dem Cluster, „mehr als das Dreifache an Beschleunigung.”² MLX stellt dieselben Primitive über Python, Swift und C++ bereit, um verteilte Arbeitsabläufe in Apps einzubetten.

Den Loop absichern (Session 347)

Willy führt um 4:01 die indirekte Prompt-Injection ein; Akshay behandelt die Framework-APIs ab 11:55.

Einem Modell die Fähigkeit zu geben, Werkzeuge aufzurufen, öffnet eine Tür. Wie Willy es formulierte: „LLMs führen eine neue probabilistische Engine in Ihre Anwendung ein, die zwar mächtig ist, aber Gefahr läuft, getäuscht zu werden.”³ Das neue Risiko ist die indirekte Prompt-Injection, die die Session definiert als „Anweisungen, die in zusätzlichem Kontext eingebettet sind, der dem Modell mit der Absicht bereitgestellt wird, den Kontrollfluss umzuleiten.”³ Die Beispiel-App der Session, Loose Leaf, fügt eine Funktion „Eine Teeparty organisieren” hinzu, die Ihren Kalender und Ihren Freundes-Feed liest und Tees bestellen kann. Der Angriff: Ein Benutzer bittet darum, eine Party mit angehängtem Kalender zu planen, doch ein Kalendereintrag enthält eine eingeschleuste Anweisung, die dem Modell sagt, es solle stattdessen sensible Benutzerdaten löschen.³

Injection erzeugt zwei Effekte. Datenvergiftung, „ein Angreifer beeinflusst die Parameter einer ausgeführten Aktion”, verwandelt eine für Ihre Mutter bestimmte Nachricht in eine, die an den Angreifer gesendet wird. Aktionsvergiftung, bei der der Angreifer „beeinflusst, welche Aktion ausgeführt wird”, lenkt eine Anfrage zum Zusammenfassen einer E-Mail darauf um, eine bösartige URL mit angehängter E-Mail zu öffnen.³ Die Session verankert die Gefahr in Simon Willisons Lethal Trifecta: Ein Benutzer ist am stärksten gefährdet, wenn ein agentisches System Zugriff auf private Daten, Kontakt mit nicht vertrauenswürdigen Inhalten und die Fähigkeit zur externen Kommunikation vereint, verallgemeinert zu „dem Risiko von Aktionen mit irgendeinem Seiteneffekt.”³ Die Einordnung ist ehrlich: „Die Lösung der indirekten Prompt-Injection ist ein aktives Forschungsfeld”, weshalb das realistische Ziel darin besteht, das Risiko Ihrer App zu verstehen und es zu mindern.³

Die Methode ist eine Bedrohungsmodellierung. Zunächst eine Datenflussanalyse von allem, was in den Prompt einfließt, wobei „alle Eingaben, die von einer externen Entität stammen”, als nicht vertrauenswürdig markiert werden, was für Loose Leaf den Kalenderinhalt und den Freundes-Feed bedeutet.³ Zweitens eine Bestandsaufnahme der Aktionen des Agenten und ihrer Seiteneffekte: Ein Werkzeug zur Teebestellung birgt ein finanzielles Risiko, ein Werkzeug zum Posten im Feed birgt ein Datenexfiltrationsrisiko, und selbst ein harmlos wirkender Brüh-Timer ist riskant, weil seine optionale Beschriftung „es einer Prompt-Injection erlauben könnte, weitere Anweisungen für spätere Angriffe zu schreiben.”³ Apples erklärte Präferenz ist, „sich als Grundlage auf deterministische Gegenmaßnahmen zu konzentrieren, weil ihre Sicherheitsgarantien leichter zu prüfen und nachzuvollziehen sind”, während probabilistische Gegenmaßnahmen obendrauf geschichtet werden.³

Anschließend zeigte Akshay die APIs. In Foundation Models sind die Modifier für Lebenszyklusereignisse „Callbacks, die an bestimmten Punkten im Lebenszyklus einer Sitzungsausführung deterministisch ausgelöst werden”, nutzbar als Sicherheitsprüfpunkte. Der .onToolCall-Modifier läuft, bevor der Executor ein Werkzeug ausführt, und „wenn dieser Callback einen Fehler wirft, wird das Werkzeug niemals ausgeführt”, was „diesen zum perfekten Ort macht, um Bestätigungen durchzusetzen”: prüfen, ob das aktuelle Werkzeug das finanzielle ist, und falls ja, zuerst eine Benutzerbestätigung verlangen.³ Der .historyTransform-Modifier „feuert, bevor das Transkript dem Modell zur Inferenz übergeben wird”, sodass Sie nicht vertrauenswürdige Werkzeugausgaben in Spotlighting-Trennzeichen einschließen und PII redigieren können, indem Sie sensible Abschnitte durch einen [REDACTED]-Platzhalter ersetzen, bevor das Modell sie sieht.³ Ein Vorbehalt: Diese Transformationen „sind nur auf die aktuelle Inferenz-Iteration beschränkt”, weshalb Sie sie bei jedem Aufruf erneut anwenden oder die @SessionProperty-Annotation für Transformationen verwenden, die fortbestehen sollen.³

Für Apps, die sich über App Intents in Siri integrieren, gelten zwei System-Schutzmechanismen. Bestätigungen sind „risikobasiert” und „kontextabhängig”: Wenn ein Intent ein Schema übernimmt, erbt er dessen Risiko-Metadaten (Fotos zu löschen ist destruktiv, Daten zu exfiltrieren ist riskant), und ein System zur Risikobewertung kombiniert diese statischen Metadaten mit „dem dynamischen Zustand des Systems”, um zu entscheiden, ob der Benutzer vor der Ausführung gefragt werden soll.³ Die Sperrbildschirm-Authentifizierung ist die zweite: Weil Siri auf einem gesperrten Gerät erreichbar ist, setzen Sie die authenticationPolicy eines Intents auf .requiresAuthentication, damit destruktive Aktionen im gesperrten Zustand nicht ausgeführt werden können; die Standardrichtlinie eines Schemas lässt sich „nur überschreiben, um sie strenger zu machen”, und eine schwächere Überschreibung erzeugt einen Build-Fehler.³

Den Loop debuggen (Session 243)

Erik diagnostiziert ab 1:58 ein stilles agentisches Versagen in seiner Craft-App.

Die Flexibilität des Loops ist zugleich sein Debugging-Problem. Wie Erik, ein AI Tools Engineer, es ausdrückte: „Traditioneller Code ist vorhersehbar. LLMs sind nicht-deterministisch; dieselbe Eingabe kann unterschiedliche Ausgaben erzeugen.”⁴ Er nannte drei Herausforderungen, die in der traditionellen Entwicklung fehlen: probabilistische Ausgabe (sodass „Standard-Unit-Tests zusammenbrechen” und Sie stattdessen Qualität und Absicht bewerten), Modell-zu-Modell-Kommunikation und Beobachtbarkeit, „wenn in einer Pipeline aus mehreren Modellen etwas kaputtgeht, kann es sehr schwer sein zu erkennen, wo es schiefging.”⁴ Das Foundation Models Instrument in Xcode 27 existiert, um genau diese letzte Frage zu beantworten.

Erik demonstrierte es an seiner Craft-App, in der eine Brainstorming-Funktion zwei Anweisungssätze nutzt, Brainstorming und Tutorial-Generierung, wobei der Brainstorming-Satz ein GenerateCraftIdeaTool und ein SwitchToTutorialModeTool anbietet.⁴ Im Trace versagte die Funktion: Sie bot weiterhin Ideen an, anstatt zu einem Tutorial zu wechseln. Die Instructions-Spur erzählte die Geschichte sofort und zeigte, „dass für die gesamte Sitzung nur ein Anweisungssatz aktiv war, obwohl die Funktion zwei verwenden sollte, also ging während der Übergabe etwas schief.”⁴ Die Baumansicht, die alles in „Sitzungen, Anfragen, Modellinferenzen, Anweisungen, Prompts und Antworten” organisiert, brachte die Grundursache zutage: „Der Prompt verweist auf das switchToTutorialMode-Werkzeug, doch dieses Werkzeug ist mit dieser Anweisung gar nicht konfiguriert.”⁴ Das Modell rief weiterhin Werkzeuge auf, ohne einen Fehler zu werfen: „Das war ein stilles Versagen”, die am schwersten aufzuspürende Art.⁴ Das Hinzufügen des fehlenden Werkzeugs zum Toolset behob das Problem, und der erneute Trace zeigte zwei verschiedene aktive Anweisungssätze, wobei die Übergabe nach einem switchToTutorialMode-Werkzeugaufruf korrekt erfolgte.⁴

Das Instrument macht auch die Performance lesbar. Die Model-Inference-Spur verwendet gelbe Balken für die Verarbeitung des Eingabe-Prompts und orangefarbene Balken für die Antwortgenerierung.⁴ Drei Metriken treiben die Optimierung: Time to First Token („eine hohe Time to First Token bedeutet, dass die Leute auf einen leeren Bildschirm starren; um sie zu senken, kürzen Sie Ihren Prompt”), Tokens per Second (um „die Leistung über verschiedene Prompt-Konfigurationen hinweg zu vergleichen und Regressionen nach Änderungen aufzuspüren”) und Total Latency, „die Zahl, die die Leute am unmittelbarsten spüren”, deren Wahrnehmung sich verringert, indem Teilergebnisse früher gestreamt werden.⁴ Ein betrieblicher Hinweis: Das Instrument „erfasst Prompt- und Antwortdaten von Ihrem Gerät, die sensible Informationen enthalten können”, weshalb das Logging in der Produktion aus, aber für die Dauer des Trace an ist, und Sie Trace-Dateien an einem sicheren Ort aufbewahren.⁴

Wie Sie anfangen

Die vier Sessions fügen sich zu einer Abfolge zusammen, der Sie auf der Hardware folgen können, die Sie bereits besitzen:

1. Den lokalen Loop aufsetzen. MLX-LM per pip install installieren, mlx_lm.server zunächst mit einem kleinen Tool-Calling-Modell ausführen, um die Einrichtung zu validieren, und die Basis-URL Ihres Agenten auf localhost richten. Beginnen Sie mit Lesen-und-Berichten-Aufgaben, bevor Sie den Agenten Dateien schreiben oder Builds ausführen lassen.¹ Sobald er das tut, geben Sie ihm einen isolierten Ort, um diese Arbeit zu erledigen: Container-Maschinen geben einem Agenten eine schnelle, persistente Linux-Umgebung auf dem Mac, VM-isoliert mit eingehängtem Home-Verzeichnis, sodass Builds und Installationen hinter einer echten Grenze laufen statt gegen den Host.
2. Erst skalieren, wenn ein Mac nicht ausreicht. Wenn ein Modell nicht in den Speicher passt oder die Inferenz zu langsam ist, verbinden Sie Macs über Thunderbolt 5, aktivieren RDMA in den Einstellungen, erzeugen mit mlx.distributed_config eine Hostdatei und führen dieselben Befehle unter mlx.launch aus. Greifen Sie für Geschwindigkeit zur Tensor-Parallelität (der Voreinstellung) und für die nötige geringe Latenz zu einer Mesh-Topologie.²
3. Bedrohungsmodellierung vor dem Ausliefern agentischer Funktionen. Listen Sie jede nicht vertrauenswürdige Kontextquelle und jeden Seiteneffekt jeder Aktion auf. Fügen Sie .onToolCall-Bestätigungen bei seiteneffektbehafteten Werkzeugen sowie .historyTransform-Spotlighting und -Redigierung bei nicht vertrauenswürdiger Werkzeugausgabe hinzu; prüfen Sie bei App Intents die Risiko-Metadaten jedes Intents und setzen Sie die authenticationPolicy so, dass destruktive Aktionen ein entsperrtes Gerät erfordern.³
4. Profilieren, bevor Sie ihm vertrauen. Profilieren Sie Ihre Foundation-Models-Funktion im Instrument von Xcode 27, lesen Sie die Instructions- und Model-Inference-Spuren auf stille Fehler hin und nutzen Sie Time to First Token, Tokens per Second und Total Latency, um die langsamen Schritte zu finden.⁴

Alles aus Session 232 ist „quelloffen und jetzt sofort verfügbar.”¹

FAQ

Kann ich wirklich einen KI-Agenten vollständig auf meinem Mac betreiben?

Ja. WWDC 2026 Session 232 demonstriert den vollständigen agentischen Loop, der lokal über MLX läuft: Ein Modell überlegt, ruft Werkzeuge auf, beobachtet Ergebnisse und iteriert, wobei nur jene Werkzeugaufrufe, die das Netzwerk wirklich benötigen, nach außerhalb der Maschine gelangen. Der Stack besteht aus MLX, MLX-LM, dem OpenAI-kompatiblen MLX-LM Server und darüber jedem beliebigen Agenten, der das OpenAI-Chat-Completions-Protokoll spricht.¹

Wie verbinde ich meinen Agenten mit einem lokalen MLX-Modell?

Drei Schritte. MLX-LM mit pip installieren, mlx_lm.server mit einem Modell starten, das Tool-Calling unterstützt, und die Basis-URL Ihres Agent-Frameworks auf die Adresse Ihres lokalen Servers auf localhost setzen. Der Agent behandelt den lokalen Server genau so, wie er eine Cloud-LLM-API behandeln würde, weil MLX-LM Server ein direkt einsetzbarer, OpenAI-kompatibler HTTP-Server ist.¹

Was, wenn das Modell für einen Mac zu groß ist?

MLX verteilt ein Modell über mehrere Macs, die über Thunderbolt 5 verbunden sind, mithilfe von RDMA (ab macOS 26.2 unterstützt) und Apples quelloffener Kommunikationsbibliothek JACCL. Sie starten Jobs mit mlx.launch und einer Hostdatei; MLX zerlegt das Modell automatisch. Apples Session führte ein Modell mit einer Billion Parametern über vier M3 Ultras aus und verzeichnete bei Inferenz und Fine-Tuning gegenüber einer einzelnen Maschine etwa eine dreifache Beschleunigung.²

Was ist das wichtigste neue Sicherheitsrisiko für agentische Mac-Apps?

Indirekte Prompt-Injection: bösartige Anweisungen, die in nicht vertrauenswürdigem Kontext versteckt sind (ein Kalendereintrag, ein sozialer Feed, ein Werkzeugergebnis) und das Modell zu Aktionen umleiten, nach denen der Benutzer nie gefragt hat, etwa Daten zu löschen oder zu exfiltrieren. Apple empfiehlt einen Durchlauf zur Bedrohungsmodellierung plus deterministische Schutzmechanismen: .onToolCall-Bestätigungen sowie .historyTransform-Spotlighting und PII-Redigierung in Foundation Models und risikobasierte Bestätigungen sowie Sperrbildschirm-Authentifizierung in App Intents.³

Wie debugge ich einen Agenten, der stillschweigend versagt?

Verwenden Sie das Foundation Models Instrument in Xcode 27. Es erfasst jede Modellinferenz, jeden Anweisungssatz, jeden Prompt und jede Antwort in Zeitleisten-Spuren und einer Baumansicht, sodass Sie genau sehen können, welche Werkzeuge bei jedem Schritt verfügbar waren und wo eine Übergabe schiefging, selbst wenn das Modell nie einen Fehler wirft. Es zeigt zudem Time to First Token, Tokens per Second und Total Latency zur Performance-Optimierung an.⁴

Ein eigenes Modell auf Apple silicon auszuführen, ist das Fundament, auf dem dieser Loop steht: siehe MLX auf Apple Silicon: wenn Sie Ihr eigenes Modell brauchen, nicht Apples und Modelle auf Apple silicon mit Core AI ausführen. Die Unterscheidung zwischen Laufzeit und Tooling, die prägt, wie Agenten eine Swift-App berühren, finden Sie im agentischen Workflow von Foundation Models. Sobald der Loop läuft, ist die Messung seiner Qualität der nächste Schritt, behandelt in Apples Evaluations-Framework. Der zentrale Anlaufpunkt der gesamten Reihe ist die Apple Ecosystem Series, und der umfassendere Build-Kontext ist der iOS Agent Development Guide.

Referenzen