App Intents son la nueva API de Apple hacia tu app

En 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 una pantalla.¹

Once semanas antes había añadido un único 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 de API más caliente que poseo.²

Aquí está la parte que me tomó un rato interiorizar. Los App Intents no son una función de Siri. Son el contrato que las apps de terceros firman con Apple Intelligence, la IA del sistema que Apple empezó a desplegar en iOS 18 y siguió construyendo hasta iOS 26.³ Si lanzas una app de iOS y todavía tratas los App Intents como una función de voz que está “bien tener”, estás malinterpretando lo que Apple ha construido. Los 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 del Vision Pro) deriva de ese contrato. Foundation Models, el LLM en el dispositivo que llegó con iOS 26, expone un protocolo Tool aparte para la llamada de herramientas dentro de la app; corre en paralelo a los App Intents en lugar de pasar por ellos.

TL;DR

• Los 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 el uso de herramientas dentro de la app; los App Intents siguen siendo la superficie canónica que Siri / Spotlight / Apple Intelligence invocan a través de las 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 y va hacia un competidor.
• Apple nos lo ha estado diciendo durante tres años. La nomenclatura (App Intents, App Shortcuts, Apple Intelligence) es intencional. El contrato sube un nivel en la pila con 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 de producción actual de este archivo en Water itera el diálogo aún más con un condicional de meta-alcanzada/cantidad-restante. El código lanzado el 8 de febrero que aparece arriba es el que probé en el grifo de la cocina.)

Hay tres cosas aquí que vale la pena nombrar 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 por defecto de 8. Cuando Siri interpreta “log 12 oz of water” produce LogWaterIntent(amount: 12) e invoca perform(). No hay análisis de cadenas de mi lado. El sistema de tipos es el esquema.⁵

parameterSummary es el reflejo en lenguaje natural del parámetro. Apple lo usa para representar 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 aciertas mal, el usuario escucha una frase fea; si lo aciertas bien, la superficie se siente nativa.⁶

perform() devuelve IntentResult & ProvidesDialog. Ese es el retorno estructurado: la superficie de IA no solo recibe éxito/fracaso, 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 respuesta 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 lenguaje natural de Apple más margen para emparejar la forma de hablar 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 representan el ícono de la acción.

Apple Intelligence enruta las solicitudes del usuario a través de los App Intents para ofrecer 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 sobre cómo tu app se dibuja a sí misma (UIKit, SwiftUI, Metal). Otras tratan sobre cómo tu app se integra con el sistema (esquemas de URL, Universal Links, widgets). Los App Intents son una tercera forma: son la manera en que la IA de Apple usa tu app. Esas superficies de widgets y de Control Center son, en sí mismas, superficies de App Intents, el mismo intent representado en muchos lugares, algo que rastreo en La superficie de widgets de iOS 26.

Vale la pena trazar la progresión.

• iOS 10 (2016) introdujo los SiriKit Intents (INIntent), la primera vez que se podía dirigir a las apps de terceros 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 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 las invocaciones de shortcuts sin pasar a segundo plano hacia 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 el desarrollo nuevo.⁹
• iOS 18 (2024) introdujo Apple Intelligence y empezó a enrutar las solicitudes de Siri a través de los App Intents siempre que era posible. La función de “contexto personal” de Apple Intelligence lee de los App Entities (la versión de datos de los App Intents).¹⁰ iOS 27 lleva esto más lejos con los App Schemas, que permiten a Siri razonar sobre tus entidades y actuar sobre ellas en términos que ya comprende, sin frases de entrenamiento, explicado aquí.
• iOS 26 (2025) introdujo el framework Foundation Models, el LLM en el dispositivo de Apple. Foundation Models expone un protocolo Tool aparte para la llamada de herramientas dentro de la app. Los 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 llamadas directas al LLM. Los dos contratos corren en paralelo.⁴

El contrato ha ido extendiéndose hacia arriba en la pila con cada versión. Originalmente, el consumidor de un 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 de Apple Intelligence respaldadas por LLM los usan para actuar sobre las solicitudes del usuario. La superficie de App Intent que lances en 2026 es la que Apple Intelligence invocará en iOS 27, 28, 29.

El patrón anterior es lo que quiero decir cuando afirmo que los 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 manera de escribir una app para visionOS, watchOS 10+ e iOS 17+. Los 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 ha llegado

Foundation Models es el framework que viene en todos los dispositivos elegibles para Apple Intelligence. El corte de hardware es la misma lista de Apple Intelligence: iPhone 15 Pro y 15 Pro Max (A17 Pro), la línea iPhone 16, la 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 / 15 Plus base.⁴¹²

La implicación: si las superficies del sistema de Apple (Siri, Spotlight, Apple Intelligence) invocan 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 quieren sus propias funciones de LLM en el dispositivo. El contrato entre apps (el que usan Apple Intelligence y Siri para encontrar tu app) corre a través de los 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 “Oye Siri, registra mi agua” hacia 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 habrán acumulado hacia quienes llegaron primero. La misma lógica aplica a las listas de compras, el registro de entrenamientos, las entradas de calendario, las búsquedas de fotos. Espero que la ventaja del primero en moverse en las declaraciones de intents se componga de la manera en que lo ha hecho para 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 de los App Entities, no solo de los 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 en cada AppEntity que coincida con Book en todas las apps instaladas. Si tu app tiene una lista de lectura y no tiene 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 a través de Siri, Spotlight y el Watch. Un perform() que solo devuelve é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 la manera en que tu acción se convierte en una cita en la superficie de IA del usuario.

