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

Das Foundation Models Framework gibt einer App direkten, kostenlosen und offline nutzbaren Zugriff auf genau jenes große Sprachmodell, das auf dem Gerät auch Apple Intelligence antreibt¹. Kein API-Schlüssel, keine Abrechnung pro Token, kein Netzwerk-Roundtrip, keine Daten, die das Gerät verlassen. Für eine ganze Klasse von Funktionen, die früher ein Cloud-LLM und eine Datenschutzprüfung bedeutet haben, sinken die Kosten damit praktisch auf null. Bezahlt wird mit Leistungsfähigkeit: Das Modell auf dem Gerät ist klein, das Kontextfenster endlich, und das Framework zieht harte Grenzen um das, was es tut und was nicht. Diese Grenzen zu kennen, ist die eigentliche Aufgabe.

Dies ist die Referenz zum Framework selbst: die Typen, die Sie tatsächlich aufrufen, die eine Funktion, die den Einsatz lohnt, und der Punkt, an dem Sie innehalten und zu etwas Größerem greifen sollten.

Kurzfassung

• LanguageModelSession ist der Einstiegspunkt. Sie erzeugen eine Sitzung, rufen respond(to:) auf und erhalten Text zurück. Der Kontext über mehrere Runden hinweg lebt in der Sitzung; für Einzelaufgaben nehmen Sie jedes Mal eine frische Sitzung².
• Geführte Generierung ist der Grund, dieses Framework zu benutzen. Annotieren Sie einen Swift-Typ mit @Generable, und das Modell liefert genau diesen Typ zurück — befüllt und typgeprüft, statt einer Zeichenkette, die Sie erst zerlegen müssen³.
• Über das Tool-Protokoll kann das Modell mitten in der Generierung Ihren Code aufrufen, um Daten zu holen oder eine Aktion auszuführen, und das Ergebnis anschließend in seine Antwort einweben⁴.
• Prüfen Sie SystemLanguageModel.default.availability, bevor Sie irgendetwas tun. Auf nicht unterstützten Geräten fehlt das Modell, ebenso bei ausgeschaltetem Apple Intelligence oder während des Downloads⁵.
• Das Kontextfenster ist real und klein. SystemLanguageModel.default.contextSize nennt das Token-Budget, das sich Prompt und Antwort teilen⁶. Auf dem Gerät beträgt dieses Budget 4K Tokens; das Modell auf Private Cloud Compute hebt es auf 32K¹⁴. Planen Sie damit, sonst wirft die Sitzung einen Fehler.
• Voraussetzung sind iOS 26 und ein Apple-Intelligence-fähiges Gerät. Darunter existiert das Framework schlicht nicht. Die iOS-27-Betas erweitern dieselbe API um Bildeingaben, Steuerung der Tool-Aufrufe pro Anfrage und ein Servermodell auf Private Cloud Compute¹²¹³¹⁴.

Was das Framework ist — und was nicht

Foundation Models ist keine Hülle um einen Cloud-Endpunkt. Das Modell liegt auf dem Gerät, wird mit dem Betriebssystem ausgeliefert und läuft auf der Neural Engine. Diese eine Tatsache prägt jede Entwurfsentscheidung in der API und jede Entscheidung, die Sie damit treffen.

Was Sie bekommen: Textgenerierung, Zusammenfassung, Klassifikation, Extraktion, kurze Umformulierungen und strukturierte Ausgaben — 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 eng umrissene 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 das selbst so, und diese Einordnung zählt, weil sie Erwartungen setzt, die die API Sie andernfalls verletzen ließe¹.

Das mentale Modell, das Sie aus Schwierigkeiten heraushält: Behandeln Sie das Modell auf dem Gerät wie einen schnellen, privaten, kostenlosen Praktikanten, der Text hervorragend formen kann und Fakten miserabel kennt. 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, eine dauerhaft gehaltene Sitzung erinnert sich also an alles Vorherige. Für eine Chat-Funktion ist genau das erwünscht. Für unabhängige Einzelaufgaben (dies zusammenfassen, jenes klassifizieren) erzeugen Sie pro Aufruf eine frische Sitzung, damit kein alter Kontext hineinsickert und Ihr Token-Budget auffrisst².

