Zum Hauptinhalt springen

Apple Foundation Models 3 & der On-Device-LLM-Stack für Claude-Nutzer

Fortgeschritten

Auf der WWDC 2026 (angekündigt am 8. Juni 2026) lieferte Apple die dritte Generation seiner Foundation Models — AFM 3 — und erweiterte das Foundation Models Framework in einer Weise, die auch dann zählt, wenn du nie Swift schreibst: Das Framework nimmt nun Drittanbieter-LLM-Anbieter auf (Anthropic Claude und Google Gemini werden als Swift-Pakete ausgeliefert), und der On-Device-Pfad hört auf, ein Spielzeug-3B-Modell zu sein, und ergänzt ein 20-Milliarden-Parameter-Sparse-MoE, das auf Apple Silicon läuft, indem es die meisten Experten im NAND hält und nur das, was ein Prompt braucht, in den RAM tauscht. Wenn du Claude-Apps baust und „On-Device“ bisher als getrenntes Universum von deinen API-Workflows behandelt hast, schließt sich diese Lücke dieses Jahr. Diese Seite entpackt, was tatsächlich ausgeliefert wurde, die nicht offensichtlichen Mechanismen und die konkreten Migrations- und Kompatibilitätsentscheidungen, die du jetzt hast.

What you'll learn
  • Die vier AFM-3-Modelle benennen — Core (3B), Core Advanced (20B sparse), Cloud, Cloud Pro — und welches wo läuft
  • Den Flash-plus-DRAM-Experten-Routing-Trick verstehen, der ein 20B-Modell überhaupt auf ein iPhone bringt
  • Die @Generable / @Guide-Makros des Foundation Models Frameworks für constrained decoding nutzen — das Modell kann buchstäblich kein ungültiges JSON ausgeben
  • Wissen, was sich auf der WWDC26 änderte: die Protokolle LanguageModel / LanguageModelExecutor, die es dir erlauben, Claude oder jedes andere LLM in dieselbe Swift-Session-API zu stecken
  • Entscheiden, wann du zum On-Device-3B greifst, wann du zu Private Cloud Compute springst und wann du die Workload auf der Claude-API belässt

Die Ein-Satz-Version​

AFM 3 ist Apples zweiter ernsthafter Wurf für On-Device-LLMs: ein neu gebautes 3B-Dense-Modell (Core), ein neues 20B-Sparse-MoE (Core Advanced), das auf dem iPhone läuft, indem es die meisten Experten im Flash-Speicher hält, ein Paar Cloud und Cloud Pro auf Apple Silicon plus NVIDIA-GPUs in Google Cloud, und ein Framework, das Anthropic Claude und Google Gemini nun als erstklassige, austauschbare Anbieter hinter demselben LanguageModel-Protokoll behandelt. Kostenlos für Entwickler, die On-Device aufrufen; kostenlos auf Private Cloud Compute für Mitglieder des App Store Small Business Program mit weniger als 2 Mio. Erstdownloads.

Drei nicht offensichtliche Dinge über AFM 3​

Alle schreiben die Schlagzeile „Apple hat ein 3B-On-Device-Modell“. Hier sind die Mechanismen, die die meisten Berichte auslassen.

1. Das 20B-Modell passt auf das iPhone, weil das meiste davon im NAND lebt, nicht im RAM​

Die naive Lesart „20-Milliarden-Parameter-Modell auf dem iPhone“ ist unmöglich: Selbst bei 4-Bit sind 20B Weights ~10 GB, weit über dem, was ein iPhone im RAM halten kann. Apples Trick, laut WWDC-2026-Ankündigung, ist es, das vollständige AFM-3-Core-Advanced-Modell im Flash-Speicher (NAND) zu speichern und nur die eingabeabhängigen routed experts in den DRAM zur Inferenzzeit zu tauschen. Die Architektur hat shared experts, die resident bleiben, und routed experts, die ein Router pro Prompt auswählt (Aktivierung von 1–4B Parametern gleichzeitig, nicht der vollen 20B). Kombiniert mit Quantization Aware Training ist das, was Apple erlaubt, ein 20B-Klasse-Modell auf einem Gerät auszuliefern, das ~8 GB nutzbaren RAM hat. Die Konsequenz für dich: iPhone-seitige Latenz wird nun weniger von Matrixmultiplikation dominiert und mehr von NAND-Lesebandbreite und den Entscheidungen des Routers — eine sehr andere Performance-Hülle als ein 3B-Dense-Modell.

