Foundation Models w iOS 26 — kompletny przewodnik po on-device AI w Swift

Wprowadzenie — dlaczego Foundation Models to przełom dla deweloperów iOS

Wyobraź sobie, że dodajesz do swojej aplikacji inteligentne funkcje AI — podsumowywanie tekstów, ekstrakcję danych, generowanie treści, a nawet wywoływanie funkcji na podstawie języka naturalnego — bez płacenia za API, bez wysyłania danych użytkowników do chmury i bez potrzeby połączenia z internetem. Brzmi jak science fiction?

Od iOS 26 to rzeczywistość.

Na WWDC 2025 Apple zaprezentowało Foundation Models — framework udostępniający deweloperom model językowy (~3 miliardy parametrów) zasilający Apple Intelligence. Ten sam model, który napędza Writing Tools, sugestie Siri i inteligentne podsumowania w całym systemie, jest teraz dostępny bezpośrednio z poziomu kodu Swift. Przyznam, że gdy po raz pierwszy to zobaczyłem, byłem pod sporym wrażeniem — Apple naprawdę otworzyło drzwi do on-device AI dla zwykłych deweloperów.

W tym artykule przejdziemy przez cały framework od zera do poziomu zaawansowanego. Zaczniemy od sprawdzania dostępności modelu i prostego generowania tekstu, przez instrukcje systemowe i streaming odpowiedzi, aż po Guided Generation z makrami @Generable i @Guide oraz Tool Calling. Każdą sekcję zilustrujemy działającymi przykładami kodu.

Wymagania i konfiguracja

Zanim zaczniemy pisać kod, upewnijmy się, że mamy wszystko czego potrzebujemy:

• Xcode 26 lub nowszy
• macOS Tahoe (macOS 26) na Macu deweloperskim
• Urządzenie docelowe z iOS 26+, iPadOS 26+, macOS 26+ lub visionOS 26+
• Urządzenie obsługujące Apple Intelligence — czyli iPhone 15 Pro lub nowszy, iPad z chipem M1+ albo Mac z Apple Silicon
• Apple Intelligence włączone w Ustawieniach urządzenia

W projekcie Xcode wystarczy dodać jeden import:

import FoundationModels

I to tyle. Żadnych dodatkowych zależności, entitlementów (chyba że chcesz używać adapterów) ani konfiguracji — framework jest wbudowany w SDK. Miła odmiana po konfiguracji typowych SDK chmurowych, prawda?

Sprawdzanie dostępności modelu

Nie każde urządzenie obsługuje Apple Intelligence, a nawet na wspieranych urządzeniach użytkownik może mieć tę funkcję wyłączoną. Dlatego pierwszym krokiem w produkcyjnej aplikacji powinno być sprawdzenie dostępności modelu.

To w zasadzie obowiązkowy krok — bez niego ryzykujesz crash w runtime:

import FoundationModels

let model = SystemLanguageModel.default

switch model.availability {
case .available:
    print("Model jest dostępny — możemy generować!")
case .unavailable(let reason):
    switch reason {
    case .deviceNotEligible:
        print("To urządzenie nie obsługuje Apple Intelligence")
    case .appleIntelligenceNotEnabled:
        print("Użytkownik nie włączył Apple Intelligence w Ustawieniach")
    case .modelNotReady:
        print("Model jest w trakcie pobierania lub przygotowywania")
    default:
        print("Model niedostępny: \(reason)")
    }
}

W SwiftUI możesz to wykorzystać do warunkowego wyświetlania interfejsu:

struct ContentView: View {
    var body: some View {
        switch SystemLanguageModel.default.availability {
        case .available:
            ChatView()
        case .unavailable(.appleIntelligenceNotEnabled):
            Text("Włącz Apple Intelligence w Ustawieniach, aby korzystać z tej funkcji.")
        case .unavailable:
            Text("Twoje urządzenie nie obsługuje funkcji AI.")
        }
    }
}

Podstawowe generowanie tekstu — LanguageModelSession

Serce całego frameworku to klasa LanguageModelSession. Zarządza komunikacją z modelem, przechowuje historię konwersacji i udostępnia metody do generowania odpowiedzi.

Najprostszy możliwy przykład? Trzy linijki:

import FoundationModels

let session = LanguageModelSession()
let response = try await session.respond(to: "Wyjaśnij, czym jest protokół w Swift, w dwóch zdaniach.")
print(response.content)

