Las App Intents son la nueva API de Apple hacia tu app

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 quedó registrada. 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 de iOS para registrar la hidratación: LogWaterIntent.swift, 80 líneas de AppIntent más un AppShortcutsProvider que declara tres variantes de frases para Siri. Ese archivo es ahora la superficie API más caliente que poseo.²

Aquí está la parte que tardé en 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 de 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 de Vision Pro) es un derivado de ese contrato. Foundation Models, el LLM en el dispositivo que se lanzó en iOS 26, expone un protocolo Tool separado para la invocación de 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 el idioma, 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 el 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 esquiva tu app y se va a un competidor.
• Apple lleva tres años diciéndonoslo. La nomenclatura (App Intents, App Shortcuts, Apple Intelligence) es a propósito. El contrato sube un nivel en el stack en cada WWDC.

Imagen de referencia del framework App Intents de la documentación de Apple Developer.⁵

Qué es realmente un 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 adelante con un condicional de meta-alcanzada/cantidad-restante. El código del 8 de febrero que está arriba es el que probé en el grifo de la cocina.)

Tres cosas aquí merecen nombrarse porque la mayoría de los “tutoriales de App Intents” pasan por encima de ellas.

El @Parameter es el esquema. La IA de Apple ve amount: Int con un valor predeterminado de 8. Cuando Siri analiza “registra 12 oz de agua” produce LogWaterIntent(amount: 12) e invoca a perform(). No hay parsing de cadenas por 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 le lee al usuario en voz alta. Si lo escribes mal, el usuario escucha una frase fea; si lo escribes 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) en 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 parser de NL de Apple más margen para coincidir con la forma en que el usuario habla, sin que tú mantengas 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.

Apple Intelligence enruta las solicitudes del usuario a través de App Intents para entregar funciones de IA en el dispositivo. Fuente: apple.com/apple-intelligence.

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

Las APIs de iOS vienen en dos formas. Algunas tratan de cómo tu app se dibuja a sí misma (UIKit, SwiftUI, Metal). Otras tratan de cómo tu app se integra con el sistema (esquemas de 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 podían ser invocadas por voz. La superficie era estrecha: una lista fija de dominios (mensajería, pagos, reservas de viajes) con esquemas estrictos.⁸
• iOS 12 (2018) amplió la superficie con Siri Shortcuts: cualquier app podía donar un NSUserActivity o un 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 nuevo desarrollo.⁹
• iOS 18 (2024) introdujo Apple Intelligence y comenzó a enrutar las solicitudes de Siri a través de App Intents siempre que fue posible. La función de “contexto personal” de Apple Intelligence lee de 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 la invocación de 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 las invocaciones directas al LLM. Los dos contratos corren en paralelo.⁴

El contrato ha estado extendiéndose hacia arriba en el stack en cada lanzamiento. Originalmente el consumidor de un App Intent era una persona tocando Shortcuts. Después la voz de Siri. Después Spotlight. Después 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 siguiendo el mismo arco en el lado de la IA: la superficie donde Apple está poniendo todas sus apuestas.

Qué cambia ahora que Foundation Models se ha 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: iPhone 15 / 15 Plus base.⁴¹²

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. Existe 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 un App Intent relevante no es alcanzable desde un comando de voz de Siri en su categoría. Apple Intelligence enruta frases como “Hey Siri, registra mi agua” 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 a un mercado donde los pesos de enrutamiento ya se han 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 de pionero en las declaraciones de intent se acumule del modo en que lo ha hecho para otras APIs de apuesta de plataforma de Apple (categorías de HealthKit, resultados ricos de Spotlight, tokens de Live Activities).

La personalización de Apple Intelligence lee de App Entities, no solo de intents. Un AppEntity declara “esta app tiene datos de 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 tiene declarada una BookEntity, tus datos son invisibles para las superficies de IA de Apple. Apple Intelligence no puede recuperar ni hacer referencia a 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 de componer por el sistema en una respuesta coherente. ProvidesDialog y ProvidesView no son una 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 logs de producción en Water me dicen tres cosas que debí haber hecho antes.

Lanza más intents de los que crees que necesitas. Lancé uno. Debí haber lanzado cuatro: LogWaterIntent, CheckTodaysProgressIntent, AdjustGoalIntent, ShowHistoryIntent. Cada uno corresponde a una frase de Siri que los usuarios realmente intentan (“¿cuánta agua he tomado hoy?” enrutada a la IA genérica de Apple en lugar de a los datos de mi app). Cada intent que falta es una consulta que Apple Intelligence enruta esquivándome.

La cadena de diálogo no es el cuerpo de un correo. 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 guiada por hechos: “8 oz registradas. Faltan 32 oz”. La superficie del Watch en particular trunca de forma agresiva. Un diálogo conversacional es una peor experiencia de usuario que un diálogo de hechos contundentes. Reescribí el mío en la semana 4.²

Las App Entities importan más de lo que pensaba. Tengo un modelo WaterEntry de SwiftData. También debería declarar una WaterEntryEntity: AppEntity más su WaterEntryQuery: EntityQuery acompañante para que Apple Intelligence pueda responder “muéstrame cuándo bebí agua ayer”. El bridging 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())")
    }
    @Property(title: "Amount") var amount: Int
    @Property(title: "Timestamp") 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 de Swift más el pegamento de fetch de SwiftData. Para hacer que las entradas individualmente afloren en Spotlight (de modo que los usuarios que buscan “agua” lleguen a la entrada correcta), conforma la entidad a IndexedEntity y dona actualizaciones de índice en las escrituras. Eso es lo que la canalización de Spotlight de Apple espera más allá de la simple exposición como 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 la 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 SwiftData es el dato, 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 un App Intent