2. Constrained Decoding ist in den Swift-Compiler eingebacken, nicht in die Runtime​

Das @Generable-Makro des Frameworks wird oft als „strukturierte Ausgabe“ beschrieben, was seinen Umfang untertreibt. @Generable läuft zur Compile-Zeit: Es erzeugt ein JSON-Schema und einen Parser für deinen Swift-Typ, und das Framework nutzt dieses Schema dann für constrained decoding — das On-Device-Modell wird auf Token-Ebene gezwungen, Ausgaben zu erzeugen, die sich zurück in deine Swift-Struct parsen lassen. Es gibt kein „hoffe, es ist gültiges JSON, und wiederhole dann“. Eine @Guide-Annotation lässt dich Vorgaben hinzufügen (.anyOf(["PG", "PG-13", "R", "G"]), Bereiche, Beschreibungen), die ebenfalls zur Decode-Zeit durchgesetzt werden. Wenn du Zeit damit verbracht hast, JSON-Repair-Fallbacks um eine Claude-Tool-Use-Schleife zu schreiben, kann die On-Device-3B-Modell-Seite deiner App diese gesamte Retry-Schicht fallen lassen.

3. Das Framework nimmt nun jedes LLM — einschließlich Claude und Gemini — hinter einer Swift-API​

Die WWDC-2026-Session „Bring an LLM provider to the Foundation Models framework“ lieferte zwei neue Protokolle aus: LanguageModel (deklariert Fähigkeiten und Executor-Konfiguration) und LanguageModelExecutor (übernimmt die eigentliche Generierung, den KV-Cache und das Streaming). Jeder kann ein Swift-Paket ausliefern, das sich daran hält — Apple nannte explizit Anthropic Claude und Google Gemini als Launch-Time-Anbieter. Die Konsequenz: Aus Sicht der App gelten dieselbe LanguageModelSession, dieselben @Generable-Typen, derselbe Tool-Calling-Vertrag und dasselbe Transcript-Modell, ob das zugrunde liegende Modell das On-Device-3B, Private Cloud Compute, Claude auf Anthropics API, Gemini auf Google Cloud oder eine MLX-Weights-Datei von Hugging Face ist. Die Modellwahl wird zur Swift-Paket-Abhängigkeit statt zu einem SDK-Rewrite.

AFM 3 auf einen Blick​

Drücke Enter oder die Leertaste, um die Karte umzudrehen. Nutze die Pfeiltasten links und rechts, um zwischen den Karten zu wechseln.Begriff angezeigt.
1 / 6

Was tatsächlich wo läuft​

Guided walkthrough1 of 4
  1. Läuft auf jedem Apple-Intelligence-Gerät. Kostenlos aus Swift über das Foundation Models Framework aufrufbar — kein API-Schlüssel, kein Netzwerk, keine Kosten pro Token. Hier legst du Klassifizierung, Extraktion, Zusammenfassung, On-Device-Rewrites und alles ab, was im Flugmodus funktionieren muss.

Ein minimaler On-Device-Aufruf​

Das Headline-Feature des Frameworks ist, dass du getypte, schema-validierte Ausgaben vom On-Device-3B mit fast keiner Zeremonie bekommen kannst.

On-Device-3B-Aufruf mit @Generable strukturierter Ausgabe (Swift)

import FoundationModels

@Generable
struct TripIdea {
  @Guide(description: "Short, evocative title")
  let title: String

  @Guide(description: "One-paragraph pitch, 40–80 words")
  let summary: String

  @Guide(.range(1...14))
  let estimatedDays: Int

  @Guide(.anyOf(["easy", "moderate", "hard"]))
  let difficulty: String
}

let session = LanguageModelSession()   // defaults to on-device Core
let idea = try await session.respond(
  to: "Suggest a shoulder-season trip in Puglia for a family with a 6-year-old.",
  generating: TripIdea.self          // constrained decoding
)

print(idea.title, idea.difficulty, idea.estimatedDays)

Zur Laufzeit wird das Modell auf Token-Ebene gezwungen, Tokens auszugeben, die den laufenden Text als TripIdea parsebar halten. Du siehst nie einen JSON-String; du erhältst einen TripIdea-Wert. Das ist derselbe Vertrag, ob die Session mit dem On-Device-3B, PCC oder einem Drittanbieter spricht, den du als Swift-Paket eingebunden hast.

