Las App Intents son la nueva API de Apple para tu aplicación

La mañana del 8 de febrero de 2026, le pedí a Siri que registrara 8 oz de agua desde mi Apple Watch mientras tenía las manos bajo el grifo de la cocina. El agua se registró. El diálogo del reloj decía 32 oz restantes. No había tocado ninguna pantalla.¹

Once semanas antes, había añadido un solo archivo Swift a Water, mi app iOS de seguimiento de hidratación: LogWaterIntent.swift, 80 líneas de AppIntent más un AppShortcutsProvider que declara tres variantes de frase para Siri. Ese archivo es ahora la superficie API más caliente que poseo.²

Aquí está la parte que me llevó un tiempo interiorizar. Las App Intents no son una función de Siri. Son el contrato que las apps de terceros firman con Apple Intelligence, las superficies de IA del sistema que Apple comenzó a desplegar en iOS 18 y siguió construyendo a lo largo de iOS 26.³ Si lanzas una app iOS y todavía tratas las App Intents como una función de voz “agradable de tener”, estás interpretando mal lo que Apple ha construido. Las App Intents son la API que permite a la IA de Apple actuar como tu app en nombre del usuario. Todo lo demás (Siri, Spotlight, Shortcuts, los resúmenes de Apple Intelligence, las superficies del Watch y Vision Pro) deriva de ese contrato. Foundation Models, el LLM en el dispositivo que llegó con iOS 26, expone un protocolo Tool separado para llamadas a herramientas dentro de la app; corre en paralelo a las App Intents en lugar de a través de ellas.

TL;DR

• Las App Intents declaran lo que tu app puede hacer de forma tipada y estructurada que la IA de Apple puede invocar directamente. Son la API de uso de herramientas de Apple para apps de terceros.
• Un ejemplo real de producción: LogWaterIntent en Water. 80 líneas, escritura completa en SwiftData, sincronización con HealthKit, conversión de unidades según la configuración regional, respuesta de diálogo estructurada para Siri.
• iOS 26 añadió Foundation Models, el LLM en el dispositivo de Apple. Foundation Models expone su propio protocolo Tool para uso de herramientas dentro de la app; las App Intents siguen siendo la superficie canónica que Siri / Spotlight / Apple Intelligence invocan entre apps. Misma dirección, dos contratos paralelos.
• Una app sin App Intents en 2026 es invisible para Apple Intelligence. El tejido de IA enruta a través de tus intents declarados o rodea tu app hacia un competidor.
• Apple lleva tres años diciéndonos esto. La nomenclatura (App Intents, App Shortcuts, Apple Intelligence) es intencional. El contrato sube un nivel en la pila con cada WWDC.

Qué es realmente una App Intent

El código fuente completo de LogWaterIntent tal como se lanzó en el commit e398c58 el 8 de febrero de 2026:²

import AppIntents
import SwiftData

struct LogWaterIntent: AppIntent {
    static var title: LocalizedStringResource = "Log Water"
    static var description: IntentDescription = "Log a glass of water to your daily intake"

    @Parameter(title: "Amount", default: 8)
    var amount: Int

    static var parameterSummary: some ParameterSummary {
        Summary("Log \(\.$amount) oz of water")
    }

    func perform() async throws -> some IntentResult & ProvidesDialog {
        let container = try ModelContainer(for: WaterEntry.self, DailyLog.self, UserSettings.self)
        let context = ModelContext(container)

        let settingsDescriptor = FetchDescriptor<UserSettings>(
            predicate: #Predicate { $0.id == "user-settings" }
        )
        let settings = try context.fetch(settingsDescriptor).first ?? UserSettings()

        let amountMl: Double
        if settings.unitSystem == .imperial {
            amountMl = Double(amount) * 29.5735
        } else {
            amountMl = Double(amount)
        }

        let todayKey = DailyLog.todayKey()
        let logDescriptor = FetchDescriptor<DailyLog>(
            predicate: #Predicate { $0.dateKey == todayKey }
        )
        let log: DailyLog
        if let existing = try context.fetch(logDescriptor).first {
            log = existing
        } else {
            log = DailyLog(date: .now, goalAmount: settings.dailyGoal)
            context.insert(log)
        }

        let entry = WaterEntry(amount: amountMl)
        log.entries.append(entry)
        try context.save()

        if settings.healthKitEnabled {
            try? await HealthKitService.shared.logWater(amount: amountMl, date: entry.timestamp)
        }

        let unit = settings.unitSystem == .imperial ? "oz" : "mL"
        let totalDisplay = settings.formatAmount(log.totalAmount)
        return .result(dialog: "Logged \(amount) \(unit). Today's total: \(totalDisplay)")
    }
}

