Sviluppare con Apple Intelligence

flagship · app iphone per chi guida

Registra i tuoi giri, condividili in bellezza.

Traccia GPS, velocità, piega e meteo, registrati sulla strada e trasformati in un poster con la mappa. Nessun account, nessun server: tutto resta sul tuo iPhone.

Scopri Qroda ↗fatta per chi guida

Nel tempo libero sto sviluppando Qroda, un'app per iPhone che registra i giri in moto, e a un certo punto ho voluto capire cosa offre Apple agli sviluppatori per l'AI sui suoi dispositivi. Volevo la vista da Xcode, non quella del keynote: quali framework esistono, in cosa è bravo ognuno, quanto costa e dove sono i limiti.

Si è rivelato un buon momento per guardarci. Alla WWDC di giugno Apple ha detto di aver ricostruito Apple Intelligence da zero, e iOS 27 ne ha portato la maggior parte il 14 settembre: una nuova generazione di modelli, un framework Foundation Models che accetta immagini e può chiamare il modello server di Apple su Private Cloud Compute, Siri AI in beta e un nuovo framework, Core AI, che apre agli sviluppatori il motore dietro i modelli di Apple. Gli adapter personalizzati sono spariti, e l'API per generare immagini da codice è deprecata. Quasi tutto quello che si trova scritto su Apple Intelligence per sviluppatori descrive ancora iOS 26.

Così mi sono messo con la documentazione attuale, le sessioni della WWDC e le release note, l'ho ripercorsa un framework alla volta e ho scritto quello che avrei voluto leggere prima di cominciare. Come il mio post Google Cloud Networking 101, prova a coprire tutti i pezzi importanti in un unico posto: a cosa serve ognuno, quando usarlo e come si incastra con il resto. Dove Qroda usa qualcosa, racconto come lo usa.

Il post va più o meno dal meno al più impegnativo: i modelli e la piattaforma, le funzionalità che ottieni quasi gratis, il framework Foundation Models, Siri e App Intents, i framework specializzati e i modelli da far girare per conto tuo. Le funzionalità AI di Xcode hanno una breve sezione alla fine, perché quest'anno sono cambiate quanto il resto. Se le idee generali (prompting, output strutturato, tool, valutazioni) sono nuove per te, il mio post AI Engineering per Sviluppatori le spiega a prescindere dalla piattaforma.

Tutto quello che segue è aggiornato all'inizio di ottobre 2026, con iOS 27.0 e Xcode 27.

Cos'è oggi Apple Intelligence

Apple Intelligence è un insieme di modelli, più le funzionalità di sistema e i framework costruiti sopra. I modelli contano, perché decidono cosa puoi fare e su quale dispositivo.

I modelli

Alla WWDC Apple ha presentato la terza generazione dei suoi modelli foundation, che chiama AFM 3. Sono cinque:

Ogni dispositivo fa girare esattamente uno dei due modelli on-device, e non sei tu a scegliere. Core Advanced è un modello sparso che legge i pesi in streaming dalla memoria flash, e gira solo sui dispositivi più recenti con almeno 12 GB di memoria. Tutti gli altri hanno Core. In pratica il tuo codice deve funzionare con quello piccolo e approfittare di quello grande quando c'è.

L'altra novità del technical report è che i modelli sono stati costruiti "in collaborazione con Google e i suoi modelli Gemini", dopo un accordo annunciato dalle due aziende a gennaio. Nelle interviste dopo il keynote, i dirigenti di Apple sono stati attenti a dire che i modelli sono di Apple, addestrati da Apple e rifiniti usando output di Gemini, e che sotto Siri non c'è Gemini. Per uno sviluppatore l'effetto pratico è avere modelli migliori dietro le stesse API.

Private Cloud Compute

Private Cloud Compute (PCC) è il lato server di Apple per le richieste troppo grandi per il dispositivo, e arriva con promesse precise: le richieste sono elaborate senza stato, nessuno in Apple ha accesso privilegiato ai nodi in esecuzione, una richiesta non può essere indirizzata a un utente specifico, e Apple pubblica le immagini del software così che i ricercatori possano verificare cosa gira. Quest'anno PCC è uscito dai data center di Apple. AFM 3 Cloud Pro gira su GPU NVIDIA in Google Cloud, con confidential computing su GPU e CPU, e Apple dice che valgono le stesse garanzie.

Per gli sviluppatori conta di più che ora anche la tua app può chiamare PCC, e ci torno nella sezione su Foundation Models.

Dispositivi, lingue e paesi

Apple Intelligence gira su iPhone 15 Pro e successivi (compresi tutti gli iPhone 16 e 17), iPad mini con A17 Pro, iPad e Mac con M1 o successivi, e Vision Pro. Apple Watch Series 9 e successivi, Ultra 2 e successivi e SE 3 la ricevono quando sono abbinati a un iPhone supportato. Supporta 16 lingue, tra cui inglese, quasi tutte le principali lingue europee, cinese, giapponese e coreano, e la lingua del dispositivo e quella di Siri devono coincidere.

La copertura per paese non è uniforme. Nell'UE funziona la maggior parte delle funzionalità di Apple Intelligence, ma Siri AI non è disponibile su iPhone, iPad e Apple Watch, e nella Cina continentale Apple Intelligence non c'è proprio.

Con iOS 27 è cambiata una cosa senza troppo rumore: Apple Intelligence è attiva di default e non si può più spegnere del tutto. Il tuo codice deve comunque gestire i dispositivi non idonei e i modelli ancora in download, ma "l'utente l'ha disattivata" su iOS 27 non lo vedrai più.

Quello che ottieni quasi gratis

Alcune funzionalità di Apple Intelligence arrivano nella tua app senza alcun lavoro, le altre con un modifier o due. Parti da qui, perché il costo è quasi zero.

Writing Tools