respond(to:) ist async throws. Der Aufruf wird angehalten, während das Modell arbeitet, und wirft einen Fehler, wenn die Anfrage das Kontextfenster sprengt, das Modell nicht verfügbar ist oder 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 UI streamen Sie, statt zu warten. streamResponse(to:) liefert Teilausgaben, während das Modell sie erzeugt — aus drei Sekunden Stillstand wird Text, der vor den Augen des Benutzers entsteht⁷.

Geführte Generierung: die Funktion, die das Framework rechtfertigt

Hier kommt der Teil, der den Eintrittspreis wert ist. Die meisten LLM-Integrationen verbringen ein Drittel ihres Codes damit, dem Modell gültiges JSON abzuringen, und die übrigen zwei Drittel damit, sich gegen die Fälle zu wappnen, in denen es trotzdem schiefgeht. Foundation Models streicht diese Arbeit ersatzlos.

Annotieren Sie einen Swift-Typ mit @Generable, lassen Sie die Sitzung ihn generieren, und das Modell liefert 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   // a Recipe, not a String

Kein Parsen. Kein JSONDecoder. Keine Wiederholungsschleife für fehlerhafte Ausgaben. Das Makro @Guide schränkt einzelne Felder ein: eine Beschreibung, die das Modell als Anweisung liest, dazu 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 so ein, dass das Feld gar nicht anders zurückkommen kann.

Der eigentliche Wert liegt in der Disziplin, die das erzwingt. Sie entwerfen zuerst den Ausgabetyp, in Swift, unter Aufsicht des Compilers. Das Modell erfüllt einen Vertrag, den Sie definiert haben, statt Prosa zu liefern, die Sie rückwärts entschlüsseln. Für Extraktion, das Ausfüllen von Formularen und jede Funktion, die Sprache in Daten verwandelt, ist geführte Generierung der Unterschied zwischen einer Demo und auslieferbarem Code.

Ein Schalter, den man kennen sollte: respond(to:generating:) setzt includeSchemaInPrompt standardmäßig auf true und spielt damit die Struktur Ihres Typs in den Prompt, um das Modell darauf einzunorden. Lassen Sie das eingeschaltet, sofern das Modell das Format nicht ohnehin aus dem Training oder aus früheren Runden der Sitzung kennt; wer die Option abschaltet, um bei einem dem Modell unbekannten Format Tokens zu sparen, bekommt Müll zurück⁹.

Tool-Aufrufe: dem Modell Zugriff auf Ihren Code geben

Geführte Generierung formt, was herauskommt. Tool-Aufrufe verändern, was hineingeht. Ein Tool ist ein Stück Ihres Codes, das das Modell mitten in der Generierung aufrufen kann, um fehlende Informationen zu beschaffen oder eine Aktion auszuführen, und dann seine Antwort mit dem Ergebnis fortzusetzen⁴.

Ein Tool erfüllt das Tool-Protokoll: ein name, eine description, die das Modell liest, um über den Einsatzzeitpunkt zu entscheiden, ein @Generable-Typ Arguments und eine Methode call(arguments:), 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] {
        // Fetch contacts, return formatted names.
    }
}

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 stellt fest, dass es Kontakte braucht, ruft Ihr Tool mit einem validierten count auf, Sie liefern Daten zurück, und das Modell schreibt die Einladung mit echten Namen. Die Argumente kommen typgeprüft an — über dieselbe Maschinerie der geführten Generierung —, Sie müssen die Absicht des Modells also nie aus freiem Text herausklauben. Die Beschreibung des Tools ist Ihr einziger Hebel darauf, wann das Modell danach greift; schreiben Sie sie deshalb wie eine Funktionsdokumentation, die ein anderer Entwickler ohne jeden weiteren Kontext lesen und korrekt anwenden muss.