struct WaterShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: LogWaterIntent(),
            phrases: [
                "Log water in \(.applicationName)",
                "Add water in \(.applicationName)",
                "Drink water in \(.applicationName)",
            ],
            shortTitle: "Log Water",
            systemImageName: "drop.fill"
        )
    }
}

(La versión actual en producción de este archivo en Water itera el diálogo más con un condicional de meta-alcanzada/cantidad-restante. El código del 8 de febrero de arriba es el que probé en el grifo de la cocina.)

Tres cosas aquí merecen ser nombradas porque la mayoría de los “tutoriales de App Intents” las pasan por alto.

El @Parameter es el esquema. La IA de Apple ve amount: Int con un valor predeterminado de 8. Cuando Siri analiza “log 12 oz of water” produce LogWaterIntent(amount: 12) y llama a perform(). No hay análisis de cadenas en mi lado. El sistema de tipos es el esquema.⁵

parameterSummary es el reflejo en lenguaje natural del parámetro. Apple lo usa para renderizar la acción en la UI de Shortcuts, en el diálogo y, cada vez más, en los paneles de confirmación de Apple Intelligence. El resumen se lee en voz alta al usuario. Si lo haces mal, el usuario escucha una frase fea; si lo haces bien, la superficie se siente nativa.⁶

perform() retorna IntentResult & ProvidesDialog. Ese es el retorno estructurado: la superficie de IA recibe no solo éxito/fallo, sino una cadena de diálogo que el usuario escucha. Apple espera cada vez más ProvidesDialog, ProvidesView o ReturnsValue para que el resultado se componga en Siri, Spotlight, el Watch y (en iOS 26) la cadena de respuestas de Apple Intelligence.⁷

El bloque AppShortcutsProvider al final es lo que registra las frases de Siri. El token \(.applicationName) es donde Siri inserta “Water” automáticamente. Tres variantes de frase con el mismo intent le dan al analizador de NL de Apple más margen para coincidir con la formulación del usuario sin que tengas que mantener un diccionario de frases. El systemImageName es un nombre real de SF Symbols; así es como Spotlight, Shortcuts y Apple Intelligence renderizan el ícono de la acción.

Por qué esta es la API de iOS más importante desde SwiftUI

Las APIs de iOS vienen en dos formas. Algunas tratan sobre cómo tu app se dibuja a sí misma (UIKit, SwiftUI, Metal). Algunas tratan sobre cómo tu app se integra con el sistema (esquemas URL, Universal Links, Widgets). Las App Intents son una tercera forma: son cómo la IA de Apple usa tu app.

Vale la pena trazar la progresión.

• iOS 10 (2016) introdujo SiriKit Intents (INIntent), la primera vez que las apps de terceros pudieron ser direccionadas por voz. La superficie era estrecha: una lista fija de dominios (mensajería, pagos, reserva de viajes) con esquemas estrictos.⁸
• iOS 12 (2018) amplió la superficie con Siri Shortcuts: cualquier app podía donar un NSUserActivity o INIntent y esperar que Siri lo sugiriera.
• iOS 13 (2019) añadió el manejo de intents dentro de la app para que las apps pudieran responder a invocaciones de shortcuts sin pasar a la UI de Siri del sistema.
• iOS 16 (2022) introdujo el framework App Intents: tipado, declarativo, con @Parameter y AppShortcutsProvider. El predecesor INIntent quedó efectivamente reemplazado para nuevos desarrollos.⁹
• iOS 18 (2024) introdujo Apple Intelligence y comenzó a enrutar las solicitudes de Siri a través de App Intents siempre que fuera posible. La función de “contexto personal” de Apple Intelligence lee desde App Entities (la versión de datos de las App Intents).¹⁰
• iOS 26 (2025) introdujo el framework Foundation Models, el LLM en el dispositivo de Apple. Foundation Models expone un protocolo Tool separado para llamadas a herramientas dentro de la app. Las App Intents siguen siendo la superficie canónica entre apps para Apple Intelligence, mientras que Tool es la superficie dentro de la app para llamadas directas al LLM. Los dos contratos corren en paralelo.⁴

