Apple Foundation Models: el framework de LLM en el dispositivo, explicado

El framework Foundation Models le da a una app acceso directo, gratuito y sin conexión al mismo gran modelo de lenguaje en el dispositivo que impulsa Apple Intelligence¹. Sin clave de API, sin factura por token, sin viaje de ida y vuelta a la red, sin datos que salgan del dispositivo. Para toda una categoría de funciones que antes implicaba un LLM en la nube y una revisión de privacidad, el costo ahora se redondea a cero. Lo que se cede es capacidad: el modelo en el dispositivo es pequeño, la ventana de contexto es finita y el framework traza líneas duras alrededor de lo que hará y lo que no. Conocer esas líneas es todo el juego.

Esta es la referencia del framework en sí: los tipos que de verdad llamas, la única función que lo hace valer la pena y el punto donde deberías detenerte y recurrir a algo más grande.

TL;DR

• LanguageModelSession es el punto de entrada. Creas una, llamas a respond(to:) y recibes texto. El contexto de varios turnos vive en la sesión; el trabajo de un solo turno recibe una sesión nueva cada vez².
• La generación guiada es la razón para usar este framework. Anota un tipo de Swift con @Generable y el modelo devuelve ese tipo, poblado y con tipos verificados, en lugar de una cadena que tienes que parsear³.
• El protocolo Tool permite que el modelo llame a tu código en plena generación para obtener datos o ejecutar una acción, y luego integre el resultado en su respuesta⁴.
• Consulta SystemLanguageModel.default.availability antes de hacer cualquier otra cosa. El modelo no está presente en dispositivos no elegibles, con Apple Intelligence desactivado o mientras se descarga⁵.
• La ventana de contexto es real y es pequeña. SystemLanguageModel.default.contextSize informa el presupuesto de tokens que comparten el prompt y la respuesta⁶. En el dispositivo ese presupuesto es de 4K tokens; el modelo de Private Cloud Compute lo eleva a 32K¹⁴. Planifica en consecuencia o la sesión lanzará un error.
• Requiere iOS 26 y un dispositivo compatible con Apple Intelligence. Por debajo de ese piso, el framework no existe. Las betas de iOS 27 amplían la misma API con entrada de imágenes, control de llamadas a herramientas por solicitud y un modelo de servidor en Private Cloud Compute¹²¹³¹⁴.

Qué es el framework y qué no es

Foundation Models no es un envoltorio sobre un endpoint en la nube. El modelo vive en el dispositivo, viaja con el sistema operativo y se ejecuta sobre el Neural Engine. Ese único hecho determina cada decisión de diseño de la API y cada decisión que tomes al usarla.

Lo que obtienes: generación de texto, resúmenes, clasificación, extracción, reescritura de textos breves y salida estructurada, todo en el dispositivo y todo gratis. Lo que no obtienes: un modelo de frontera. Apple construyó el modelo en el dispositivo para tareas de lenguaje acotadas dentro de una app, no para razonamiento abierto, ni para análisis de documentos largos, ni para conocimiento del mundo que puedas interrogar. Apple lo dice con todas sus letras, y el encuadre importa porque fija expectativas que, de otro modo, la API te dejará incumplir¹.

El modelo mental que te mantiene fuera de problemas: trata al modelo en el dispositivo como a un pasante rápido, privado y gratuito, excelente para dar forma al texto y pésimo para saber datos. Dale material y una tarea clara. No le hagas preguntas que no tiene manera de responder.

LanguageModelSession: el punto de entrada

Toda interacción empieza con una sesión.

import FoundationModels

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

La sesión guarda el estado de la conversación. Cada llamada a respond(to:) se suma a la transcripción en curso, de modo que una sesión que conservas recuerda lo que vino antes. Para una función de chat, eso es justamente lo que quieres. Para tareas independientes de un solo disparo (resume esto, clasifica aquello), crea una sesión nueva en cada llamada para que el contexto viejo no se filtre ni se coma tu presupuesto de tokens².