Hier liegt zugleich 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¹¹, den Apple Intelligence aufruft, sind verschiedene Oberflächen mit derselben Form: eine benannte, beschriebene, typisierte Fähigkeit. Entwerfen Sie die Fähigkeit einmal, und Sie können sie über beide Wege anbieten.

Verfügbarkeit: die Prüfung, die Sie nicht überspringen dürfen

Das Modell ist nicht immer da. Es fehlt auf Geräten, die Apple Intelligence nicht unterstützen, wenn der Benutzer die Funktion abgeschaltet hat und während der Zeitspanne, in der das Betriebssystem die Modelldaten noch herunterlädt. Wer Code ausliefert, der die Existenz des Modells voraussetzt, bekommt Abstürze, stille Fehlfunktionen oder Hänger — bei einem Teil seiner Benutzer, den er nie getestet hat.

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

switch SystemLanguageModel.default.availability {
case .available:
    // Show the intelligence feature.
case .unavailable(.deviceNotEligible):
    // Hide it. This device will never have the model.
case .unavailable(.appleIntelligenceNotEnabled):
    // Prompt the user to turn on Apple Intelligence.
case .unavailable(.modelNotReady):
    // Downloading or otherwise not ready yet. Try again later.
case .unavailable(let other):
    // Unknown reason. Fail closed.
}

Die drei Gründe verlangen drei unterschiedliche Produktantworten, und sie in einen Topf zu werfen ist der häufigste Weg, solche Funktionen kaputt wirken zu lassen. deviceNotEligible ist endgültig: Funktion ausblenden, nicht nachbohren. appleIntelligenceNotEnabled ist eine Einstellung, die der Benutzer kontrolliert — ein einmaliger Hinweis ist fair. modelNotReady ist vorübergehend: erneut versuchen, keine Fehlermeldung zeigen. Bauen Sie den Nicht-verfügbar-Pfad mit derselben Sorgfalt wie den Erfolgsfall, denn für einen realen Teil der Geräte ist er der einzige Pfad.

Wenn das Modell verfügbar ist und Sie wissen, dass gleich eine Anfrage kommt, wärmt prewarm() auf der Sitzung das Modell vor, sodass die erste echte Antwort schneller eintrifft¹⁰. Auf einem Bildschirm, auf dem der Benutzer gleich handeln wird, lohnt sich das; spekulativ aufgerufen ist es Verschwendung.

Praxis: eine vollständige Funktion in einer Datei

Die obigen Bausteine ergeben zusammen eine echte Funktion — mit weniger Code, als die meisten Netzwerkschichten für einen einzigen Endpunkt brauchen. Das folgende Beispiel ist ein vollständiger, kompilierbarer SwiftUI-Bildschirm, der formlose Besprechungsnotizen in strukturierte Aufgabenpunkte verwandelt: Verfügbarkeitsprüfung, @Generable-Ausgabetyp, ein Aufruf mit geführter Generierung und die drei Nicht-verfügbar-Zweige sauber behandelt. Jedes Symbol stammt aus der oben dokumentierten Framework-Oberfläche²³⁵⁸.

import SwiftUI
import FoundationModels

@Generable
struct ActionItems {
    @Guide(description: "One-sentence summary of the meeting")
    let summary: String

    @Guide(description: "Concrete follow-up tasks, each starting with a verb")
    let tasks: [String]

    @Guide(description: "How urgent the follow-ups are overall", .anyOf(["low", "medium", "high"]))
    let urgency: String
}

struct MeetingNotesView: View {
    @State private var notes = ""
    @State private var result: ActionItems?
    @State private var errorMessage: String?

