Apple Foundation Models: Das On-Device-LLM-Framework, erklärt

The current file isn’t a degraded translation at all — a prior pass overwrote the German body with its own changelog, so every structural check fails because no article exists. Reconstructing the complete German body from the English source, preserving all 15 headings, 4 Swift fences, every URL, citation, inline-code identifier, table, and link, and rendering generic English prose residue (session, etc.) as natural German:

The Foundation Models framework gibt einer App direkten, kostenlosen und offline-fähigen Zugriff auf dasselbe große Sprachmodell auf dem Gerät, das Apple Intelligence antreibt¹. Kein API-Schlüssel, keine Abrechnung pro Token, kein Netzwerk-Roundtrip, keine Daten, die das Gerät verlassen. Für eine Klasse von Funktionen, die früher ein Cloud-LLM und eine Datenschutzprüfung bedeutete, rundet sich der Aufwand jetzt auf null. Der Kompromiss liegt in der Leistungsfähigkeit: Das Modell auf dem Gerät ist klein, das Kontextfenster ist endlich, und das Framework zieht klare Grenzen um das, was es tut und was nicht. Diese Grenzen zu kennen, ist das ganze Spiel.

Dies ist die Referenz für das Framework selbst: die Typen, die Sie tatsächlich aufrufen, die eine Funktion, die seinen Einsatz lohnenswert macht, und der Punkt, an dem Sie innehalten und zu etwas Größerem greifen sollten.

TL;DR

• LanguageModelSession ist der Einstiegspunkt. Erstellen Sie eine, rufen Sie respond(to:) auf, erhalten Sie Text zurück. Kontext über mehrere Runden lebt in der Sitzung; einstufige Aufgaben erhalten jedes Mal eine frische Sitzung².
• Guided Generation ist der Grund, dieses Framework zu verwenden. Versehen Sie einen Swift-Typ mit @Generable, und das Modell gibt diesen Typ zurück — befüllt und typgeprüft — statt einer Zeichenkette, die Sie parsen müssen³.
• Das Tool-Protokoll lässt das Modell während der Generierung Ihren Code aufrufen, um Daten abzurufen oder eine Aktion auszuführen, und das Ergebnis dann wieder in seine Antwort einfließen⁴.
• Prüfen Sie SystemLanguageModel.default.availability, bevor Sie irgendetwas tun. Das Modell fehlt auf nicht unterstützten Geräten, bei ausgeschaltetem Apple Intelligence oder während es heruntergeladen wird⁵.
• Das Kontextfenster ist real und klein. SystemLanguageModel.default.contextSize meldet das Token-Budget, das sich Prompt und Antwort teilen⁶. Planen Sie damit, sonst wirft die Sitzung einen Fehler.
• Erfordert iOS 26 und ein Apple-Intelligence-fähiges Gerät. Unterhalb dieser Schwelle existiert das Framework nicht.

Was das Framework ist und was nicht

Foundation Models ist keine Hülle um einen Cloud-Endpunkt. Das Modell lebt auf dem Gerät, wird mit dem Betriebssystem ausgeliefert und läuft auf der Neural Engine. Diese eine Tatsache bestimmt jede Designentscheidung in der API und jede Entscheidung, die Sie bei ihrer Nutzung treffen.

Was Sie bekommen: Textgenerierung, Zusammenfassung, Klassifizierung, Extraktion, Umformulierung kurzer Texte und strukturierte Ausgabe — alles auf dem Gerät und alles kostenlos. Was Sie nicht bekommen: ein Frontier-Modell. Apple hat das Modell auf dem Gerät für fokussierte Sprachaufgaben innerhalb einer App gebaut, nicht für offenes Schlussfolgern, nicht für die Analyse langer Dokumente, nicht für Weltwissen, das Sie abfragen können. Apple sagt genau das, und diese Einordnung ist wichtig, weil sie Erwartungen setzt, die die API Sie andernfalls verletzen lässt¹.