Writing Tools (Strumenti di scrittura nell'interfaccia italiana) corregge, riscrive e riassume il testo, e compare automaticamente in ogni vista di testo standard. Il lavoro consiste soprattutto nel decidere dove non lo vuoi. In SwiftUI, .writingToolsBehavior(_:) accetta .automatic, .complete, .limited (suggerimenti in un pannello, senza riscrivere sul posto) o .disabled. Disattivalo negli editor di codice, nei campi di ricerca e ovunque una riscrittura non abbia senso.

Qroda lo attiva dove serve, nei campi per il nome di giri, percorsi, punti, pilota e moto, e lo lega allo stesso interruttore nelle Impostazioni che controlla l'altra funzionalità Apple Intelligence dell'app. Ognuno di quei campi usa .writingToolsBehavior(aiEnabled ? .automatic : .disabled), così l'interruttore spegne davvero tutto.

In UIKit puoi anche limitare i tipi di risultato con allowedWritingToolsResultOptions (testo semplice, testo formattato, elenchi, tabelle) e reagire all'inizio e alla fine di una sessione attraverso il delegate della vista di testo, che è il posto giusto per mettere in pausa la sincronizzazione o il salvataggio automatico. Se hai un motore di testo tuo, UIWritingToolsCoordinator ti permette di supportare Writing Tools senza UITextView, e iOS 27 ci aggiunge una presentazione per il controllo grammaticale.

Genmoji

Una Genmoji è un'immagine che si comporta come un carattere nel testo. Nel codice è un NSAdaptiveImageGlyph, che scala con il font attorno. Per accettarle, imposta supportsAdaptiveImageGlyph su una UITextView; da iOS 26 le accetta anche un TextEditor SwiftUI collegato a un AttributedString. La trappola è il salvataggio. Una Genmoji vive in una stringa con attributi, quindi se salvi testo semplice sparisce. Salva la stringa con attributi (AttributedString è Codable, e lato UIKit funziona RTFD), e usa il contentDescription del glifo come alternativa in testo semplice per ricerca, notifiche e accessibilità.

In iOS 27 le Genmoji vengono generate nel cloud dal modello di immagini ADM 3, e un'app può farne creare una direttamente presentando il pannello di Image Playground con lo stile emoji e un handler onAdaptiveImageGlyphCreation.

Image Playground

Image Playground genera immagini a partire da testo, foto e concetti estratti dai tuoi contenuti. Si entra dal pannello di sistema: passi uno o più concetti e un'immagine di partenza opzionale a .imagePlaygroundSheet(...), la persona rifinisce il risultato e tu ricevi l'URL di un file. Prima controlla supportsImagePlayground nell'environment, e copia il risultato fuori dalla sua posizione temporanea se vuoi tenerlo.

import ImagePlayground
import SwiftUI
 
struct CoverButton: View {
    @Environment(\.supportsImagePlayground) private var supportsImagePlayground
    @State private var isPresented = false
    let story: String
 
    var body: some View {
        Button("Create a cover") { isPresented = true }
            .disabled(!supportsImagePlayground)
            .imagePlaygroundSheet(
                isPresented: $isPresented,
                concepts: [.extracted(from: story, title: "Cover")]
            ) { url in
                saveCover(from: url)
            }
    }
}

Il concetto .extracted(from:title:) è quello utile: invece di scrivere tu un prompt, passi al sistema un pezzo dei tuoi contenuti e sceglie lui cosa disegnare.

Con iOS 27 qui è cambiato molto. La generazione è passata a un nuovo modello su Private Cloud Compute, quindi ora le immagini possono essere fotorealistiche o in qualsiasi stile (.any), con nuove opzioni per la dimensione dell'output e per modificare un'immagine esistente invece di generarne una nuova. C'è un limite di utilizzo giornaliero per persona, che iCloud+ alza, e l'interfaccia relativa la mostra il sistema al posto tuo. Le immagini generate portano un watermark invisibile SynthID. Lo stile ChatGPT aggiunto in iOS 26 c'è ancora, come provider esterno.

Un'API sta uscendo di scena. ImageCreator, che generava immagini da codice senza alcuna interfaccia, è deprecata in iOS 27, e Apple indica di usare al suo posto il pannello o ImagePlaygroundViewController. Se il tuo design si basava sul generare illustrazioni in silenzio, in background, va ripensato.

Le funzionalità senza API

Buona parte di Apple Intelligence non ha un'API per sviluppatori, ma vale la pena conoscerla perché tocca comunque la tua app. I riepiloghi di notifiche e mail riscrivono quello che la tua app invia, quindi le notifiche con il fatto importante all'inizio si riassumono meglio. Clean Up, Extend e Spatial Reframing in Foto, Image Wand in Note, Smart Reply, Call Context, Workout Buddy e le novità di Safari esistono solo a livello di sistema. Lo stesso vale per l'estensione ChatGPT, che permette a Siri e a Writing Tools di passare una richiesta a ChatGPT quando l'utente la attiva; è ancora l'unico modello di terze parti integrato nel sistema. Live Translation è un'eccezione parziale, perché le app di chiamata possono aderire alle chiamate tradotte; ne parlo nella sezione su Translation.

Il framework Foundation Models

Questo è il pezzo centrale per gli sviluppatori. Il framework Foundation Models, arrivato con iOS 26, dà alla tua app accesso diretto al modello on-device da Swift: niente server, niente chiave API, nessun costo per richiesta, e funziona offline. Con iOS 27 è diventato molto più di un wrapper attorno a un piccolo modello.

A cosa serve il modello on-device

Il modello on-device è piccolo, quindi pensalo come un buon elaboratore di testo più che come un chatbot. È bravo a riassumere, estrarre campi, classificare, assegnare tag, riscrivere e generare testi brevi a partire da contenuti che la tua app ha già. È scarso in conoscenza del mondo, ragionamenti lunghi e tutto ciò che richiede molto contesto. La sua finestra di contesto va da 4K a 8K token a seconda del dispositivo, e quel budget copre istruzioni, prompt, output dei tool e risposte insieme. Leggi la dimensione reale da SystemLanguageModel.default.contextSize invece di scriverla a mano nel codice, e usa tokenCount(for:) per misurare quello che stai per inviare.

È il tipo di lavoro che gli dà Qroda. Una funzionalità chiamata Il giro in parole scrive una frase su ogni giro, sotto il nome nella schermata di riepilogo, e un'introduzione di due frasi per ogni riepilogo mensile o di stagione, nella lingua del pilota. Per questo un modello piccolo basta e avanza, e siccome gira sul telefono, i dati del giro non lo lasciano mai.

Sessioni e generazione guidata

Parli con il modello attraverso una LanguageModelSession. Una sessione conserva la conversazione, così le domande successive hanno contesto. Le istruzioni, che scrivi tu, dicono al modello cos'è e come comportarsi, e il modello le mette davanti al prompt. Questo rende semplice la regola più importante: non mettere mai l'input dell'utente nelle istruzioni, solo nel prompt.

La funzionalità che rende il framework davvero pratico è la generazione guidata (guided generation). Invece di fare il parsing di testo libero, marchi un tipo Swift con @Generable, aggiungi descrizioni e vincoli con @Guide, e il framework permette al modello di produrre solo un'istanza valida di quel tipo:

import FoundationModels
 
@Generable
struct RideSummary {
    @Guide(description: "A short, friendly title for the ride")
    var title: String
 
    @Guide(description: "Highlights of the ride", .count(3))
    var highlights: [String]
 
    var character: RideCharacter
}
 
@Generable
enum RideCharacter {
    case relaxed, sporty, epic
}
 
let session = LanguageModelSession(
    instructions: "You summarize motorcycle rides from trip data. Be brief."
)
 
let summary = try await session.respond(
    to: "212 km in 4h10. Passes: Giau, Falzarego, Valparola. Max lean 41°.",
    generating: RideSummary.self
).content

Il modello non può restituire un campo mancante o un tipo sbagliato. Puoi anche fare streaming dell'output strutturato, e ogni snapshot è una versione parzialmente compilata del tuo tipo, comoda per le interfacce che si costruiscono mentre arriva la risposta. Le proprietà vengono generate nell'ordine in cui le dichiari, quindi metti in cima alla struct quelle che servono prima all'interfaccia. Quando la forma è nota solo a runtime, come un modulo progettato da un utente, DynamicGenerationSchema fa lo stesso lavoro senza un tipo a compile time.

Qualche dettaglio fa risparmiare tempo. Gli snapshot dello streaming contengono tutto il testo fin lì, quindi sostituisci invece di accodare. prewarm(promptPrefix:) carica il modello prima che l'utente prema invio. Una sessione gestisce una richiesta alla volta, e mandarne una seconda mentre la prima è in corso genera un errore. Per il campionamento, GenerationOptions accetta una modalità di campionamento e una temperatura tra 0 e 1; il campionamento greedy dà lo stesso output per lo stesso input, ed è quello che vuoi nei test.

Scrivere prompt per un modello piccolo

Il modello on-device vuole uno stile di prompt diverso dai grandi modelli cloud. Rende al meglio con un compito ristretto per richiesta. Se una funzionalità deve estrarre fatti, classificarli e poi scrivere qualcosa, falle diventare tre chiamate con i loro piccoli prompt invece di una lunga. I passi piccoli sono più facili per il modello e più facili da testare, e più avanti puoi sostituirne uno senza toccare gli altri.

Tieni le istruzioni brevi e semplici, e quando il formato dell'output conta, mostra uno o due esempi nelle istruzioni invece di descrivere il formato a parole. Lascia lavorare il tipo il più possibile: una descrizione @Guide precisa e un vincolo come .range o .count guidano il modello meglio di un'altra frase di istruzioni. Dai al modello i contenuti che gli servono invece di contare su quello che sa, perché la sua conoscenza del mondo è scarsa e può essere sbagliata. Tutto quello che invii, compresi i nomi delle proprietà e le descrizioni delle guide, deve essere in una lingua che il modello supporta.

Le istruzioni di Qroda mostrano quanto possono essere semplici. Il modello riceve il giro come poche righe brevi con un'etichetta, con ogni numero già formattato dall'app, e questo:

let instructions = """
    You write one short sentence about a motorcycle ride, addressed to the \
    rider, in \(languageName). Use only the facts you are given. \
    Never use digits; write any amount in words. \
    Do not use abbreviations. \
    No exclamation marks, no emoji, no quotation marks, no hashtags. \
    Warm and plain. \
    Reply with the sentence only.
    """

Lì dentro ci sono due scelte che contano. I numeri che il pilota vede arrivano sempre dall'app, nelle sue unità, quindi invece di fidarsi che il modello li copi correttamente, le istruzioni gli dicono di non scrivere cifre affatto. E le istruzioni restano in inglese ma nominano la lingua di destinazione, dopo un controllo con supportsLocale(_:), così la risposta segue la lingua del pilota senza un prompt per ogni lingua. Ogni giro ha anche una sessione nuova, così niente del prompt di un giro può finire nel successivo.

La generazione guidata è lo strumento giusto per l'output strutturato, ma l'output di Qroda è una sola frase, quindi usa un validatore. Una risposta vuota, più lunga di 160 caratteri (240 per un riepilogo), distribuita su più righe, che contiene una cifra o che ha più frasi di quelle richieste viene scartata, mai riparata. Se il modello ha ignorato "niente cifre", non mi fido nemmeno dei fatti che riporta. Un limite su maximumResponseTokens fa sì che una risposta fuori controllo fallisca il controllo sulla lunghezza invece di andare avanti.

Gli input lunghi richiedono un piano. Misurali con tokenCount(for:), e se un documento non ci sta, dividilo in pezzi, riassumi i pezzi e lavora sui riassunti. Poi testa il prompt come il codice: un insieme fisso di input, campionamento greedy perché i risultati siano ripetibili, e un modo per confrontare gli output quando cambi qualcosa. Il nuovo framework Evaluations di Apple, di cui parlo più avanti, è fatto esattamente per questo.

Tool calling

Il modello non conosce i dati del tuo utente né il meteo di oggi. I tool gli permettono di chiederli al tuo codice. Implementi il protocollo Tool con un nome, una descrizione e argomenti @Generable, passi i tool alla sessione, e il modello decide quando chiamarli:

struct FindRidesTool: Tool {
    let name = "findRides"
    let description = "Finds the user's recorded rides near a place."
 
    @Generable
    struct Arguments {
        @Guide(description: "A place, pass or road to search for")
        var place: String
    }
 
    func call(arguments: Arguments) async throws -> [String] {
        try await RideStore.shared.rides(near: arguments.place).map(\.title)
    }
}
 
let session = LanguageModelSession(
    tools: [FindRidesTool()],
    instructions: "Answer questions about the user's own rides."
)
 
let answer = try await session.respond(to: "When did I last ride the Stelvio?")

Il modello può chiamare un tool più volte, anche in parallelo, e tutto quello che un tool restituisce finisce nella finestra di contesto, quindi restituisci risultati brevi e pertinenti invece di record interi. In iOS 27 puoi anche forzare o vietare le chiamate ai tool per singola richiesta, con una modalità di tool calling (.allowed, .disallowed o .required).

Ora Apple fornisce anche qualche tool suo. Vision offre OCRTool e BarcodeReaderTool, che il modello può chiamare per leggere testo e codici nelle immagini che gli passi. Core Spotlight offre SpotlightSearchTool, che dà al modello il retrieval sull'indice Spotlight della tua app: la versione on-device della RAG. È adatto a funzionalità del tipo "rispondi a domande sulle mie note". La sessione di Apple su questo tool avverte che la configurazione predefinita può sforare il contesto più piccolo del modello on-device, quindi regola quanto recupera.

Immagini nel prompt

Il modello on-device ora accetta immagini. Aggiungi un Attachment dentro il prompt builder, a partire da un CGImage, un CIImage, un pixel buffer, un URL o una UIImage:

let session = LanguageModelSession(tools: [BarcodeReaderTool()])
 
let response = try await session.respond {
    "What's on this receipt? List the items and the total."
    Attachment(receiptImage)
}

Questo copre molto di quello che prima richiedeva una pipeline: descrivere una foto, confrontare due immagini, estrarre campi da uno screenshot. Insieme alla generazione guidata, da un'immagine a una struct tipizzata bastano poche righe. Per i documenti fitti, affiancagli il tool OCR invece di fidarti del modello sui caratteri piccoli.

Private Cloud Compute dalla tua app

PrivateCloudComputeLanguageModel mette il modello server, AFM 3 Cloud, dietro la stessa API delle sessioni, e passare a lui è una riga:

let model = PrivateCloudComputeLanguageModel()
let session = LanguageModelSession(model: model)
 
let response = try await session.respond(
    to: "Compare these three training plans and recommend one: ...",
    contextOptions: ContextOptions(reasoningLevel: .moderate)
)

Hai una finestra di contesto da 32K e il ragionamento, con livelli .light, .moderate o .deep (il modello on-device non ragiona). Non c'è una chiave API né una fattura. Ogni persona ha invece una quota giornaliera legata al suo account iCloud, che iCloud+ alza. Il modello espone quotaUsage, così puoi mostrare quando qualcuno è vicino al limite, e un limitIncreaseSuggestion che presenta le opzioni di upgrade di Apple.

Il problema è l'accesso. Serve un entitlement gestito, e per ora possono ottenerlo solo gli sviluppatori nell'App Store Small Business Program con meno di due milioni di primi download. Se superi quella soglia, hai sei mesi per smettere di usarlo. Apple dice che più avanti arriverà un accesso più ampio "a pagamento". Per gli sviluppatori indipendenti è una cosa grossa: un modello server capace, con le garanzie di privacy di Apple, a costo zero. Per tutti gli altri, per ora non è un'opzione.

Metti in conto che a volte fallisca. Le richieste a PCC hanno bisogno di rete, la disponibilità può essere .systemNotReady e la quota può finire, quindi progetta la funzionalità in modo che ripieghi sul modello on-device o su nessuna AI. Il modello server è disponibile anche su watchOS 27, ed è il modo di usare il framework su Apple Watch.

Portare il proprio modello

iOS 27 ha anche trasformato il framework in un'interfaccia comune. Tutto ciò che implementa il nuovo protocollo LanguageModel funziona con LanguageModelSession, comprese generazione guidata e tool. Anthropic pubblica un pacchetto Swift che ci porta Claude, Gemini è disponibile tramite Firebase, e sia Core AI sia MLX possono esporre modelli locali allo stesso modo. I profili dinamici permettono a una sessione di cambiare modello, livello di ragionamento e politica sui tool da una richiesta all'altra, e ogni risposta ora riporta l'uso dei token.

Come architettura, è la parte che trovo più utile. Scrivi la funzionalità su Foundation Models con la generazione guidata, usa il modello on-device quando basta, e passa a PCC o a un modello di terze parti per le richieste che chiedono di più, senza un secondo percorso nel codice.

On-device, PCC o il modello di qualcun altro

Con una sola API davanti a più modelli, sceglierne uno è soprattutto una decisione di prodotto, quindi conviene mettere nero su bianco i compromessi.

Il modello on-device è gratuito, funziona offline, risponde più in fretta una volta caldo e tiene i dati sul dispositivo, il che rende la storia sulla privacy facile da spiegare. I suoi limiti sono il contesto piccolo, l'assenza di ragionamento, la scarsa conoscenza del mondo e il fatto che esiste solo sui dispositivi con Apple Intelligence.

Private Cloud Compute mantiene le garanzie di privacy di Apple e non ti costa niente, e in più dà un contesto molto più grande e il ragionamento. Lo paghi con la dipendenza dalla rete, una quota giornaliera per persona e un entitlement per cui devi avere i requisiti.

Un modello di terze parti come Claude o Gemini è l'opzione più capace e funziona per qualsiasi sviluppatore, ma la chiave API, la fattura e un server o un proxy per tenere la chiave lontana dal dispositivo li porti tu. I dati dei tuoi utenti escono anche dalle garanzie di privacy di Apple e vanno a un'altra azienda, cosa che va scritta nella privacy policy e nei dettagli sulla privacy dell'App Store, e per cui vale la pena chiedere il permesso prima di inviare qualcosa di personale.

Un modello che fai girare tu con Core AI o MLX non ha quote e non dipende dalla rete né da un'altra azienda. Il costo salta fuori altrove: dimensione dell'app o download del modello, il lavoro per convertirlo e ottimizzarlo, e batteria e memoria sul dispositivo.

La mia scelta predefinita è il modello on-device per tutto quello che entra nel suo contesto, PCC per le richieste che non ci stanno se ho i requisiti, e un modello di terze parti solo quando nessuno dei due basta e la funzionalità vale la conversazione in più sulla privacy. Per Qroda basta il modello on-device, perché una frase su un giro non richiede né un grande contesto né ragionamento.

Disponibilità, limiti ed errori

Il modello non è sempre disponibile, quindi controlla prima di mostrare una funzionalità AI:

let model = SystemLanguageModel.default
 
switch model.availability {
case .available:
    print(model.variant.displayName, model.contextSize)
case .unavailable(.deviceNotEligible):
    // Hide the feature, or fall back to something without AI.
    break
case .unavailable(.modelNotReady):
    // Still downloading. Try again later.
    break
case .unavailable:
    break
}

variant ti dice se il dispositivo usa Core o Core Advanced, utile per decidere quanto contesto inviare. Nel simulatore, un'opzione dello scheme ti permette di simulare ogni stato di disponibilità, così puoi testare i fallback.

Con iOS 27 sono cambiati gli errori. Il vecchio GenerationError è deprecato a favore di LanguageModelError, i cui casi sono quelli da gestire nell'interfaccia: finestra di contesto piena, guardrail scattato, rifiuto del modello, richiesta scaduta, lingua non supportata o rate limiting. I rate limit colpiscono soprattutto le app che generano in background, e lì Apple consiglia di usare respond invece dello streaming. Quando una conversazione lunga riempie il contesto, la soluzione è aprire una nuova sessione da una trascrizione ridotta. Le trascrizioni sono Codable, quindi puoi anche salvarle e ripristinare una conversazione dopo il riavvio dell'app.

I guardrail sono attivi di default. Se la tua funzionalità trasforma contenuti scritti dalle persone stesse (riscrivere una pagina di diario, per esempio), l'impostazione permissiveContentTransformations riduce i falsi positivi.

In Qroda ogni errore è silenzio. Il narratore restituisce o testo validato o niente, quindi un modello non disponibile, un rifiuto, un contesto pieno e una risposta scartata all'interfaccia sembrano tutti uguali: la frase non c'è. L'unico file dell'app che importa FoundationModels sta dietro un piccolo protocollo, con un'implementazione che non scrive mai per iOS da 18 a 25 (il framework richiede iOS 26) e uno stub con frasi preconfezionate per le preview e i test dell'interfaccia. L'impostazione della funzionalità non compare proprio sui telefoni che non possono usarla. Le frasi vengono generate una volta sola, quando il riepilogo compare per la prima volta, e salvate con il giro; le introduzioni dei riepiloghi sono in cache con un'impronta dei loro numeri, delle unità e della lingua, così vengono riscritte solo quando cambia una di queste cose.

Gli strumenti, e la fine degli adapter

Gli strumenti sono diventati seri. In Xcode, la macro #Playground esegue i prompt in linea accanto al codice e mostra il conteggio dei token. Instruments ha un template Foundation Models per latenza e uso dei token. Il nuovo framework Evaluations ti permette di misurare la qualità di una funzionalità AI su un dataset. È il pezzo che adotterei per primo, perché senza non puoi sapere se una modifica al prompt ha aiutato. Fuori da Xcode, macOS 27 include un tool a riga di comando fm, c'è un SDK Python in beta, e Apple ha reso open source un pacchetto di utility che include un adapter chat-completions e gira su Linux.

Gli adapter personalizzati non ci sono più. Nel 2025 Apple permetteva agli sviluppatori di addestrarli per il modello on-device con un toolkit Python e un entitlement apposito, ma sono stati deprecati in iOS 26.4 e rimossi in iOS 27, e l'ultima versione del toolkit non supporta i nuovi modelli. Per i modelli personalizzati Apple ora indica Core AI. Il caso d'uso integrato .contentTagging, una versione del modello ottimizzata per tagging e classificazione, è ancora disponibile.

Siri, App Intents e Visual Intelligence

Il secondo modo in cui Apple Intelligence raggiunge la tua app è chiamandola. Passa tutto da App Intents.

Le basi di App Intents

Un App Intent descrive qualcosa che la tua app sa fare, e una volta che esiste, il sistema può eseguirlo da Siri, Comandi Rapidi, Spotlight, il tasto Azione, il Centro di Controllo e i widget:

import AppIntents
 
struct SaveSpotIntent: AppIntent {
    static let title: LocalizedStringResource = "Save a spot"
    static let supportedModes: IntentModes = .background
 
    func perform() async throws -> some IntentResult & ProvidesDialog {
        guard try await RideRecorder.shared.saveCurrentSpot() else {
            return .result(dialog: "No ride is recording.")
        }
        return .result(dialog: "Spot saved.")
    }
}

Aggiungi un AppShortcutsProvider con le frasi da pronunciare (che devono contenere il nome della tua app) e l'intent funziona senza che l'utente debba configurare nulla. Le app entity descrivono i tuoi dati, così gli intent possono riceverli come parametri e il sistema può cercarli. Se hai scritto intent tempo fa, nota che supportedModes ha sostituito openAppWhenRun, deprecato da iOS 26. Gli snippet, le piccole viste che un intent mostra come risultato, sono diventati interattivi in iOS 26, quindi uno snippet può avere pulsanti e interruttori che eseguono altri intent senza aprire l'app. Uno snippet è un intent a sé che restituisce una vista, può ricaricarsi dopo un'azione ed è limitato a 400 punti di altezza, il che lo tiene a una scheda e non a una schermata. Gli snippet non funzionano su tvOS, visionOS e watchOS. iOS 27 ha aggiunto gli intent di lunga durata, che superano il limite di 30 secondi e mostrano una Live Activity, più la cancellazione, nuovi tipi di parametro per durate e nomi di persone, e un modo più semplice per lanciare un errore con un messaggio tuo (AppIntentError(description:)).

Gli intent di Qroda sono pochi, eppure coprono molto. Inizia un giro, Termina il mio giro e Salva un punto sono App Shortcuts con frasi come "Inizia un giro in Qroda", quindi funzionano da Siri, Spotlight e Comandi Rapidi senza configurazione. Inizia un giro è anche un controllo del Centro di Controllo, che il tasto Azione può eseguire. Salva un punto è un LiveActivityIntent, quindi il pulsante sulla Live Activity del giro nella Dynamic Island lo esegue nel processo dell'app senza aprirla, e il suo messaggio riporta quello che è successo davvero (salvato, nessun giro in registrazione, GPS non ancora agganciato) invece di dichiarare sempre successo. Siccome Qroda supporta ancora iOS 18, gli intent che aprono l'app dichiarano sia openAppWhenRun sia, dietro un controllo di disponibilità, supportedModes.

Siri AI e App Schemas

Siri AI, la Siri personale basata su LLM che Apple aveva promesso nel 2024, è arrivata con iOS 27 in beta. Capisce il contesto personale da Messaggi, Mail e Foto, sa cosa c'è sullo schermo, può compiere azioni tra le app e risponde attingendo dal web. Mentre scrivo è solo in inglese, c'è una lista d'attesa e un limite di utilizzo giornaliero, e non è disponibile su iPhone, iPad e Apple Watch nell'UE, né in Cina.

Per le app di terze parti, oggi la porta d'ingresso a Siri AI sono gli App Schemas. Uno schema descrive un'azione standard in un dominio definito da Apple, e tu ci fai conformare un intent o un'entity con una macro, come @AppIntent(schema: .messages.sendMessage). I domini che arrivano a Siri sono Audio, Calendar, Camera, Clock, Mail, Maps, Messages, Notes, Phone, Photos, Reminders, Video, e la ricerca di sistema e in-app, e molti dei loro schemi sono nuovi in iOS 27. Un altro gruppo di domini (Books, Browser, Files, Journaling, Presentation, Reader, Spreadsheet, Whiteboard, Word processor) supporta Comandi Rapidi ma non Siri. Conformarsi a uno schema si presenta così:

@AppIntent(schema: .messages.sendMessage)
struct SendMessageIntent {
    var content: AttributedString?
    var destination: MessageDestination
    var subject: AttributedString?
    var attachments: [IntentFile]
    var audioMessage: IntentFile?
    var locations: [GeoToolbox.PlaceDescriptor]
    var links: [URL]
    var scheduledDate: Date?
 
    func perform() async throws -> some ReturnsValue<[MessageEntity]> {
        let sent = try await Messenger.shared.send(content, to: destination)
        return .result(value: sent)
    }
}

Lo schema fissa i parametri e il loro significato, ed è questo che permette a Siri di usare l'intent in modo affidabile; tu fornisci i tuoi tipi per la destinazione e per l'entity del messaggio, più il codice che fa il lavoro. Xcode aiuta: il completamento del codice suggerisce gli schemi per prefisso di dominio, e ti avvisa quando hai implementato solo una parte di un gruppo di schemi collegati, come inviare un messaggio senza poterne preparare una bozza.

Qualche altra novità di iOS 27 fa funzionare meglio gli schemi con Siri. Quando qualcuno fa qualcosa a mano nella tua app, puoi donare l'intent di schema corrispondente tramite IntentDonationManager, che insegna a Siri cosa fanno davvero le persone e ne migliora i suggerimenti. Le entity possono conformarsi a OwnershipProvidingEntity e dire se sono condivise o pubbliche, così Siri chiede conferma, con il contesto giusto, prima di modificare qualcosa che altre persone possono vedere. Un'entity che rappresenta una persona può convertirsi da e verso l'IntentPerson di sistema tramite IntentValueRepresentation, il che permette a Siri di portare un contatto da un'app all'altra. E le entity possono essere marcate come sincronizzabili, così una conversazione con Siri che le riguarda può continuare su un altro dispositivo.

Se la tua app rientra in uno dei domini di Siri, adottare gli schemi è il lavoro su Apple Intelligence più utile che puoi fare adesso. Se non rientra, lo sforzo ripaga comunque attraverso le tue entity, che sono la parte successiva. Qroda è nel secondo gruppo: nessuno dei domini di Siri descrive la registrazione di un giro, quindi il suo supporto a Siri sono le frasi degli App Shortcuts, e i suoi dati arrivano al sistema come entity indicizzate.

Consapevolezza dello schermo e indice semantico

Siri AI risponde a domande su cosa c'è sullo schermo e sui dati personali di una persona, ed entrambe le cose dipendono dalle informazioni che fornisce la tua app. In iOS 26, senza alcun lavoro, Siri può già inviare a ChatGPT uno screenshot o i contenuti condivisibili della tua app. In iOS 27 puoi essere preciso: annoti le viste con .appEntityIdentifier(_:), descrivi l'elemento principale con un NSUserActivity e annoti le collezioni, così Siri sa quale delle tue entity è sullo schermo invece di indovinarla dai pixel.

Per il contesto personale, le entity conformi a IndexedEntity e indicizzate con Core Spotlight finiscono nell'indice semantico in cui cerca Siri. Marcare le proprietà che contano con @Property(indexingKey:) le rende ricercabili, e iOS 27 aggiunge le annotazioni di entity sulle notifiche, così una notifica può puntare all'entity di cui parla. Tutto questo è anche ciò che fa funzionare bene la tua app in Spotlight e in Comandi Rapidi, quindi vale la pena farlo a prescindere da Siri.

In Qroda ogni giro salvato è una IndexedEntity. Spotlight ne mostra il nome, o il luogo in cui è avvenuto, con un sottotitolo come "Bormio · 24 set 2026", e toccare un risultato apre il giro tramite un OpenIntent. L'indice vive sul dispositivo, e conta, perché il nome di un giro e i suoi luoghi sono dati personali.

Visual Intelligence

Visual Intelligence (Intelligenza visiva nell'interfaccia italiana) permette di inquadrare qualcosa con la fotocamera, o di fare uno screenshot, e cercarlo nelle app. La tua app partecipa implementando una IntentValueQuery che riceve un SemanticContentDescriptor (etichette più i pixel) e restituisce le entity corrispondenti. Toccare un risultato lo apre nella tua app tramite un OpenIntent, e un pulsante "altri risultati" può passare la ricerca alla tua app con lo schema di Visual Intelligence. In iOS 27 la stessa API funziona su iPad e Mac. Se la tua app ha un catalogo di cose che le persone potrebbero fotografare (prodotti, piante, luoghi, ricambi), è un modo economico per farti trovare.

iOS 27 permette anche a Visual Intelligence di salvare quello che riconosce direttamente in Calendario, Contatti e Salute. Se la tua app legge già da EventKit, Contacts o HealthKit, quei dati ti arrivano senza nessuna riga di codice per Visual Intelligence.

Comandi Rapidi e Spotlight

Da iOS 26, l'app Comandi Rapidi (Shortcuts) ha un'azione Use Model che invia l'input al modello on-device, a PCC o a ChatGPT. Quando le entity della tua app ci passano dentro, vengono serializzate in JSON a partire dalle loro proprietà, quindi entity ben descritte danno risultati migliori. iOS 27 ha aggiunto modelli più recenti con recupero dal web e un inspector che mostra la trascrizione del modello.

Altre due novità di iOS 27 in Comandi Rapidi riguardano chi sviluppa app. Describe a Shortcut permette di scrivere in linguaggio naturale cosa si vuole e costruisce il comando a partire dagli intent che le app forniscono, quindi titoli chiari per gli intent e buone descrizioni dei parametri aiutano a decidere se le azioni della tua app ci finiscono dentro. E Comandi Rapidi ha guadagnato azioni di archiviazione che si sincronizzano via iCloud, più automazioni che partono quando qualcuno fa uno screenshot, usa la tastiera o riceve una notifica. Le entity archiviate hanno bisogno di identificatori stabili per sopravvivere a quella sincronizzazione, da controllare se gli ID delle tue entity vengono generati al volo.

Per testare tutto questo, Xcode 27 ha un framework AppIntentsTesting che esegue intent e query in un bundle di test dell'interfaccia. L'ordine suggerito da Apple è testare prima gli intent, poi Comandi Rapidi, poi Spotlight, e Siri per ultima.

I framework specializzati

Prima di Apple Intelligence c'era già una lunga lista di framework di ML on-device, e sono ancora lo strumento giusto più spesso di un LLM. Sono veloci e gratuiti, danno sempre la stessa risposta, e quasi tutti girano su molti più dispositivi di Apple Intelligence.

Vision

Vision analizza le immagini: riconoscimento del testo, struttura dei documenti, codici a barre, volti, pose del corpo e delle mani, salienza, estetica delle immagini e classificazione. Da iOS 18 ha una vera API Swift, in cui ogni richiesta è un tipo con un perform(on:) asincrono. iOS 26 ha aggiunto RecognizeDocumentsRequest, che restituisce la struttura di un documento (paragrafi, elenchi, tabelle e le loro celle, codici a barre) invece di righe di testo, più una richiesta che rileva una lente della fotocamera sporca. Leggere una tabella da una foto ora richiede poche righe:

import Vision
 
let request = RecognizeDocumentsRequest()
let observations = try await request.perform(on: imageData)
 
if let table = observations.first?.document.tables.first {
    for row in table.rows {
        print(row.map { $0.content.text.transcript }.joined(separator: " | "))
    }
}

Il testo di ogni cella arriva anche con i dati rilevati, come indirizzi email e numeri di telefono, così non devi estrarli tu.

iOS 27 ha aggiunto la segmentazione al tocco: GenerateIterativeSegmentationRequest riceve un punto, un riquadro o uno scarabocchio e restituisce una maschera che puoi rifinire, con il modello scaricato su richiesta. Vision fornisce anche i tool OCR e codici a barre per il framework Foundation Models, e ora gira anche su watchOS. Per leggere testo e documenti, Vision resta una scelta migliore che chiedere a un modello di leggere l'immagine.

Speech

SpeechAnalyzer, arrivato con iOS 26, ha sostituito la vecchia API di riconoscimento vocale per la maggior parte degli usi. È veloce, gestisce audio lunghi e gira interamente sul dispositivo. I modelli di trascrizione stanno nello storage di sistema, quindi non pesano sulla dimensione della tua app, e li gestisci tramite AssetInventory. Usa SpeechTranscriber sui dispositivi supportati, ripiega su DictationTranscriber altrove, e aggiungi SpeechDetector se vuoi elaborare solo il parlato. Il flusso è sempre lo stesso: crei un transcriber per una lingua, ti assicuri che i suoi asset siano installati, passi l'audio a uno SpeechAnalyzer e leggi i risultati come una sequenza asincrona di stringhe con attributi che portano i tempi, così puoi allineare il testo all'audio. Non è disponibile su watchOS. iOS 27 ha semplificato l'input audio, con provider che leggono direttamente da un AVAsset o da un dispositivo di acquisizione e un convertitore per i formati audio, che elimina buona parte del codice di contorno che serviva negli esempi più vecchi. SFSpeechRecognizer funziona ancora ma è archiviato tra le API legacy. E se ti servono solo i sottotitoli, AVKit in iOS 27 può generare sottotitoli in inglese per i video sul dispositivo, senza codice nella tua app.

Translation

Il framework Translation traduce il testo sul dispositivo con modelli linguistici scaricabili. .translationPresentation mostra l'interfaccia di traduzione di sistema, e TranslationSession traduce da codice, una stringa o un gruppo alla volta. iOS 26.4 ha aggiunto la scelta tra traduzione ad alta fedeltà e a bassa latenza, e la traduzione di stringhe con attributi, così la formattazione sopravvive. Translation non è disponibile su watchOS, tvOS e visionOS.

Live Translation, la funzionalità di sistema che traduce le chiamate mentre avvengono, ha una piccola API per le app di chiamata: attraverso CallKit o LiveCommunicationKit, un'app può dichiarare di supportare la traduzione audio, e al resto pensa il sistema.

Natural Language

Natural Language fa identificazione della lingua, tokenizzazione, tagging delle parti del discorso e delle entità, sentiment ed embedding, compresi embedding contestuali da un piccolo transformer. Non è cambiato da iOS 17 e non ne ha bisogno. Per riconoscere una lingua, dividere il testo o calcolare una similarità è più veloce ed economico di qualsiasi chiamata a un modello:

import NaturalLanguage
 
let recognizer = NLLanguageRecognizer()
recognizer.processString(text)
let language = recognizer.dominantLanguage

È anche un primo passo sensato prima di una chiamata a Foundation Models, perché puoi controllare che il testo sia in una lingua supportata dal modello prima di inviarlo.

Sintesi vocale, suoni e musica

AVSpeechSynthesizer legge il testo ad alta voce con le voci di sistema, SSML e, con il permesso, la Voce personale di una persona. Sound Analysis classifica l'audio con un classificatore integrato che riconosce più di 300 suoni, in file o dal vivo. Entrambi sono invariati e funzionano ovunque. La novità di iOS 27 è Music Understanding, che analizza un brano sul dispositivo per tonalità, tempo, struttura, strumenti e volume.

Far girare i tuoi modelli

Quando niente di integrato va bene, porti un modello tuo. È la parte cambiata di più con iOS 27, e ora la scelta dipende dal tipo di modello che hai.

Core AI

Core AI è nuovo in iOS 27 e disponibile su tutte le piattaforme Apple. È il framework di inferenza che fa girare i modelli on-device di Apple, aperto agli sviluppatori, ed è pensato per le architetture attuali: transformer, modelli di diffusione, segmentazione. Converti un modello PyTorch attraverso torch.export con il convertitore coreai-torch di Apple, lo comprimi con il pacchetto di ottimizzazione che lo accompagna e, se vuoi, lo compili in anticipo per una piattaforma. Nella tua app carichi il modello, ne prendi una funzione e la esegui, con supporto per modelli con stato come i modelli linguistici con una KV cache:

import CoreAI
 
// The first load specializes the model for this device and caches the result.
let model = try await AIModel(contentsOf: modelURL)
guard let classify = try model.loadFunction(named: "main") else { return }
 
var input = NDArray(shape: [1, 3, 224, 224], scalarType: .float32)
// Write the pixel data through input.mutableView(as: Float.self).
 
var outputs = try await classify.run(inputs: ["image": input])
let scores = outputs.remove("scores")?.ndArray

Il primo caricamento di un modello grande può richiedere un po', perché Core AI lo specializza per il dispositivo, quindi fallo prima che l'utente abbia bisogno del risultato. Un entitlement Background Inference permette ai task in background di usare il Neural Engine, e ci sono un'app di debug e un template di Instruments per il profiling.

Apple ha anche pubblicato un repository di ricette di export già pronte e pacchetti Swift, tra cui un pacchetto per modelli linguistici che si collega al framework Foundation Models. È così che un modello personalizzato o aperto finisce dietro la stessa API LanguageModelSession dei modelli di Apple. E se un modello ha bisogno di un'operazione che nessun framework fornisce, il supporto ai tensori di Metal ti permette di scriverla come kernel GPU.

Core ML e Create ML

Core ML non è deprecato. Apple ora lo posiziona per il machine learning tradizionale (tree ensemble, regressione, feature engineering su dati tabellari) e per le pipeline esistenti, e indirizza verso Core AI tutto ciò che ha un'architettura moderna. In iOS 27 non ha ricevuto nuove API. Create ML addestra ancora modelli per immagini, testo, suoni e dati tabellari su un Mac partendo da esempi etichettati, senza competenze di ML, ed è spesso tutto quello che serve per un classificatore personalizzato. Usa le sue API basate su DataFrame, perché quelle vecchie con MLDataTable sono deprecate.

MLX

MLX è il framework open source di Apple per gli array su Apple silicon, con front-end Python e Swift, memoria unificata e differenziazione automatica. È lo strumento per far girare modelli aperti su un Mac e farne il fine-tuning: mlx-lm scarica, esegue e adatta con LoRA la maggior parte degli LLM aperti, e mlx_lm.server li espone tramite un'API compatibile con OpenAI. MLX supporta i Neural Accelerator dei chip M5, e Apple ha riportato un time to first token fino a quattro volte più rapido rispetto a M4. Può anche distribuire inferenza e addestramento su più Mac via Thunderbolt 5. Per cominciare bastano due comandi:

pip install mlx-lm
mlx_lm.generate --model mlx-community/Llama-3.2-3B-Instruct-4bit \
  --prompt "Explain a KV cache in two sentences."

Punta mlx_lm.server allo stesso modello e hai un endpoint locale compatibile con OpenAI, che Xcode può usare come provider per la chat e che torna comodo per provare i prompt prima di portarli in un'app.

Lato app, mlx-swift-lm fa girare modelli linguistici e di visione dentro un'app, e la sua ultima versione collega i modelli MLX al framework Foundation Models. La mia regola pratica: MLX per sperimentare, fare fine-tuning e per le app Mac, Core AI quando un modello viene distribuito dentro un'app per iPhone.

L'AI dentro Xcode

Gli strumenti per costruire tutto questo sono cambiati altrettanto. Xcode 26 è arrivato con ChatGPT integrato, l'accesso con Claude e il supporto per qualsiasi provider con un'API chat-completions, compresi i modelli locali. Xcode 26.3, a febbraio, ha aggiunto il coding agentico con Claude Agent e Codex, ed esposto Xcode stesso come server MCP, così gli agenti che girano fuori da Xcode possono lavorare sul tuo progetto tramite xcrun mcpbridge. Per collegare Claude Code basta un comando:

claude mcp add --transport stdio xcode -- xcrun mcpbridge

Fa parte del mio setup, che ho descritto in Come uso davvero Claude Code. Xcode 26.6 ha aggiunto un agente Gemini e il supporto per l'Agent Client Protocol.

Xcode 27 porta gli agenti dentro l'editor: conversazioni accanto al codice, una modalità /plan, subagenti e plugin che raggruppano skill, tool MCP e agenti, con GitHub e Figma tra i primi. Funziona qualsiasi agente che parli l'Agent Client Protocol, compresi quelli locali, e macOS 27 aggiunge un controllo a livello di kernel su quali file possono toccare i sottoprocessi di un agente. Xcode 27 gira solo su Apple silicon.

Cosa usare e quando

Con tutto sul tavolo, la maggior parte delle decisioni si riduce a poche scelte predefinite:

• Testo nelle viste standard: Writing Tools, già presente. Disattivalo dove non c'entra.
• Immagini dai contenuti della tua app: il pannello di Image Playground, non ImageCreator.
• Riassunti, estrazione, classificazione e tagging: il framework Foundation Models con la generazione guidata, on-device.
• Leggere testo, documenti e codici: Vision, o i tool di Vision dentro una sessione Foundation Models.
• Contesto più grande o ragionamento: Private Cloud Compute se hai i requisiti, oppure un modello di terze parti tramite il protocollo LanguageModel.
• Ricerca e domande sui dati della tua app: indicizza le tue entity in Core Spotlight e usa il tool di ricerca Spotlight.
• Entrare in Siri: App Schemas se la tua app rientra in un dominio di Siri, più entity ben descritte e indicizzate e annotazioni sullo schermo in ogni caso.
• Trascrizione: SpeechAnalyzer.
• Traduzione: il framework Translation, e Live Translation per le chiamate.
• Identificazione della lingua, tokenizzazione e similarità: Natural Language.
• Un modello moderno personalizzato: Core AI. Un modello classico personalizzato: Core ML o Create ML. Sperimentare con modelli aperti su un Mac: MLX.

Conclusione

Apple Intelligence per sviluppatori è molto diversa da un anno fa. In iOS 26 era un piccolo modello on-device e una manciata di funzionalità di sistema. In iOS 27 è una piattaforma a strati: funzionalità di sistema che ottieni gratis, un framework per i modelli che copre il dispositivo, i server di Apple e i provider di terze parti, App Intents come porta d'ingresso a Siri, e Core AI sotto per i tuoi modelli. I framework specializzati ci sono ancora, e sono ancora la risposta giusta per molti problemi.

Se non ti porti a casa nient'altro: progetta per il modello on-device più piccolo e considera quelli più grandi un bonus. Usa la generazione guidata invece di fare il parsing del testo. Controlla la disponibilità e costruisci prima il fallback. Descrivi i dati della tua app come App Entities, perché Siri, Spotlight, Comandi Rapidi e Visual Intelligence li leggono tutti. E ricorda che Private Cloud Compute ora è un'opzione per i piccoli sviluppatori, con una quota al posto di una fattura.

Spero che questo post ti sia stato utile. Se hai domande o feedback, non esitare a farmelo sapere!