    var body: some View {
        Form {
            TextField("Paste meeting notes", text: $notes, axis: .vertical)
                .lineLimit(6...12)

            Button("Extract action items") {
                Task { await extract() }
            }
            .disabled(notes.isEmpty)

            if let result {
                Section(result.summary) {
                    ForEach(result.tasks, id: \.self) { Text($0) }
                    Text("Urgency: \(result.urgency)")
                }
            }

            if let errorMessage {
                Text(errorMessage).foregroundStyle(.secondary)
            }
        }
    }

    private func extract() async {
        switch SystemLanguageModel.default.availability {
        case .available:
            do {
                let session = LanguageModelSession()
                let response = try await session.respond(
                    to: "Extract the action items from these notes: \(notes)",
                    generating: ActionItems.self
                )
                result = response.content
            } catch {
                errorMessage = "The model could not process these notes."
            }
        case .unavailable(.appleIntelligenceNotEnabled):
            errorMessage = "Turn on Apple Intelligence in Settings to use this feature."
        case .unavailable(.modelNotReady):
            errorMessage = "The model is still downloading. Try again shortly."
        case .unavailable:
            errorMessage = "This feature needs an Apple Intelligence-capable device."
        }
    }
}

Drei Details lohnen bei einem so kleinen Beispiel die Aufmerksamkeit. Der Ausgabetyp ist die API: ActionItems legt exakt fest, was die Funktion produziert, und die @Guide-Einschränkung auf urgency sorgt dafür, dass die Zeichenkette nichts außerhalb der drei erlaubten Werte enthalten kann⁸. Die Sitzung wird pro Aufruf neu erzeugt, weil jede Extraktion für sich steht; eine dauerhaft gehaltene Sitzung würde frühere Notizen ins Token-Budget schleppen². Und die Nicht-verfügbar-Zweige erzeugen drei verschiedene Benutzererfahrungen statt einer generischen Fehlermeldung — das ist der Unterschied zwischen einer Funktion, die ehrlich abstuft, und einer, die kaputt aussieht. Fügen Sie die Datei in ein iOS-26-Projekt ein, starten Sie sie auf einem Apple-Intelligence-fähigen Gerät, und sie funktioniert.

Das Kontextfenster — und wo es nicht mehr reicht

SystemLanguageModel.default.contextSize nennt das Token-Budget, in dem das Modell arbeitet, und dieses Budget ist geteilt: Prompt und Antwort müssen zusammen hineinpassen⁶. Gemessen an einem Cloud-Modell ist die Zahl klein, und bei echten Eingaben spüren Sie das schnell. Ein langes Dokument, ein vollständiger Chatverlauf, ein üppiges Tool-Ergebnis: Jedes davon kann das Budget sprengen und respond zum Fehler zwingen.

Daraus folgen zwei Fehlerbilder, und beide zu verhindern liegt bei Ihnen. Erstens das schleichende Anwachsen: Eine Sitzung über mehrere Runden sammelt Transkript an, bis eine Runde zu viel überläuft. Dagegen hilft, für unzusammenhängende Arbeit frische Sitzungen zu starten und die Eingabe pro Runde schlank zu halten. Zweitens die einzelne, zu große Anfrage: Ein 20-seitiges PDF passt nicht, Punkt. Zerlegen Sie es in Stücke, fassen Sie die Stücke zusammen und schließen Sie dann über die Zusammenfassungen (das Map-Reduce, das LLM-Entwickler gut kennen) — oder akzeptieren Sie, dass die Aufgabe für ein Modell auf dem Gerät die falsche Form hat.

Das Kontextfenster ist das klarste Signal für die Entscheidung, auf die es bei diesem Framework wirklich ankommt: wann Sie auf dem Gerät bleiben und wann Sie es verlassen. Die Zahlen sind inzwischen öffentlich: Das Modell auf dem Gerät arbeitet in einem Budget von 4K Tokens, das Servermodell auf Private Cloud Compute hebt das auf 32K¹⁴. Alles Folgende zum Zerlegen gilt mit diesen Zahlen im Hinterkopf.