Metoda respond(to:) jest asynchroniczna, więc musisz ją wywołać w kontekście async. Zwraca obiekt Response, którego właściwość content zawiera wygenerowany tekst.

Sesja jest stanowa. Każde kolejne wywołanie respond(to:) uwzględnia całą dotychczasową historię konwersacji, co oznacza, że możesz prowadzić wieloturowe rozmowy:

let session = LanguageModelSession()

let r1 = try await session.respond(to: "Podaj trzy popularne wzorce projektowe w iOS.")
print(r1.content)

let r2 = try await session.respond(to: "Opisz dokładniej pierwszy z nich.")
print(r2.content) // Model „pamięta" poprzednie pytanie

Ważne ograniczenie: model ma limit kontekstu wynoszący 4096 tokenów — obejmujący instrukcje, wszystkie prompty i odpowiedzi w sesji. To niewiele (szczególnie w porównaniu z modelami chmurowymi), więc planuj interakcje tak, aby zmieścić się w tym budżecie.

Instrukcje systemowe — definiowanie zachowania modelu

Chcesz, żeby model zachowywał się jak ekspert od SwiftUI? Albo odpowiadał wyłącznie po polsku? Do tego służą instrukcje — odpowiednik system prompt, który pewnie znasz z OpenAI czy Claude.

Instrukcje przekazujesz przy tworzeniu sesji:

let session = LanguageModelSession(instructions: """
    Jesteś ekspertem od programowania w Swift i SwiftUI.
    Odpowiadaj zawsze po polsku.
    Podawaj konkretne przykłady kodu.
    Odpowiedzi formułuj zwięźle — maksymalnie 3-4 zdania.
""")

Instrukcje są „niewidoczne" dla użytkownika, ale wpływają na każdą odpowiedź w sesji. To naprawdę potężne narzędzie do kształtowania tonu, stylu i zakresu odpowiedzi modelu — szczerze mówiąc, dobrze napisane instrukcje potrafią zrobić ogromną różnicę w jakości outputu.

W SwiftUI możesz użyć składni buildera:

struct AIAssistantView: View {
    @State private var session = LanguageModelSession {
        """
        Jesteś asystentem fitness. Pomagasz użytkownikom planować treningi
        i udzielasz porad żywieniowych. Odpowiadaj przyjaźnie i motywująco.
        """
    }

    // ... reszta widoku
}

Streaming odpowiedzi — responsywny interfejs użytkownika

Czekanie na pełną odpowiedź modelu może trwać kilka sekund. Zamiast wyświetlać spinner, możesz streamować odpowiedź token po tokenie — dokładnie tak, jak robią to ChatGPT czy Claude.

Zamiast respond(to:) użyj streamResponse(to:):

let session = LanguageModelSession()

let stream = session.streamResponse(to: "Napisz krótki wiersz o programowaniu w Swift.")

for try await partial in stream {
    // partial.content zawiera dotychczas wygenerowany tekst
    print(partial.content)
}

W SwiftUI wygląda to bardzo naturalnie:

struct StreamingView: View {
    @State private var session = LanguageModelSession()
    @State private var displayedText = ""
    @State private var isGenerating = false

    var body: some View {
        VStack {
            ScrollView {
                Text(displayedText)
                    .padding()
            }

            Button("Generuj") {
                isGenerating = true
                Task {
                    let stream = session.streamResponse(
                        to: "Podaj 5 porad dla początkujących deweloperów iOS."
                    )
                    for try await partial in stream {
                        displayedText = partial.content
                    }
                    isGenerating = false
                }
            }
            .disabled(isGenerating)
        }
    }
}

Dzięki streamingowi interfejs reaguje natychmiast — użytkownik widzi pojawiający się tekst w czasie rzeczywistym. To naprawdę robi różnicę w odczuciu responsywności aplikacji, zwłaszcza na starszych urządzeniach.

Guided Generation — ustrukturyzowane dane z makrem @Generable

No dobrze, a teraz przechodzimy do tego, co moim zdaniem jest najpotężniejszą funkcją całego frameworku. Zamiast otrzymywać od modelu surowy tekst i próbować go parsować (każdy, kto próbował parsować JSON z LLM, wie jak to potrafi frustrować), możesz zdefiniować typ Swift i kazać modelowi go wypełnić.