El contrato ha estado extendiéndose hacia arriba en la pila con cada lanzamiento. Originalmente, el consumidor de una App Intent era una persona tocando Shortcuts. Luego la voz de Siri. Luego Spotlight. Luego los resúmenes de Apple Intelligence. Ahora, las superficies del sistema respaldadas por LLM de Apple Intelligence las usan para actuar sobre las solicitudes del usuario. La superficie de App Intent que lances en 2026 es la que Apple Intelligence estará invocando en iOS 27, 28, 29.

El patrón anterior es lo que quiero decir cuando afirmo que las App Intents no son una función de Siri. Son la API de uso estructurado de herramientas para todo el tejido de IA de Apple. SwiftUI fue la API de UI más importante porque se convirtió en la única forma de escribir una app para visionOS, watchOS 10+ e iOS 17+. Las App Intents están trazando el mismo arco en el lado de la IA: la superficie donde Apple está poniendo todas sus apuestas.

Qué cambia ahora que Foundation Models ha sido lanzado

Foundation Models es el framework que se incluye en cada dispositivo elegible para Apple Intelligence. El corte de hardware es la misma lista de Apple Intelligence: iPhone 15 Pro y 15 Pro Max (A17 Pro), línea iPhone 16, línea iPhone 17, iPhone Air, iPhone 17e, iPad Pro con M1 o posterior, iPad Air con M1 o posterior, iPad mini con A17 Pro, Vision Pro con M2 o posterior, y Mac con M1 o posterior. Notablemente ausentes: el iPhone 15 base / 15 Plus.⁴¹²

La implicación: si las superficies del sistema de Apple (Siri, Spotlight, Apple Intelligence) llaman a tu app, lo hacen a través de App Intents y App Entities. No hay una API setSystemPrompt(...) para apps de terceros en el tejido de IA del sistema. Está el registro de intents. Foundation Models añade una superficie Tool paralela dentro de la app para los desarrolladores que quieran sus propias funciones de LLM en el dispositivo. El contrato entre apps (el que Apple Intelligence y Siri usan para encontrar tu app) corre a través de App Intents.

Tres consecuencias concretas para los desarrolladores de apps:

Una app sin una App Intent relevante no es alcanzable desde un comando de voz de Siri en su categoría. Apple Intelligence enruta frases como “Hey Siri, log my water” a las apps que han declarado primero el intent correspondiente. Lancé el intent de Water en febrero de 2026. Mi lectura de la dirección del framework: las apps de hidratación que lancen el intent en 2027 entrarán en un mercado donde los pesos de enrutamiento ya se habrán acumulado hacia los pioneros. La misma lógica aplica a listas de compras, registro de entrenamientos, entradas de calendario, búsquedas de fotos. Espero que la ventaja del primer movilizador en las declaraciones de intents se componga del modo en que lo ha hecho con otras APIs de apuesta de plataforma de Apple (categorías de HealthKit, resultados enriquecidos de Spotlight, tokens de Live Activities).

La personalización de Apple Intelligence lee desde App Entities, no solo desde intents. Una AppEntity declara “esta app tiene datos con esta forma.” Cuando el usuario pregunta “cuál fue el último libro que añadí a mi lista de lectura,” Apple Intelligence busca cada AppEntity que coincida con Book en cada app instalada. Si tu app tiene una lista de lectura y no hay un BookEntity declarado, tus datos son invisibles para las superficies de IA de Apple. Apple Intelligence no puede recuperar ni referenciar tus datos.¹¹

La forma de retorno IntentResult & ProvidesDialog es cada vez más importante. Apple Intelligence está componiendo los resultados de los intents en respuestas más largas en Siri, Spotlight y el Watch. Un perform() que solo retorna éxito sin un diálogo estructurado es más difícil para que el sistema lo componga en una respuesta coherente. ProvidesDialog y ProvidesView no son cortesía opcional; son cómo tu acción se convierte en una cita en la superficie de IA del usuario.

Qué construiría diferente

Once semanas de registros de producción en Water me dicen tres cosas que debería haber hecho antes.