Was die iOS-27-Betas hinzufügen

Alles bisher Beschriebene betrifft das Framework, wie es in iOS 26 ausgeliefert wurde, und all das gilt weiterhin. Die iOS-27-Betas erweitern dieselbe Oberfläche in vier Richtungen, von denen keine das mentale Modell aus iOS 26 bricht¹².

Der Prompt nimmt Bilder auf. Das Modell auf dem Gerät bekommt Vision-Fähigkeiten: Sie fügen einem Prompt neben Text einen Bildanhang bei, und das Modell beantwortet Fragen zu beidem. Die neuen Typen heißen Attachment, ImageAttachmentContent und ImageReference; Anhänge akzeptieren UIImage, NSImage, CGImage, Core-Image-Typen, CoreVideo-Pixelpuffer und Datei-URLs¹²¹³. Bilder funktionieren in jeder Größe und jedem Seitenverhältnis, verbrauchen aber dasselbe Token-Budget wie Ihr Text — das 4K-Fenster auf dem Gerät wird also schnell zur bestimmenden Entwurfsgrenze¹³. Die vollständige Anleitung finden Sie unter Bildeingaben in Foundation Models unter iOS 27.

Tool-Aufrufe bekommen eine Drossel. GenerationOptions erhält einen toolCallingMode, den Sie pro Anfrage setzen und der steuert, wie das Modell mit den angehängten Tools umgeht; zudem liefert das Vision-Framework fertige Implementierungen von OCRTool und BarcodeReaderTool, die Sie an eine Sitzung anhängen, statt eigene Erkennungslogik zu schreiben¹⁵. Die Verhaltensdetails stehen in Steuerung der Tool-Aufrufe unter iOS 27.

Ein größeres Modell, eine Zeile entfernt. PrivateCloudComputeLanguageModel fährt dieselbe API gegen Apples Servermodell auf Private Cloud Compute — hinter einer Berechtigung, mit dem 32K-Kontextfenster und einem Schlussfolgerungsvermögen, das dem Modell auf dem Gerät fehlt¹²¹⁴. Geführte Generierung und Tools arbeiten unverändert; der Modellwechsel ist das Argument model der Sitzung.

Sitzungen bekommen mehr Steuerungsfläche. Die Betas ergänzen ContextOptions, TranscriptErrorHandlingPolicy, dynamische Profile (DynamicInstructions, LanguageModelSession.DynamicProfile) sowie ein Protokoll für eigene Sprachmodell-Anbieter (LanguageModel, LanguageModelExecutor), mit dem eine Sitzung ein von Ihnen bereitgestelltes Modell statt des Systemmodells ansteuert¹². Auch watchOS tritt der Plattformliste mit 27.0 bei¹².

Die Einordnung, die bleibt: iOS-26-Code kompiliert und verhält sich unter iOS 27 gleich. Die Betas erweitern, was ein Prompt tragen kann und wo das Modell laufen darf; was das Framework ist, ändern sie nicht.

Wann Sie Foundation Models nicht einsetzen sollten

Das Framework ist kostenlos, privat und offline — verlockend, überall danach zu greifen. Widerstehen Sie. Greifen Sie darüber hinaus, wenn:

• Sie echtes Schlussfolgern oder breites Weltwissen brauchen. Das Modell auf dem Gerät ist bewusst klein. Offenes Schlussfolgern, Codegenerierung und tiefe Analysen gehören einem Frontier-Modell in der Cloud. Wer sie vom Modell auf dem Gerät verlangt, bekommt selbstbewusste, falsche Antworten.
• Die Eingabe nicht ins Kontextfenster passt und das Zerlegen 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 Systemupdates 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. Dann existiert das Framework schlicht nicht, und die Verfügbarkeitsprüfung sagt Ihnen das bei jedem Lauf.