respond(to:) es async throws. Se suspende mientras el modelo trabaja y lanza un error cuando la solicitud excede la ventana de contexto, cuando el modelo no está disponible o cuando los filtros de seguridad rechazan el contenido. Cada uno de esos casos es una rama real que debes manejar, no un caso límite que puedas ignorar.

Para una UI que responda bien, usa streaming en lugar de esperar. streamResponse(to:) entrega salida parcial a medida que el modelo la produce, lo que convierte una pausa de tres segundos en texto que aparece mientras se forma⁷.

Generación guiada: la función que justifica el framework

Aquí está la parte que vale la entrada. La mayoría de las integraciones con LLM gastan un tercio de su código en sacarle JSON válido al modelo y los otros dos tercios en defenderse de las veces en que igual falla. Foundation Models elimina ese trabajo.

Anota un tipo de Swift con @Generable, pídele a la sesión que lo genere y el modelo devuelve una instancia de ese tipo, poblada y con seguridad de tipos³:

@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

Sin parseo. Sin JSONDecoder. Sin bucle de reintentos para salidas malformadas. La macro @Guide restringe campos individuales: una descripción que el modelo lee como instrucción y límites opcionales, como un rango numérico o una expresión regular con la que la salida debe coincidir⁸. El framework no le pide amablemente al modelo un número entre 5 y 240; restringe la decodificación para que el campo no pueda volver de otra forma.

La disciplina que impone es el valor real. Diseñas primero el tipo de salida, en Swift, con el compilador verificándolo. El modelo completa un contrato que tú definiste, en vez de devolver prosa a la que luego tienes que aplicar ingeniería inversa. Para extracción, llenado de formularios y cualquier función que convierta lenguaje en datos, la generación guiada es la diferencia entre una demo y código listo para producción.

Un control que conviene conocer: respond(to:generating:) deja includeSchemaInPrompt en true por defecto, lo que inyecta la forma de tu tipo en el prompt para sesgar al modelo hacia ella. Déjalo activado a menos que el modelo ya conozca el formato por su entrenamiento o por turnos anteriores de la sesión; desactivarlo para ahorrar tokens en un formato que el modelo nunca vio es la manera segura de recibir basura⁹.

Llamada a herramientas: dejar que el modelo alcance tu código

La generación guiada da forma a lo que sale. La llamada a herramientas cambia lo que entra. Una herramienta es una porción de tu código que el modelo puede invocar en plena generación para obtener información que no tiene o ejecutar una acción, y después continuar su respuesta usando el resultado⁴.

Una herramienta se ajusta al protocolo Tool: un name, una description que el modelo lee para decidir cuándo llamarla, un tipo Arguments marcado con @Generable y un método call(arguments:) que hace el trabajo⁴:

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.")

El flujo: el modelo decide que necesita contactos, llama a tu herramienta con un count validado, tú devuelves datos y el modelo redacta la invitación con nombres reales. Los argumentos llegan con los tipos ya verificados a través de la misma maquinaria de generación guiada, así que nunca tienes que deducir la intención del modelo a partir de texto libre. La descripción de la herramienta es tu única palanca sobre cuándo el modelo recurre a ella, así que escríbela como la documentación de una función que otro ingeniero, sin ningún contexto adicional, tiene que leer y usar correctamente.

Aquí está también el punto donde Foundation Models se une al resto de la historia de los agentes. Una herramienta a la que llama el modelo en el dispositivo y un App Intent¹¹ al que llama Apple Intelligence son superficies distintas con la misma forma: una capacidad con nombre, descripción y tipos. Diseña la capacidad una vez y podrás exponerla por ambas vías.

Disponibilidad: la verificación que no puedes saltarte