Model jest zmuszony na poziomie tokenów do generowania poprawnego wyjścia. To nie jest zwykłe „mam nadzieję, że JSON będzie poprawny" — to gwarancja strukturalna.

Mechanizm nazywa się Guided Generation i opiera się na makrze @Generable:

import FoundationModels

@Generable
struct PrzepisKulinarny {
    let nazwa: String
    let skladniki: [String]
    let czasPrzygotowania: Int
    let instrukcje: String
}

Makro @Generable generuje w czasie kompilacji schemat JSON dla Twojego typu. Gdy poprosisz model o wygenerowanie danych, framework użyje tego schematu do wymuszenia poprawnej struktury.

let session = LanguageModelSession()
let response = try await session.respond(
    to: "Podaj przepis na szarlotkę",
    generating: PrzepisKulinarny.self
)

let przepis = response.content
print(przepis.nazwa)              // np. "Klasyczna szarlotka"
print(przepis.skladniki)          // ["jabłka", "mąka", "cukier", ...]
print(przepis.czasPrzygotowania)  // np. 60
print(przepis.instrukcje)         // Krok po kroku...

Kluczowa zasada: wszystkie przechowywane właściwości typu @Generable muszą same być „generowalne". Obsługiwane typy bazowe to: String, Int, Double, Bool, tablice tych typów, opcjonale oraz inne typy oznaczone @Generable (czyli możesz zagnieżdżać struktury bez problemu).

Makro @Guide — precyzyjne sterowanie generowaniem

Makro @Guide pozwala jeszcze dokładniej ograniczać i instruować model przy generowaniu poszczególnych pól. Zobaczmy na przykładzie:

@Generable
struct RecenzjaFilmu {
    @Guide(description: "Tytuł filmu w oryginalnym języku")
    let tytul: String

    @Guide(description: "Krótkie podsumowanie w jednym zdaniu")
    let podsumowanie: String

    @Guide(.anyOf(["Akcja", "Komedia", "Dramat", "Horror", "Sci-Fi", "Animacja"]))
    let gatunek: String

    @Guide(description: "Ocena w skali 1-10", .range(1...10))
    let ocena: Int

    @Guide(description: "Lista trzech mocnych stron filmu", .count(3))
    let mocneStrony: [String]
}

let session = LanguageModelSession()
let recenzja = try await session.respond(
    to: "Napisz recenzję filmu Incepcja",
    generating: RecenzjaFilmu.self
).content

print(recenzja.gatunek)      // Gwarantowane: jedna z podanych opcji
print(recenzja.ocena)         // Gwarantowane: liczba 1-10
print(recenzja.mocneStrony)   // Gwarantowane: dokładnie 3 elementy

Dostępne ograniczenia w @Guide:

• .anyOf([...]) — wartość musi być jedną z podanych opcji
• .range(min...max) — wartość liczbowa w zadanym zakresie
• .count(n) — tablica o dokładnie n elementach
• description: — opis w języku naturalnym instruujący model
• Wzorce regex — ograniczanie formatu stringów za pomocą wyrażeń regularnych

Kolejność właściwości ma znaczenie

To detal, o którym łatwo zapomnieć. Model generuje wartości sekwencyjnie, właściwość po właściwości, w kolejności deklaracji w kodzie. Wartość pola zadeklarowanego później może więc zależeć od pól wygenerowanych wcześniej — ale nie odwrotnie.

Przykładowo, jeśli masz strukturę z polami temat i plan_lekcji, zadeklaruj temat jako pierwszy. Wtedy model wygeneruje plan lekcji, znając już temat.

Streaming ustrukturyzowanych danych

Guided Generation wspiera również streaming — dane przychodzą właściwość po właściwości:

let stream = session.streamResponse(
    to: "Podaj przepis na tiramisu",
    generating: PrzepisKulinarny.self
)

for try await snapshot in stream {
    // snapshot.content to częściowo wypełniony PrzepisKulinarny
    // Pola wypełniane są kolejno — od pierwszego do ostatniego
    print(snapshot.content)
}

Dzięki temu możesz aktualizować UI progresywnie, wyświetlając kolejne pola w miarę ich generowania. Użytkownik nie czeka na cały obiekt — widzi dane pojawiające się na żywo.

Tool Calling — model wywołuje Twoje funkcje