Lanza más intents de los que crees que necesitas. Lancé uno. Debería haber lanzado cuatro: LogWaterIntent, CheckTodaysProgressIntent, AdjustGoalIntent, ShowHistoryIntent. Cada uno mapea a una frase de Siri que los usuarios realmente intentan (“how much water have I had today” enrutada a la IA genérica de Apple en lugar de a los datos de mi app). Cada intent ausente es una consulta que Apple Intelligence enruta alrededor de mí.

La cadena de diálogo no es el cuerpo de un email. Tenía ProvidesDialog desde el principio, pero mi diálogo inicial era prosa. El usuario que lo escucha a través de CarPlay o AirPods necesita una estructura corta, concreta y orientada a hechos: “8 oz logged. 32 oz to go.” La superficie del Watch en particular trunca agresivamente. El diálogo conversacional es una peor experiencia de usuario que el diálogo seguro de hechos. Reescribí el mío en la semana 4.²

Las App Entities importan más de lo que pensaba. Tengo un modelo SwiftData WaterEntry. También debería declarar un WaterEntryEntity: AppEntity más su acompañante WaterEntryQuery: EntityQuery para que Apple Intelligence pueda responder “show me when I drank water yesterday.” El puente mínimo:¹¹

struct WaterEntryEntity: AppEntity {
    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Water Entry"
    static var defaultQuery = WaterEntryQuery()
    var id: UUID
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(title: "\(amount) oz at \(timestamp.formatted())")
    }
    var amount: Int
    var timestamp: Date
}

struct WaterEntryQuery: EntityQuery {
    func entities(for identifiers: [UUID]) async throws -> [WaterEntryEntity] {
        // Fetch matching entries from SwiftData
    }
    func suggestedEntities() async throws -> [WaterEntryEntity] {
        // Recent entries Apple Intelligence can suggest
    }
}

Dos pequeños tipos Swift más el pegamento de fetch de SwiftData. Para hacer las entradas individualmente expuestas en Spotlight (de modo que los usuarios que busquen “water” caigan en la entrada correcta), conforma la entidad a IndexedEntity y dona actualizaciones de índice en las escrituras. Eso es lo que el pipeline de Spotlight de Apple espera más allá de la mera exposición de AppEntity.

La misma forma aplica en otras partes de mis apps. Get Bananas, mi app de listas de compras, ya tiene un SwiftData @Model ShoppingItem con @Attribute(.unique) var id: UUID, name, amount, section, isChecked, más un campo lastModified para sincronización con iCloud Drive.¹³ Envolverlo como ShoppingItemEntity: AppEntity y lanzar un par de intents (AddShoppingItem, CheckOffItem, ShowList) expondría la misma capa de persistencia a Apple Intelligence que Get Bananas ya expone a Claude Desktop a través de su servidor MCP .mcpb.¹⁴ Dos ecosistemas de LLM, dos contratos diferentes, la misma lista de compras. Esa es la tesis de los contratos paralelos como una sola app lanzada: el modelo de SwiftData es los datos, las App Intents son el contrato de Apple, MCP es el contrato de Anthropic, ambas superficies operan sobre la misma fuente de verdad.

Cuándo no lanzar una App Intent

La negativa es parte del diseño.

Si tu app es puramente impulsada por consumo (leer las fotos del usuario, mostrar noticias, reproducir audio) sin estado mutable del usuario, las App Intents pueden no tener nada que exponer. El framework de Apple soporta OpenIntent (simplemente abrir la app a un contexto), pero si la única acción útil es “abrir la app,” el intent es sobrecarga. No lances uno solo por tener uno.

Si la acción depende de affordances de UI que son difíciles de abstraer (una compleja herramienta de canvas multi-paso, una app de edición 3D), el parameterSummary requerido del intent degenerará en un pseudo-lenguaje-natural vago que nadie dice realmente. La frase de Siri “edit my photo with the blur tool at strength 7” es técnicamente posible, pero ningún humano la pronunciará. La superficie del intent es un impuesto sin recompensa.

La regla correcta: una App Intent gana su lugar cuando hay una frase que un usuario diría naturalmente que dispara la acción. “Log 8 oz of water” es esa frase. “Apply Gaussian blur with sigma 2.4 to layer 3” no lo es. Si las acciones de tu app se agrupan en el segundo patrón, los intents no son tu palanca de conversión.

La conclusión final