El modelo no siempre está ahí. Falta en dispositivos que no admiten Apple Intelligence, cuando el usuario lo tiene desactivado y durante el lapso en que el sistema operativo todavía descarga los recursos del modelo. Si publicas código que da por sentado que el modelo existe, ese código fallará, se degradará en silencio o se colgará para una parte de tus usuarios con la que nunca probaste.

Consulta SystemLanguageModel.default.availability y ramifica según la razón⁵:

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.
}

Las tres razones exigen tres respuestas de producto distintas, y confundirlas es la causa más común de que estas funciones se sientan rotas. deviceNotEligible es permanente: oculta la función, no insistas. appleIntelligenceNotEnabled es un ajuste que el usuario controla: un aviso único es razonable. modelNotReady es temporal: reintenta, no muestres un error. Construye la ruta de no disponibilidad con el mismo cuidado que la ruta feliz, porque para una porción real de dispositivos es el único camino.

Cuando el modelo está disponible y sabes que viene una solicitud, prewarm() sobre la sesión precalienta el modelo para que la primera respuesta real llegue más rápido¹⁰. Vale la pena en una pantalla donde el usuario está a punto de actuar; es un desperdicio si lo llamas de forma especulativa.

Manos a la obra: una función completa en un solo archivo

Las piezas anteriores se combinan en una función real con menos código del que la mayoría de las capas de red necesita para un solo endpoint. El ejemplo siguiente es una pantalla de SwiftUI completa y compilable que convierte notas de reunión en formato libre en tareas concretas y estructuradas: verificación de disponibilidad, tipo de salida @Generable, una llamada de generación guiada y las tres ramas de no disponibilidad ya manejadas. Cada símbolo proviene de la superficie del framework documentada arriba²³⁵⁸.

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."
        }
    }
}

Hay tres detalles que vale la pena notar en un ejemplo tan pequeño. El tipo de salida es la API: ActionItems define exactamente lo que produce la función, y la restricción @Guide sobre urgency significa que la cadena no puede volver con nada fuera de los tres valores permitidos⁸. La sesión se crea en cada llamada porque cada extracción es independiente; una sesión retenida arrastraría las notas previas al presupuesto de tokens². Y las ramas de no disponibilidad producen tres experiencias de usuario distintas, no un error genérico, que es la diferencia entre una función que se degrada con honestidad y una que parece rota. Pega el archivo en un proyecto de iOS 26, ejecútalo en un dispositivo compatible con Apple Intelligence y funciona.

La ventana de contexto y dónde deja de alcanzar

SystemLanguageModel.default.contextSize informa el presupuesto de tokens dentro del cual trabaja el modelo, y ese presupuesto es compartido: el prompt y la respuesta deben caber juntos⁶. La cifra es pequeña frente a la de un modelo en la nube, y se siente enseguida con entradas reales. Un documento largo, un historial de chat completo, un resultado de herramienta abultado: cualquiera de ellos puede reventar el presupuesto y hacer que respond lance un error.

De ahí se derivan dos modos de falla, y prevenir ambos te toca a ti. Primero, la acumulación lenta: una sesión de varios turnos junta transcripción hasta que un turno más la desborda. Contrólalo iniciando sesiones nuevas para trabajos no relacionados y manteniendo liviana la entrada de cada turno. Segundo, la solicitud única demasiado grande: un PDF de 20 páginas no cabe, punto. Divídelo en fragmentos, resume los fragmentos y luego razona sobre los resúmenes (el map-reduce que los ingenieros de LLM conocen bien), o acepta que la tarea tiene la forma equivocada para un modelo en el dispositivo.

La ventana de contexto es la señal más limpia para la decisión que de verdad importa con este framework: cuándo quedarse en el dispositivo y cuándo salir. Las cifras ya son públicas: el modelo en el dispositivo trabaja dentro de un presupuesto de 4K tokens, y el modelo de servidor de Private Cloud Compute lo eleva a 32K¹⁴. Todo lo dicho sobre fragmentación se aplica con esas cifras a la vista.

Qué agregan las betas de iOS 27