Model on-device nie wie, jaka jest aktualna pogoda, ile kosztuje bitcoin ani jakie dane ma Twoja aplikacja. Ale dzięki Tool Calling możesz dać mu dostęp do tych informacji — definiujesz narzędzia, a model sam decyduje, kiedy i które z nich wywołać.

Narzędzie to typ Swift implementujący protokół Tool:

import FoundationModels

struct PobierzPogodeTool: Tool {
    let name = "pobierzPogode"
    let description = "Pobiera aktualną pogodę dla podanego miasta"

    @Generable
    struct Arguments {
        @Guide(description: "Nazwa miasta, np. Warszawa")
        let miasto: String
    }

    func call(arguments: Arguments) async throws -> String {
        // Tu wywołujesz prawdziwe API pogodowe
        let pogoda = try await WeatherService.fetch(city: arguments.miasto)
        return "W \(arguments.miasto) jest \(pogoda.temperatura)°C, \(pogoda.opis)"
    }
}

Narzędzie rejestrujesz przy tworzeniu sesji:

let tools: [any Tool] = [PobierzPogodeTool()]

let session = LanguageModelSession(
    instructions: "Jesteś asystentem pogodowym. Używaj dostępnych narzędzi.",
    tools: tools
)

let response = try await session.respond(
    to: "Jaka jest pogoda w Krakowie?"
)
print(response.content)
// Model automatycznie wywoła PobierzPogodeTool z argumentem "Kraków"
// i użyje wyniku do sformułowania odpowiedzi

Co się dzieje pod spodem? W skrócie:

1. Model analizuje prompt i stwierdza, że potrzebuje danych pogodowych
2. Framework wywołuje metodę call(arguments:) Twojego narzędzia
3. Wynik wraca do modelu jako kontekst
4. Model generuje finalną odpowiedź, uwzględniając dane z narzędzia

Możesz definiować wiele narzędzi jednocześnie — model sam zdecyduje, które wywołać. Może nawet wywołać kilka sekwencyjnie w ramach jednego zapytania, co daje naprawdę ciekawe możliwości.

Narzędzia z kontekstem (od Xcode 26.1 beta)

Od wersji beta 26.1 możesz implementować alternatywną metodę call(arguments:context:), która daje dostęp do ToolCallContext — wrappera wokół transkryptu sesji. Dzięki temu narzędzie może uwzględnić pełną historię konwersacji przy generowaniu odpowiedzi. Przydatna opcja, choć na razie jest w fazie beta.

Prewarm — optymalizacja wydajności

Pierwsze wywołanie modelu w sesji może trwać dłużej, bo framework musi załadować model do pamięci. Żeby skrócić czas oczekiwania, możesz użyć mechanizmu prewarm:

struct ChatView: View {
    @State private var session = LanguageModelSession()

    var body: some View {
        VStack {
            // ... UI czatu
        }
        .onAppear {
            session.prewarm()
        }
    }
}

Wywołaj prewarm() w momencie, gdy wiesz, że użytkownik prawdopodobnie skorzysta z funkcji AI — np. przy wejściu na ekran czatu czy po kliknięciu przycisku „Generuj". Prewarm potrafi skrócić czas do pierwszego tokena nawet o 40%, co jest zauważalną różnicą.

Kiedy nie warto: jeśli aplikacja proaktywnie generuje sugestie bez akcji użytkownika, prewarm może nie przynieść korzyści — model i tak musi się załadować przed pierwszym wywołaniem.

Transkrypt sesji — debugowanie i monitorowanie

Każda sesja przechowuje pełen zapis interakcji we właściwości session.transcript. Znajdziesz tam instrukcje, każdy prompt, każdą odpowiedź i każde wywołanie narzędzia — wszystko w kolejności chronologicznej.

let session = LanguageModelSession(instructions: "Odpowiadaj krótko.")
_ = try await session.respond(to: "Czym jest SwiftUI?")

// Przeglądanie transkryptu
for entry in session.transcript.entries {
    print(entry)
}

To nieocenione narzędzie do debugowania — widzisz dokładnie, co model „widział", jakie narzędzia wywołał i jak sformułował odpowiedź. W produkcji możesz też użyć transkryptu do zbudowania interfejsu czatowego.

Praktyczny przykład — inteligentna aplikacja do nauki

Dobra, połączmy teraz wszystko w jednym, większym przykładzie. Zbudujemy asystenta do nauki, który generuje quizy z podanego tematu. To doskonale pokazuje siłę Guided Generation w praktyce.