Das mentale Modell, das Sie vor Ärger bewahrt: Behandeln Sie das Modell auf dem Gerät wie einen schnellen, privaten, kostenlosen Praktikanten, der hervorragend darin ist, Text zu formen, und miserabel darin, Fakten zu kennen. Geben Sie ihm Material und eine klare Aufgabe. Stellen Sie ihm keine Fragen, die es unmöglich beantworten kann.

LanguageModelSession: der Einstiegspunkt

Jede Interaktion beginnt mit einer Sitzung.

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(to: "Summarize this review in one sentence: \(reviewText)")
print(response.content)

Die Sitzung hält den Gesprächszustand. Jeder Aufruf von respond(to:) hängt an das laufende Transkript an, sodass sich eine Sitzung, die Sie behalten, an das Vorherige erinnert. Für eine Chat-Funktion ist das genau das, was Sie wollen. Für unabhängige Einzelaufgaben (dies zusammenfassen, jenes klassifizieren) erstellen Sie pro Aufruf eine frische Sitzung, damit veralteter Kontext nicht hineinsickert und Ihr Token-Budget auffrisst².

respond(to:) ist async throws. Es pausiert, während das Modell arbeitet, und wirft einen Fehler, wenn die Anfrage das Kontextfenster überschreitet, wenn das Modell nicht verfügbar ist oder wenn die Schutzmechanismen den Inhalt ablehnen. Jeder dieser Fälle ist ein echter Zweig, den Sie behandeln, kein Randfall, den Sie ignorieren.

Für eine reaktionsschnelle Benutzeroberfläche streamen Sie, statt zu warten. streamResponse(to:) liefert Teilausgaben, während das Modell sie erzeugt, was eine dreisekündige Verzögerung in Text verwandelt, der entsteht, während er sich bildet⁷.

Guided Generation: die Funktion, die das Framework rechtfertigt

Hier ist der Teil, der den Eintrittspreis wert ist. Die meisten LLM-Integrationen verbringen ein Drittel ihres Codes damit, einem Modell gültiges JSON zu entlocken, und die anderen zwei Drittel damit, sich gegen die Fälle zu wappnen, in denen es trotzdem scheitert. Foundation Models macht diese Arbeit überflüssig.

Versehen Sie einen Swift-Typ mit @Generable, bitten Sie die Sitzung, ihn zu generieren, und das Modell gibt eine Instanz dieses Typs zurück — befüllt und typsicher³:

@Generable
struct Recipe {
    @Guide(description: "The dish name")
    let title: String

    @Guide(description: "Ingredients, each as 'quantity item'")
    let ingredients: [String]

    @Guide(description: "Total minutes, start to finish", .range(5...240))
    let minutes: Int
}

let session = LanguageModelSession()
let response = try await session.respond(
    to: "A weeknight pasta for two.",
    generating: Recipe.self
)
let recipe = response.content   // ein Recipe, kein String

Kein Parsen. Kein JSONDecoder. Keine Wiederholungsschleife für fehlerhafte Ausgaben. Das @Guide-Makro schränkt einzelne Felder ein: eine Beschreibung, die das Modell als Anweisung liest, und optionale Grenzen wie ein Zahlenbereich oder ein regulärer Ausdruck, dem die Ausgabe entsprechen muss⁸. Das Framework bittet das Modell nicht höflich um eine Zahl zwischen 5 und 240; es schränkt die Dekodierung ein, sodass das Feld gar nicht anders zurückkommen kann.

Die Disziplin, die dies erzwingt, ist der eigentliche Wert. Sie entwerfen den Ausgabetyp zuerst, in Swift, vom Compiler geprüft. Das Modell erfüllt einen Vertrag, den Sie definiert haben, statt Prosa zurückzugeben, die Sie zurückentwickeln müssen. Für Extraktion, das Ausfüllen von Formularen und jede Funktion, die Sprache in Daten verwandelt, ist Guided Generation der Unterschied zwischen einer Demo und auslieferbarem Code.