Todo lo anterior describe el framework tal como salió en iOS 26, y sigue vigente por completo. Las betas de iOS 27 extienden esa misma superficie en cuatro direcciones, y ninguna rompe el modelo mental de iOS 26¹².

El prompt acepta imágenes. El modelo en el dispositivo suma capacidades de Vision: insertas un adjunto de imagen en un prompt junto al texto y el modelo responde sobre ambos. Los tipos nuevos son Attachment, ImageAttachmentContent e ImageReference, y los adjuntos aceptan UIImage, NSImage, CGImage, tipos de Core Image, búferes de píxeles de CoreVideo y URLs de archivos¹²¹³. Las imágenes funcionan en cualquier tamaño y relación de aspecto, pero gastan del mismo presupuesto de tokens que tu texto, así que la ventana de 4K en el dispositivo se vuelve rápidamente la restricción de diseño¹³. El recorrido completo está en la entrada de imágenes en Foundation Models en iOS 27.

La llamada a herramientas gana un regulador. GenerationOptions suma un toolCallingMode que estableces por solicitud y que controla cómo interactúa el modelo con las herramientas que adjuntaste, y el framework Vision incluye implementaciones listas de OCRTool y BarcodeReaderTool que adjuntas a una sesión en lugar de escribir tu propio código de reconocimiento¹⁵. Los detalles de comportamiento están en el control de llamadas a herramientas en iOS 27.

Un modelo más grande, a una línea de distancia. PrivateCloudComputeLanguageModel ejecuta la misma API contra el modelo de servidor de Apple en Private Cloud Compute, detrás de un entitlement, con la ventana de contexto de 32K y un razonamiento que el modelo en el dispositivo no tiene¹²¹⁴. La generación guiada y las herramientas funcionan sin cambios; cambiar de modelo es el argumento model de la sesión.

Las sesiones ganan más superficie de control. Las betas agregan ContextOptions, TranscriptErrorHandlingPolicy, perfiles dinámicos (DynamicInstructions, LanguageModelSession.DynamicProfile) y un protocolo de proveedor de modelos de lenguaje personalizado (LanguageModel, LanguageModelExecutor) que permite que una sesión ejecute un modelo aportado por ti en lugar del del sistema¹². watchOS también se suma a la lista de plataformas en 27.0¹².

El encuadre que conviene retener: el código de iOS 26 compila y se comporta igual en iOS 27. Las betas amplían lo que un prompt puede transportar y dónde puede ejecutarse el modelo; no cambian lo que el framework es.

Cuándo no usar Foundation Models

El framework es gratuito, privado y funciona sin conexión, lo que lo vuelve tentador para todo. Resiste. Ve más allá de él cuando:

• Necesitas razonamiento de verdad o amplitud de conocimiento del mundo. El modelo en el dispositivo es pequeño por diseño. El razonamiento abierto, la generación de código y el análisis profundo le corresponden a un modelo de frontera en la nube. Pedírselos al modelo en el dispositivo produce respuestas seguras y equivocadas.
• La entrada no cabe en la ventana de contexto y fragmentarla destruiría el sentido. Algunas tareas necesitan verlo todo a la vez.
• Necesitas un modelo que controles: un checkpoint específico, un fine-tune, pesos propios, versionado determinista a lo largo de las actualizaciones del sistema. Apple publica y actualiza el modelo según su calendario, no el tuyo.
• Estás por debajo de iOS 26 o en un dispositivo no elegible. El framework sencillamente no está ahí, y la verificación de disponibilidad te lo dirá en cada ejecución.

Para los casos en el dispositivo que el framework no cubre (un modelo propio, tus propios pesos, entrenamiento en el dispositivo), las capas de más abajo son Core ML para un modelo fijo ya convertido, MLX para modelos de pesos abiertos y fine-tunes que te pertenecen, y Core AI en iOS 27 cuando necesitas control explícito sobre la especialización y la planificación. Para los casos que de verdad requieren escala, Private Cloud Compute o un LLM en la nube detrás de una frontera de privacidad sigue siendo la respuesta honesta. Foundation Models no reemplaza a ninguno de ellos. Es el primer recurso correcto para trabajo de lenguaje acotado sobre texto que ya tienes en la mano, y el recurso equivocado para todo lo demás.