Für die Fälle auf dem Gerät, die das Framework nicht abdeckt (ein eigenes Modell, eigene Gewichte, Training direkt auf dem Gerät), liegen darunter Core ML für ein fest konvertiertes Modell, MLX für Open-Weight-Modelle und eigene Fine-Tunings sowie Core AI aus iOS 27, wenn Sie explizite Kontrolle über Spezialisierung und Scheduling brauchen. Für die Fälle, die wirklich Größe verlangen, bleiben Private Cloud Compute oder ein Cloud-LLM hinter einer Datenschutzgrenze die ehrliche Antwort. Foundation Models ersetzt keines davon. Es ist der richtige erste Griff für eng umrissene Sprachaufgaben auf Text, den Sie ohnehin schon haben — und der falsche für alles andere.

Die Fähigkeit, die dieses Framework belohnt, ist nicht Prompt-Handwerk. Es ist Geschmack in der Frage des Zuschnitts: dem Modell Aufgaben zu geben, die es gut kann, @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. Wer mit diesen Instinkten baut, bekommt vom Modell auf dem Gerät erstaunlich viel echte Arbeit geschenkt. Wer sie ignoriert, liefert eine Funktion aus, die für jeden Benutzer bricht, 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 nutzbaren Zugriff auf genau jenes Modell auf dem Gerät, das auch 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?

Erforderlich sind iOS 26 und ein Apple-Intelligence-fähiges Gerät. Darunter existiert das Framework nicht, und selbst auf einem unterstützten System fehlt das Modell auf nicht unterstützten Geräten, bei ausgeschaltetem Apple Intelligence oder während des Modell-Downloads. Prüfen Sie deshalb immer SystemLanguageModel.default.availability, bevor Sie es verwenden⁵.

Wie bekomme ich strukturierte, typsichere Ausgaben statt einer Zeichenkette?

Annotieren Sie einen Swift-Typ mit @Generable, dann liefert das Modell genau diesen Typ zurück — befüllt und typgeprüft, statt einer Zeichenkette, die Sie erst zerlegen müssen. Diese geführte Generierung ist die eine Funktion, die den Einsatz des Frameworks lohnt³.

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

SystemLanguageModel.default.contextSize nennt das Token-Budget, das sich Prompt und generierte Antwort teilen⁶. Das Modell auf dem Gerät bietet 4K Tokens, das Modell auf Private Cloud Compute 32K¹⁴. Lange Dokumente und lange Gesprächsverläufe sprengen das Budget auf dem Gerät — planen Sie also mit der Grenze, sonst wirft die Sitzung einen Fehler.

Funktioniert Foundation Models offline, und werden Daten an Apple gesendet?

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

Kann das Modell auf dem Gerät mitten in der Generierung meinen eigenen Code aufrufen?

Ja. Über das Tool-Protokoll kann das Modell während der Generierung Ihren Code aufrufen, um Daten zu holen oder eine Aktion auszuführen, und das Ergebnis anschließend in seine Antwort einweben⁴.

Wann sollte ich Foundation Models nicht verwenden?

Greifen Sie darüber hinaus, wenn Sie ein Frontier-Modell brauchen: offenes Schlussfolgern, Codegenerierung, Analyse langer Dokumente oder Weltwissen. Apple hat das Modell auf dem Gerät für eng umrissene Sprachaufgaben innerhalb einer App gebaut; wer allgemeine Intelligenz davon verlangt, bekommt selbstbewusste, falsche Antworten¹.

Was fügt iOS 27 zu Foundation Models hinzu?

Die iOS-27-Betas ergänzen Bildeingaben (Anhänge im Prompt, erzeugt aus UIImage, CGImage, Pixelpuffern und mehr), Steuerung der Tool-Aufrufe pro Anfrage über GenerationOptions, fertige Vision-Tools OCRTool und BarcodeReaderTool sowie PrivateCloudComputeLanguageModel, um dieselbe API gegen Apples Servermodell mit 32K Kontext zu fahren^12131415. iOS-26-Code läuft unverändert weiter.