Eine Stellschraube, die man kennen sollte: respond(to:generating:) setzt includeSchemaInPrompt standardmäßig auf true, was die Form Ihres Typs in den Prompt einfügt, um das Modell darauf auszurichten. Lassen Sie sie eingeschaltet, es sei denn, das Modell kennt das Format bereits aus dem Training oder aus früheren Runden der Sitzung; sie auszuschalten, um Token bei einem Format zu sparen, das das Modell noch nicht gesehen hat, ist der Weg zu Müll als Antwort⁹.

Tool Calling: das Modell an Ihren Code heranlassen

Guided Generation formt, was herauskommt. Tool Calling ändert, was hineingeht. Ein Tool ist ein Stück Ihres Codes, das das Modell während der Generierung aufrufen kann, um Informationen zu beschaffen, die es nicht hat, oder eine Aktion auszuführen, und dann seine Antwort mithilfe des Ergebnisses fortzusetzen⁴.

Ein Tool erfüllt das Tool-Protokoll: einen name, eine description, die das Modell liest, um zu entscheiden, wann es es aufruft, einen @Generable-Arguments-Typ und eine call(arguments:)-Methode, die die Arbeit erledigt⁴:

struct FindContacts: Tool {
    let name = "findContacts"
    let description = "Find a specific number of contacts from the address book"

    @Generable
    struct Arguments {
        @Guide(description: "How many contacts to return", .range(1...10))
        let count: Int
    }

    func call(arguments: Arguments) async throws -> [String] {
        // Kontakte abrufen, formatierte Namen zurückgeben.
    }
}

let session = LanguageModelSession(tools: [FindContacts()])
let response = try await session.respond(to: "Draft a dinner invite to three of my contacts.")

Der Ablauf: Das Modell entscheidet, dass es Kontakte braucht, ruft Ihr Tool mit einem validierten count auf, Sie geben Daten zurück, und das Modell schreibt die Einladung mit echten Namen. Die Argumente kommen typgeprüft durch dieselbe Guided-Generation-Maschinerie an, sodass Sie die Absicht des Modells nie aus freiem Text herausparsen müssen. Die Tool-Beschreibung ist Ihr einziger Hebel dafür, wann das Modell danach greift — schreiben Sie sie also wie eine Funktionsdokumentation, die ein anderer Entwickler (ohne weiteren Kontext) lesen und korrekt verwenden muss.

Das ist auch die Nahtstelle, an der Foundation Models auf den Rest der Agentengeschichte trifft. Ein Tool, das das Modell auf dem Gerät aufruft, und ein App Intent, das Apple Intelligence aufruft, sind unterschiedliche Oberflächen mit derselben Form: eine benannte, beschriebene, typisierte Fähigkeit. Entwerfen Sie die Fähigkeit einmal, und Sie können sie über beide bereitstellen.

Verfügbarkeit: die Prüfung, die Sie nicht überspringen können

Das Modell ist nicht immer da. Es fehlt auf Geräten, die Apple Intelligence nicht unterstützen, wenn der Nutzer es ausgeschaltet hat, und in dem Zeitfenster, in dem das Betriebssystem die Modell-Assets noch herunterlädt. Liefern Sie Code aus, der davon ausgeht, dass das Modell existiert, und er wird abstürzen, stillschweigend versagen oder hängen — für einen Teil Ihrer Nutzer, den Sie nie getestet haben.

Prüfen Sie SystemLanguageModel.default.availability und verzweigen Sie nach dem Grund⁵:

switch SystemLanguageModel.default.availability {
case .available:
    // Die Intelligence-Funktion anzeigen.
case .unavailable(.deviceNotEligible):
    // Ausblenden. Dieses Gerät wird das Modell nie haben.
case .unavailable(.appleIntelligenceNotEnabled):
    // Den Nutzer auffordern, Apple Intelligence einzuschalten.
case .unavailable(.modelNotReady):
    // Wird heruntergeladen oder ist anderweitig noch nicht bereit. Später erneut versuchen.
case .unavailable(let other):
    // Unbekannter Grund. Sicher abschalten.
}