La habilidad que este framework premia no es el arte de escribir prompts. Es el criterio sobre el alcance: darle al modelo tareas en las que es bueno, diseñar tipos @Generable que capturen exactamente lo que necesitas y reconocer el momento en que el trabajo supera al dispositivo. Construye con esos instintos y el modelo en el dispositivo hará una cantidad sorprendente de trabajo real sin costo alguno. Ignóralos y publicarás una función que se rompe para cada usuario cuya entrada se pasó por un token.

Preguntas frecuentes

¿El framework Foundation Models de Apple es gratuito?

Sí. El framework le da a una app acceso directo, gratuito y sin conexión al mismo modelo en el dispositivo que impulsa Apple Intelligence. No hay clave de API, ni factura por token, ni viaje de ida y vuelta a la red¹.

¿Qué dispositivos y qué versión de iOS requiere Foundation Models?

Requiere iOS 26 y un dispositivo compatible con Apple Intelligence. Por debajo de ese piso el framework no existe, y aun en un sistema compatible el modelo falta en dispositivos no elegibles, con Apple Intelligence desactivado o mientras el modelo se descarga. Consulta siempre SystemLanguageModel.default.availability antes de usarlo⁵.

¿Cómo obtengo salida estructurada y con seguridad de tipos en lugar de una cadena?

Anota un tipo de Swift con @Generable y el modelo devuelve ese tipo, poblado y con tipos verificados, en lugar de una cadena que tienes que parsear. Esta generación guiada es la única función que hace que el framework valga la pena³.

¿Cuál es la ventana de contexto del modelo en el dispositivo de Apple?

SystemLanguageModel.default.contextSize informa el presupuesto de tokens, que se comparte entre el prompt y la respuesta generada⁶. El modelo en el dispositivo ofrece 4K tokens; el modelo de Private Cloud Compute ofrece 32K¹⁴. Los documentos largos y los historiales extensos de varios turnos excederán el presupuesto en el dispositivo, así que planifica para ese límite o la sesión lanzará un error.

¿Foundation Models funciona sin conexión? ¿Envía datos a Apple?

Se ejecuta enteramente en el dispositivo, sobre el Neural Engine. Ningún dato sale del dispositivo y no se requiere ningún viaje de ida y vuelta a la red, que es justamente lo que lo vuelve adecuado para funciones que antes necesitaban un LLM en la nube y una revisión de privacidad¹.

¿El modelo en el dispositivo puede llamar a mi propio código en plena generación?

Sí. El protocolo Tool permite que el modelo invoque tu código para obtener datos o ejecutar una acción durante la generación, y luego integre el resultado en su respuesta⁴.

¿Cuándo no debería usar Foundation Models?

Ve más allá de él cuando necesites un modelo de frontera: razonamiento abierto, generación de código, análisis de documentos largos o conocimiento del mundo. Apple construyó el modelo en el dispositivo para tareas de lenguaje acotadas dentro de una app, de modo que pedirle inteligencia general produce respuestas seguras y equivocadas¹.

¿Qué agrega iOS 27 a Foundation Models?

Las betas de iOS 27 agregan entrada de imágenes (adjuntos en el prompt, creados a partir de UIImage, CGImage, búferes de píxeles y más), control de llamadas a herramientas por solicitud mediante GenerationOptions, herramientas de Vision listas para usar como OCRTool y BarcodeReaderTool, y PrivateCloudComputeLanguageModel para ejecutar la misma API contra el modelo de servidor de Apple con contexto de 32K^12131415. El código de iOS 26 sigue funcionando sin cambios.