Claude in dieselbe Swift-Session einbringen​

Die WWDC-2026-Session „Bring an LLM provider“ hat das konkret gemacht: Implementiere LanguageModel und LanguageModelExecutor, veröffentliche es als git-getaggtes Swift-Paket, und App-Code, der bereits das On-Device-3B nutzt, kann deinen Anbieter aufrufen, indem er einen Initializer ändert.

Skizze eines Drittanbieters, der LanguageModel implementiert

import FoundationModels

public struct ClaudeSonnet5: LanguageModel {
  public let capabilities = LanguageModelCapabilities(capabilities: [
      .toolCalling, .guidedGeneration, .reasoning
  ])
  public var executorConfiguration: ClaudeExecutor.Configuration
}

public final class ClaudeExecutor: LanguageModelExecutor {
  public struct Configuration: Hashable {   // hashable = KV-cache key
      public var modelID: String
      public var tokenProvider: TokenProvider   // NOT a plain API key string
  }

  public required init(configuration: Configuration) throws { /* … */ }

  public func respond(
      to request: LanguageModelExecutorGenerationRequest,
      model: Model,
      streamingInto channel: LanguageModelExecutorGenerationChannel
  ) async throws {
      // 1. Map Foundation Models transcript → Anthropic /messages payload
      // 2. Stream deltas back via channel.send(.response(action: .appendText(...)))
      // 3. Surface tool calls / reasoning via the same transcript entry types
  }
}

Zwei Feinheiten, zu denen die API dich bewusst hindrängt. Erstens: Configuration ist absichtlich Hashable: Das Framework cacht Executors nach Konfiguration, also gleiche Config = gleicher Executor = erhaltener KV-Cache über Turns hinweg. Zweitens: Die Leitlinie rät explizit von plain API-Key-Strings in Initialisierern ab — bevorzuge einen TokenProvider oder einen Sign-in-Flow, persistiere Tokens im Keychain und nutze App Attest für Cloud-Aufrufe, um zu verifizieren, dass das Gerät kein manipulierter Build ist, der deinen Endpunkt von außen trifft.

Wann was nutzen — eine Entscheidungstabelle für Claude-Builder​

Pro tip
  • Greife zu On-Device AFM 3 Core (3B): Zusammenfassung, Klassifizierung, Entitätsextraktion, On-Device-Rewrites, Tastaturvorschläge — alles, wo ein begrenzter Prompt und getypte Ausgabe einen Netzwerk-Roundtrip schlagen. Kostenlos.
  • Greife zu AFM 3 Core Advanced (20B): privates Reasoning, das das Gerät nicht verlassen darf (Gesundheit, Finanzen, unveröffentlichte Dokumente) und bei dem das 3B stolpert. Erwarte variable Latenz wegen NAND-Expert-Swap.
  • Greife zu Private Cloud Compute (Cloud / Cloud Pro): größerer Kontext, längeres Reasoning oder multimodal, wo das 20B On-Device nicht mithält, aber der Datenschutz Drittanbieter-APIs weiterhin ausschließt.
  • Bleibe bei Claude über die Anthropic-API (oder den neuen Swift-Paket-Anbieter): lange Agent-Läufe, Extended Thinking, Big-Context-Codebase-Arbeit und plattformübergreifende Apps, die dasselbe Modell auf Android und Web brauchen. Siehe die Foundations-Seite Claude vs. andere.
  • Wickle das On-Device-3B NICHT in eine JSON-Repair-Schleife: Es hat constrained decoding. Wenn deine Ausgabe nicht parst, ist das Schema falsch oder du hast @Generable übersprungen.

Querverweise​

Kurzer Check​

Check yourself

0/5
  1. Wie bringt AFM 3 Core Advanced ein 20B-Parameter-Modell auf ein iPhone?
  2. Was gibt dir das @Generable-Makro, was handgemachtes JSON-Prompting nicht gibt?
  3. Du willst Claude Sonnet 5 aus einer iOS-App aufrufen, die bereits das Foundation Models Framework für On-Device-Zusammenfassung nutzt. Was ist der WWDC26-native Weg?
  4. Welche Entwicklergruppe bekommt Private-Cloud-Compute-Aufrufe kostenlos aus dem Framework?
  5. Warum muss der Executor-`Configuration`-Typ `Hashable` sein?

Quellen & weiterführende Literatur​