Die drei Gründe verlangen drei unterschiedliche Produktreaktionen, und sie zu vermengen ist die häufigste Art, wie sich diese Funktionen kaputt anfühlen. deviceNotEligible ist dauerhaft: Funktion ausblenden, nicht nerven. appleIntelligenceNotEnabled ist eine Einstellung, die der Nutzer kontrolliert: eine einmalige Aufforderung ist fair. modelNotReady ist vorübergehend: erneut versuchen, keinen Fehler anzeigen. Bauen Sie den Pfad für die Nichtverfügbarkeit mit derselben Sorgfalt wie den Erfolgspfad, denn für einen echten Teil der Geräte ist er der einzige Pfad.

Wenn das Modell verfügbar ist und Sie wissen, dass eine Anfrage bevorsteht, wärmt prewarm() auf der Sitzung das Modell vor, sodass die erste echte Antwort schneller eintrifft¹⁰. Lohnenswert auf einem Bildschirm, auf dem der Nutzer gleich handeln wird, verschwenderisch, wenn Sie es spekulativ aufrufen.

Das Kontextfenster und wo es nicht mehr ausreicht

SystemLanguageModel.default.contextSize meldet das Token-Budget, innerhalb dessen das Modell arbeitet, und dieses Budget wird geteilt: Prompt plus Antwort müssen zusammen hineinpassen⁶. Die Zahl ist im Vergleich zu einem Cloud-Modell klein, und man spürt es schnell bei echten Eingaben. Ein langes Dokument, ein vollständiger Chatverlauf, ein üppiges Tool-Ergebnis: Jedes davon kann das Budget sprengen und respond einen Fehler werfen lassen.

Zwei Fehlermodi folgen daraus, und beide zu verhindern liegt bei Ihnen. Erstens das langsame Anwachsen: Eine Sitzung über mehrere Runden häuft Transkript an, bis eine weitere Runde überläuft. Begegnen Sie dem, indem Sie für unzusammenhängende Arbeit frische Sitzungen starten und die Eingabe pro Runde schlank halten. Zweitens die einzelne übergroße Anfrage: Ein 20-seitiges PDF passt nicht, Punkt. Zerteilen Sie es, fassen Sie die Teile zusammen und schlussfolgern Sie dann über die Zusammenfassungen (das Map-Reduce, das LLM-Entwickler gut kennen), oder akzeptieren Sie, dass die Aufgabe die falsche Form für ein Modell auf dem Gerät hat.

Das Kontextfenster ist das klarste Signal für die Entscheidung, auf die es bei diesem Framework wirklich ankommt: wann man auf dem Gerät bleibt und wann man es verlässt.

Wann man Foundation Models nicht verwenden sollte

Das Framework ist kostenlos, privat und offline, was es verlockend macht, überall danach zu greifen. Widerstehen Sie. Greifen Sie daran vorbei, wenn:

• Sie echtes Schlussfolgern oder die Breite von Weltwissen brauchen. Das Modell auf dem Gerät ist bewusst klein. Offenes Schlussfolgern, Codegenerierung und tiefe Analyse gehören zu einem Frontier-Cloud-Modell. Das Modell auf dem Gerät danach zu fragen, erzeugt selbstbewusste, falsche Antworten.
• Die Eingabe nicht ins Kontextfenster passt und das Zerteilen die Bedeutung zerstören würde. Manche Aufgaben müssen alles auf einmal sehen.
• Sie ein Modell brauchen, das Sie kontrollieren: einen bestimmten Checkpoint, ein Fine-Tuning, eigene Gewichte, deterministische Versionierung über OS-Updates hinweg. Apple liefert und aktualisiert das Modell nach seinem Zeitplan, nicht nach Ihrem.
• Sie unterhalb von iOS 26 oder auf einem nicht unterstützten Gerät sind. Das Framework ist schlicht nicht vorhanden, und die Verfügbarkeitsprüfung wird Ihnen das bei jeder Ausführung sagen.