Durante tres años Apple ha estado señalando que el tejido de IA del sistema de iOS pasa por App Intents. WWDC 2024 añadió el enrutamiento de Apple Intelligence a través de ellas. WWDC 2025 añadió Foundation Models junto a ellas como una superficie separada de llamada a herramientas dentro de la app, dejando las App Intents como el contrato entre apps que Siri / Spotlight / Apple Intelligence siguen usando. Cada señal apunta en la misma dirección: la App Intent tipada y declarativa es el contrato que las apps de terceros ahora firman con el sistema.

La mayoría de las apps iOS aún tratan las App Intents como Siri Shortcuts: una función para lanzar si tienes tiempo. Mi lectura es que ese encuadre va a envejecer mal. A medida que las superficies del sistema de Apple Intelligence se extienden (ya a través de Siri, Spotlight, Shortcuts y los resúmenes de Apple Intelligence hoy), las apps sin intents declarados es probable que se encuentren fuera del grafo de enrutamiento. La superficie del primer movilizador, según mi experiencia observando otras apuestas de plataforma de Apple, se compone.

Water ha tenido LogWaterIntent lanzado durante once semanas. La cantidad de código que lanza una App Intent es lo bastante pequeña como para caber en un solo archivo. El costo de no lanzarla crece con cada lanzamiento de Apple Intelligence.

Si lanzas una app iOS en 2026 y no has declarado al menos una App Intent, tu hoja de ruta tiene un elemento ausente. Añádelo.

FAQ

¿Qué es una App Intent en el desarrollo iOS?

Una App Intent es una estructura Swift tipada y declarativa que expone una de las acciones de tu app a las superficies de IA del sistema de Apple. Declara parámetros mediante @Parameter, un resumen en lenguaje natural mediante parameterSummary y un cuerpo perform() asíncrono que hace el trabajo y retorna un resultado estructurado. Siri, Spotlight, Shortcuts y Apple Intelligence de Apple pueden invocarla. Foundation Models (el LLM en el dispositivo de Apple) usa un protocolo Tool separado para llamadas directas a herramientas dentro de la app.

¿En qué se diferencian las App Intents del antiguo INIntent?

Las App Intents (introducidas en iOS 16, 2022) reemplazaron a INIntent como el framework principal de intents de Apple. El framework más nuevo es totalmente nativo de Swift, usa property wrappers como @Parameter, soporta consultas de entidades con seguridad de tipos mediante AppEntity y es la superficie que Siri, Spotlight, Shortcuts y Apple Intelligence invocan. El antiguo INIntent aún tiene soporte, pero no recibe trabajo de nuevas funciones.

¿Necesito iOS 26 para lanzar una App Intent?

No. Las App Intents están disponibles desde iOS 16 en adelante. iOS 26 añade el framework Foundation Models junto a ellas, pero las declaraciones de App Intent en sí mismas funcionan en iOS 16+. El código de ejemplo de arriba usa SwiftData (iOS 17+), por lo que el objetivo de despliegue depende de lo que importe tu cuerpo perform(). Las App Intents simples funcionan hasta iOS 16; las respaldadas por SwiftData necesitan iOS 17.

¿Cuál es la diferencia entre una App Intent y una App Entity?

Una App Intent es una acción (verbo). Una App Entity son los datos que tu app conoce (sustantivo). LogWaterIntent es un intent. WaterEntry convertido en un tipo consultable es una entidad. Apple Intelligence usa ambos: los intents para realizar acciones, las entidades para recuperar y referenciar datos en las respuestas.

¿Cómo se relacionan las App Intents con la llamada a herramientas de Foundation Models?

Foundation Models expone su propio protocolo Tool para llamadas directas a herramientas de LLM dentro de la app. Las App Intents siguen siendo la superficie canónica entre apps que Apple Intelligence, Siri y Spotlight invocan. Misma dirección (uso de herramientas tipado y declarativo); dos contratos paralelos. Una app que quiera ser alcanzable por las superficies de IA del sistema lanza App Intents; una app que quiera invocar su propio LLM en el dispositivo con herramientas personalizadas lanza conformidades a Tool. Muchas apps lanzarán ambas.

Las App Intents no son una función. Son el contrato. La app que lanza el intent primero obtiene la superficie; la app que la lanza más tarde encuentra la superficie ya enrutada a otra parte. Hace once semanas lancé una en Water. La composición ya ha comenzado.

Referencias