import FoundationModels
import SwiftUI

// Struktury danych
@Generable
struct Pytanie {
    @Guide(description: "Treść pytania")
    let tresc: String

    @Guide(description: "Cztery możliwe odpowiedzi", .count(4))
    let odpowiedzi: [String]

    @Guide(description: "Indeks poprawnej odpowiedzi (0-3)", .range(0...3))
    let poprawnaOdpowiedz: Int
}

@Generable
struct Quiz {
    @Guide(description: "Temat quizu")
    let temat: String

    @Guide(description: "Lista 3 pytań", .count(3))
    let pytania: [Pytanie]
}

// Widok
struct QuizView: View {
    @State private var session = LanguageModelSession(instructions: """
        Jesteś nauczycielem programowania.
        Tworzysz quizy sprawdzające wiedzę z podanego tematu.
        Pytania powinny być zróżnicowane pod względem trudności.
    """)
    @State private var quiz: Quiz?
    @State private var isLoading = false

    var body: some View {
        NavigationStack {
            Group {
                if let quiz {
                    List {
                        ForEach(Array(quiz.pytania.enumerated()), id: \.offset) { index, pytanie in
                            Section("Pytanie \(index + 1)") {
                                Text(pytanie.tresc)
                                    .font(.headline)
                                ForEach(Array(pytanie.odpowiedzi.enumerated()), id: \.offset) { i, odp in
                                    HStack {
                                        Text(odp)
                                        if i == pytanie.poprawnaOdpowiedz {
                                            Spacer()
                                            Image(systemName: "checkmark.circle.fill")
                                                .foregroundStyle(.green)
                                        }
                                    }
                                }
                            }
                        }
                    }
                } else {
                    ContentUnavailableView(
                        "Wygeneruj quiz",
                        systemImage: "brain.head.profile",
                        description: Text("Kliknij przycisk poniżej")
                    )
                }
            }
            .navigationTitle(quiz?.temat ?? "Quiz AI")
            .toolbar {
                Button(isLoading ? "Generowanie..." : "Nowy quiz") {
                    generateQuiz()
                }
                .disabled(isLoading)
            }
        }
        .onAppear { session.prewarm() }
    }

    private func generateQuiz() {
        isLoading = true
        Task {
            do {
                let response = try await session.respond(
                    to: "Stwórz quiz o podstawach Swift Concurrency",
                    generating: Quiz.self
                )
                quiz = response.content
            } catch {
                print("Błąd generowania: \(error)")
            }
            isLoading = false
        }
    }
}

Zwróć uwagę na siłę Guided Generation w tym przykładzie — zamiast parsować tekst, dostajesz gotowy obiekt Swift z gwarantowaną strukturą: dokładnie 3 pytania, każde z dokładnie 4 odpowiedziami i indeksem poprawnej odpowiedzi w zakresie 0-3. Żadnego ręcznego parsowania, żadnych niespodzianek.

Ograniczenia i dobre praktyki

Foundation Models to potężne narzędzie, ale (jak wszystko w programowaniu) ma swoje ograniczenia. Warto je poznać zanim zaczniesz budować coś większego.

Ograniczenia

• Kontekst 4096 tokenów — łączny limit na instrukcje, prompty i odpowiedzi w sesji. Przy dłuższych konwersacjach musisz tworzyć nowe sesje
• Nie nadaje się do wszystkiego — Apple wprost odradza używanie modelu do generowania kodu, obliczeń matematycznych i pytań faktograficznych
• Brak fine-tuningu — nie możesz bezpośrednio dostosować modelu. Zachowanie kształtujesz przez instrukcje, Guided Generation i Tool Calling
• Jedna odpowiedź na raz — w ramach jednej sesji nie da się wywoływać respond równolegle. Potrzebujesz wielu sesji do równoległych zapytań
• Zależność od urządzenia — wymaga Apple Silicon i włączonego Apple Intelligence, co wciąż wyklucza spory procent użytkowników

Dobre praktyki