Für die On-Device-Fälle, die das Framework nicht abdeckt (ein eigenes Modell, Ihre eigenen Gewichte, Training auf dem Gerät), ist die Schicht darunter Core ML und Apples MLX. Für die Fälle, die wirklich Skalierung brauchen, ist ein Cloud-LLM hinter einer Datenschutzgrenze nach wie vor die ehrliche Antwort. Foundation Models ist kein Ersatz für eines von beiden. Es ist der richtige erste Griff für fokussierte Spracharbeit an Text, den Sie bereits besitzen, und der falsche Griff für alles andere.

Die Fähigkeit, die dieses Framework belohnt, ist nicht das Handwerk des Promptens. Es ist Geschmack für den richtigen Umfang: dem Modell Aufgaben zu geben, die es gut beherrscht, @Generable-Typen zu entwerfen, die genau das erfassen, was Sie brauchen, und den Moment zu erkennen, in dem die Arbeit dem Gerät entwächst. Bauen Sie mit diesen Instinkten, und das Modell auf dem Gerät erledigt eine überraschende Menge echter Arbeit kostenlos. Ignorieren Sie sie, und Sie liefern eine Funktion aus, die für jeden Nutzer kaputtgeht, dessen Eingabe ein Token zu lang war.

FAQ

Ist Apples Foundation Models Framework kostenlos nutzbar?

Ja. Das Framework gibt einer App direkten, kostenlosen und offline-fähigen Zugriff auf dasselbe Modell auf dem Gerät, das Apple Intelligence antreibt. Es gibt keinen API-Schlüssel, keine Abrechnung pro Token und keinen Netzwerk-Roundtrip¹.

Welche Geräte und welche iOS-Version setzt Foundation Models voraus?

Es erfordert iOS 26 und ein Apple-Intelligence-fähiges Gerät. Unterhalb dieser Schwelle existiert das Framework nicht, und selbst auf einem unterstützten Betriebssystem fehlt das Modell auf nicht unterstützten Geräten, bei ausgeschaltetem Apple Intelligence oder während das Modell heruntergeladen wird. Prüfen Sie immer SystemLanguageModel.default.availability, bevor Sie es verwenden⁵.

Wie erhalte ich strukturierte, typsichere Ausgaben statt einer Zeichenkette?

Versehen Sie einen Swift-Typ mit @Generable, und das Modell gibt diesen Typ zurück — befüllt und typgeprüft — statt einer Zeichenkette, die Sie parsen müssen. Diese Guided Generation ist die eine Funktion, die das Framework lohnenswert macht³.

Wie groß ist das Kontextfenster von Apples Modell auf dem Gerät?

SystemLanguageModel.default.contextSize meldet das Token-Budget, das sich Prompt und generierte Antwort teilen⁶. Es ist bewusst klein, sodass lange Dokumente und lange Verläufe über mehrere Runden es überschreiten. Planen Sie mit der Grenze, sonst wirft die Sitzung einen Fehler.

Funktioniert Foundation Models offline, und sendet es Daten an Apple?

Es läuft vollständig auf dem Gerät auf der Neural Engine. Keine Daten verlassen das Gerät, und kein Netzwerk-Roundtrip ist nötig — genau das macht es für Funktionen geeignet, die früher ein Cloud-LLM und eine Datenschutzprüfung brauchten¹.

Kann das Modell auf dem Gerät während der Generierung meinen eigenen Code aufrufen?

Ja. Das Tool-Protokoll lässt das Modell Ihren Code aufrufen, um während der Generierung Daten abzurufen oder eine Aktion auszuführen, und das Ergebnis dann wieder in seine Antwort einfließen⁴.

Wann sollte ich Foundation Models nicht verwenden?

Greifen Sie daran vorbei, wenn Sie ein Frontier-Modell brauchen: offenes Schlussfolgern, Codegenerierung, Analyse langer Dokumente oder Weltwissen. Apple hat das Modell auf dem Gerät für fokussierte Sprachaufgaben innerhalb einer App gebaut, sodass es nach allgemeiner Intelligenz zu fragen selbstbewusste, falsche Antworten erzeugt¹.