La negativa es parte del diseño.

Si tu app es puramente de 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 (solo abrir la app en un contexto), pero si la única acción útil es “abrir la app”, el intent es sobrecarga. No lo lances solo por tener uno.

Si la acción depende de affordances de UI difíciles de abstraer (una herramienta de canvas multipaso compleja, una app de edición 3D), el parameterSummary requerido del intent degenerará en pseudo-lenguaje natural vago que nadie realmente dice. La frase de Siri “edita mi foto con la herramienta de desenfoque a una intensidad de 7” es técnicamente posible, pero ningún humano la pronunciará. La superficie del intent es un impuesto sin recompensa.

La regla correcta: un App Intent gana su lugar cuando existe una frase que un usuario diría naturalmente que dispara la acción. “Registra 8 oz de agua” es esa frase. “Aplica desenfoque gaussiano con sigma 2,4 a la capa 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

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 ellos. WWDC 2025 añadió Foundation Models junto a ellos como una superficie separada de invocación de 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: el App Intent tipado y declarativo es el contrato que las apps de terceros ahora firman con el sistema.

La mayoría de las apps de iOS todavía 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 extiendan (ya hoy a través de Siri, Spotlight, Shortcuts y los resúmenes de Apple Intelligence), las apps sin intents declarados probablemente se encontrarán fuera del grafo de enrutamiento. La superficie del pionero, en mi experiencia observando las otras apuestas de plataforma de Apple, se acumula.

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

Si lanzas una app de iOS en 2026 y no has declarado al menos un App Intent, a tu hoja de ruta le falta una línea. Añádela.

FAQ

¿Qué es un App Intent en el desarrollo de iOS?

Un 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 vía @Parameter, un resumen en lenguaje natural vía parameterSummary y un cuerpo perform() async que hace el trabajo y retorna un resultado estructurado. Siri, Spotlight, Shortcuts y Apple Intelligence de Apple pueden invocarlo. Foundation Models (el LLM en el dispositivo de Apple) usa un protocolo Tool separado para invocaciones directas de herramientas dentro de la app.

¿En qué se diferencia App Intents del antiguo INIntent?

App Intents (introducido en iOS 16, 2022) reemplazó 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 type-safe vía 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 un 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 target de despliegue depende de lo que importe el cuerpo de tu perform(). Las App Intents simples funcionan hasta iOS 16; las respaldadas por SwiftData necesitan iOS 17.

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

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

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

Foundation Models expone su propio protocolo Tool para invocaciones directas de 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 se queda con la superficie; la app que lo lanza más tarde encuentra que la superficie ya está enrutada hacia otro lado. Hace once semanas lancé uno en Water. La acumulación ya ha comenzado.

Más de la serie Apple Ecosystem

Este ensayo es el punto de entrada. Los otros cuatro cubren el resto del stack arquitectónico:

• Two Agent Ecosystems, One Shopping List: cómo Get Bananas expone los mismos datos a Apple Intelligence (App Intents) y a Claude Desktop (MCP) a través de un solo archivo JSON en iCloud Drive.
• Liquid Glass in SwiftUI: Three Patterns From Shipping Return: patrones de producción para la capa visual de iOS 26.
• Five Apple Platforms, Three Shared Files: la estrategia de envío multiplataforma, cuándo compartir código y cuándo bifurcar targets.
• HealthKit + SwiftUI on iOS 26: la capa de fuente de datos de los flujos de autorización, los tipos de muestra y la trampa que bloquea a los usuarios fuera de tu app.

O salta al hub completo: Apple Ecosystem Series. Para el contexto más amplio de iOS con agentes de IA, consulta la iOS Agent Development guide.

Referencias