• Najpierw prompt engineering — zanim rozważysz adaptery czy złożone rozwiązania, optymalizuj instrukcje i prompty. Często wystarczy precyzyjniejsze sformułowanie, żeby dostać znacznie lepsze wyniki
• Kontroluj długość odpowiedzi — dodaj do instrukcji frazy typu „odpowiedz w dwóch zdaniach" lub „wymień maksymalnie 5 elementów"
• Używaj Guided Generation — gdy potrzebujesz ustrukturyzowanych danych, zawsze preferuj @Generable zamiast parsowania tekstu
• Zwracaj uwagę na kolejność pól — w typach @Generable deklaruj pola w logicznej kolejności, od ogólnych do szczegółowych
• Prewarm w idle time — ładuj model z wyprzedzeniem, gdy wiesz, że użytkownik go potrzebuje
• Testuj z Playgrounds — użyj makra #Playground w Xcode 26, żeby szybko eksperymentować z promptami bez kompilowania całej aplikacji
• Graceful degradation — zawsze sprawdzaj dostępność i zapewnij alternatywny UI dla urządzeń bez Apple Intelligence

Foundation Models vs. rozwiązania chmurowe — kiedy co wybrać

Foundation Models nie zastępuje OpenAI API, Claude ani innych rozwiązań chmurowych. To komplementarne narzędzie z zupełnie innymi zaletami:

Aspekt	Foundation Models (on-device)	API chmurowe (np. OpenAI, Claude)
Prywatność	Dane nigdy nie opuszczają urządzenia	Dane wysyłane na serwery zewnętrzne
Koszt	Bezpłatne, bez limitów	Płatne za token/zapytanie
Internet	Nie wymaga	Wymaga
Latencja	~0.6ms per token promptu, ~30 tok/s generowania	Zależna od sieci
Możliwości	~3B parametrów — krótkie zadania	Modele 100B+ — złożone rozumowanie
Kontekst	4096 tokenów	128K-200K+ tokenów
Fine-tuning	Tylko adaptery (z ograniczeniami)	Pełne fine-tuning API

Najlepsza strategia? Podejście hybrydowe. Używaj Foundation Models do szybkich, prywatnych zadań — ekstrakcja danych, klasyfikacja, krótkie podsumowania, sugestie UI. A API chmurowe zostaw na złożone rozumowanie, długie konwersacje i zadania wymagające aktualnej wiedzy o świecie. W mojej praktyce sprawdza się to znakomicie.

Najczęściej zadawane pytania (FAQ)

Czy Foundation Models wymaga połączenia z internetem?

Nie. Model działa w pełni on-device — na procesorze, GPU i Neural Engine urządzenia. Nie wymaga internetu, nie wysyła danych do chmury i nie generuje żadnych kosztów API. Jedyny warunek: urządzenie musi obsługiwać Apple Intelligence i mieć ją włączoną.

Na jakich urządzeniach działa Foundation Models?

Framework wymaga iOS 26+, iPadOS 26+, macOS 26+ lub visionOS 26+ na urządzeniach z Apple Silicon. Dla iPhone'a to model 15 Pro lub nowszy, dla iPada i Maca — chip M1 lub nowszy. Użytkownik musi też mieć włączone Apple Intelligence w Ustawieniach, a funkcja musi być dostępna w jego regionie.

Czy mogę fine-tunować model Apple do mojej aplikacji?

Bezpośredni fine-tuning nie jest możliwy. Apple oferuje jednak mechanizm adapterów — lekkich nakładek LoRA modyfikujących zachowanie modelu. Wymagają specjalnego entitlementu, Maca z Apple Silicon i 32 GB+ RAM do trenowania. Co ważne, adaptery trzeba retrenować przy każdej aktualizacji bazowego modelu. Dla większości zastosowań wystarczą instrukcje systemowe, Guided Generation i Tool Calling.

Jaki jest limit kontekstu modelu on-device?

Maksymalnie 4096 tokenów na sesję — obejmujących instrukcje systemowe, prompty użytkownika i wygenerowane odpowiedzi. To znacznie mniej niż modele chmurowe (128K-200K+). Dla dłuższych interakcji twórz nowe sesje lub po prostu optymalizuj prompty pod kątem zwięzłości.

Czy Foundation Models nadaje się do generowania kodu lub obliczeń matematycznych?

Apple oficjalnie odradza takie zastosowanie. Model ~3B parametrów jest zoptymalizowany pod kątem rozumienia języka naturalnego, ekstrakcji danych, klasyfikacji, podsumowań i generowania krótkich treści. Do złożonych zadań programistycznych lub matematycznych zdecydowanie lepiej sprawdzą się większe modele chmurowe.