Qué construiría de forma diferente

Once semanas de registros 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 mapea 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 lejos de mí.

La cadena de diálogo no es el cuerpo de un correo. Tenía ProvidesDialog desde el principio, pero mi diálogo temprano era prosa. El usuario que lo escucha a través de CarPlay o de los AirPods necesita una estructura corta, concreta y centrada en los hechos: “8 oz registradas. Faltan 32 oz”. La superficie del Watch en particular trunca de forma agresiva. El diálogo conversacional es una peor experiencia de usuario que el diálogo de hechos seguros. Reescribí el mío en la semana 4.²

Los App Entities importan más de lo que pensaba. Tengo un modelo de SwiftData WaterEntry. También debería declarar un WaterEntryEntity: AppEntity más su WaterEntryQuery: EntityQuery complementario para que Apple Intelligence pueda responder “muéstrame cuándo tomé agua ayer”. 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())")
    }
    @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 tipos pequeños de Swift más el pegamento de obtención de SwiftData. Para hacer que las entradas sean visibles individualmente en Spotlight (de modo que los usuarios que buscan “water” lleguen a la entrada correcta), haz que la entidad cumpla con 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 otros lugares de mis apps. Get Bananas, mi app de lista de compras, ya tiene un @Model ShoppingItem de SwiftData 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 a Apple Intelligence la misma capa de persistencia 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 el dato, los 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

El rechazo es parte del diseño.

Si tu app está impulsada puramente por el consumo (leer las fotos del usuario, mostrar noticias, reproducir audio) sin estado de usuario mutable, los App Intents quizá no tengan nada que exponer. El framework de Apple soporta OpenIntent (simplemente abrir la app en 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 elementos de UI que son difíciles de abstraer (una herramienta de lienzo compleja de varios pasos, 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 “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 hay una oración que un usuario diría de forma natural que dispara la acción. “Registra 8 oz de agua” es esa oración. “Aplica un 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 final

Durante tres años Apple ha estado señalando que el tejido de IA del sistema de iOS pasa por los App Intents. La WWDC 2024 añadió el enrutamiento de Apple Intelligence a través de ellos. La WWDC 2025 añadió Foundation Models junto a ellos como una superficie aparte de llamada de herramientas dentro de la app, dejando a los 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 firman ahora con el sistema.

La mayoría de las apps de iOS todavía tratan los 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 probablemente se encuentren fuera del grafo de enrutamiento. La superficie del primero en moverse, según mi experiencia observando las otras apuestas de plataforma de Apple, se compone.

Water ha tenido LogWaterIntent lanzado durante once semanas. La cantidad de código que lanza un App Intent es lo bastante pequeña para caber en un solo archivo. El costo de no lanzarlo crece con cada versión 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. Agrégala.

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 mediante @Parameter, un resumen en lenguaje natural mediante parameterSummary, y un cuerpo asíncrono perform() que hace el trabajo y devuelve 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 aparte para las llamadas 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 de intents principal de Apple. El framework más reciente 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 sigue soportado, pero no recibe trabajo de nuevas funciones.

¿Necesito iOS 26 para lanzar un App Intent?

No. Los App Intents están disponibles desde iOS 16 en adelante. iOS 26 añade el framework Foundation Models junto a ellos, pero las declaraciones de App Intent en sí funcionan en iOS 16+. El código de ejemplo anterior usa SwiftData (iOS 17+), así que el target de despliegue depende de lo que importe tu cuerpo perform(). Los App Intents básicos funcionan hasta iOS 16; los respaldados 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. Que WaterEntry se convierta 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 los App Intents con la llamada de herramientas de Foundation Models?

Foundation Models expone su propio protocolo Tool para las llamadas directas de herramientas del LLM dentro de la app. Los 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 quiere ser alcanzable por las superficies de IA del sistema lanza App Intents; una app que quiere invocar su propio LLM en el dispositivo con herramientas personalizadas lanza conformidades con Tool. Muchas apps lanzarán ambos.

Los 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 después encuentra la superficie ya enrutada hacia otro lado. Hace once semanas lancé uno en Water. La composición ya ha comenzado.

Más de la serie Apple Ecosystem

Este ensayo es el punto de entrada. Los otros cuatro cubren el resto de la pila de arquitectura:

• Dos ecosistemas de agentes, una lista de compras: 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 en SwiftUI: tres patrones de lanzar Return: patrones de producción para la capa visual de iOS 26.
• Cinco plataformas de Apple, tres archivos compartidos: la estrategia de lanzamiento multiplataforma, cuándo compartir código y cuándo bifurcar targets.
• HealthKit + SwiftUI en 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 directo al hub completo: Serie Apple Ecosystem. Para el contexto más amplio de iOS-con-agentes-de-IA, consulta la guía de Desarrollo de Agentes en iOS.

Referencias