App Intents 2.0: SiriKit Deprecation and the Mandatory Migration Path

With the release of iOS 27, Apple has officially declared SiriKit deprecated, making the transition to App Intents mandatory for all teams seeking integration with Apple Intelligence, Spotlight, and system-level shortcuts. For years, SiriKit served as the primary bridge between third-party applications and iOS voice commands, routing requests through predefined domains like messaging, workouts, and payments. However, the rigid intent-definition architecture of SiriKit is incompatible with the semantic reasoning of modern on-device LLMs.

To participate in the new semantic indexing ecosystem, apps must migrate their interaction models to App Intents 2.0. This framework shifts the responsibility of language understanding from static system domains to structured metadata exposed directly by your application. This guide provides the architectural context and implementation path required to execute this transition.

---

Key Takeaways

• SiriKit Deprecation: Legacy intent definitions (.intentdefinition files) and INExtension targets are fully deprecated; compiler warnings will transition to build blockers in upcoming releases.
• Semantic Indexing: Apple Intelligence accesses application features via App Entities exposed to the system-wide Spotlight index rather than matching user utterances to pre-baked intent templates.
• Out-of-Process Execution: App Intents run in an isolated system extension sandbox, requiring strict attention to memory usage (30MB memory limit) and lightweight dependency injection.
• View Annotations API: Enables direct mapping of SwiftUI view elements to App Intents, allowing Siri to interact with on-screen content dynamically.
• Vocabulary Migration Tax: The shift from custom SiriKit vocabularies to App Entity titles and descriptions requires complete reconstruction of localized terms into semantic string identifiers.

---

The “Why”: Moving Beyond Static Intent Domains

SiriKit was architected around a fixed set of intent domains. If your application did not fit neatly into one of these categories (e.g., messaging, ride-booking, or photo search), you were forced to use general-purpose intents, which suffered from poor recognition accuracy. SiriKit relied on natural language processing models running at the system level that mapped user utterances to these domains, which then forwarded structured payloads to your app extension.

[Legacy SiriKit Pipeline]
User Utterance ---> System NLP Parser ---> Static Intent Domain (e.g., INSendMessageIntent) 
                                                              |
                                                              v
                                                   Host App / INExtension

[App Intents 2.0 & Apple Intelligence]
User Utterance ---> LLM (Semantic Router) ---> Spotlight Index (Registered App Entities)
                                                              |
                                                              v
                                                  App Intent (Dynamic Execution)

Figure 1: Comparison between SiriKit’s static domain matching and App Intents 2.0’s dynamic semantic routing.

This approach is obsolete. With Apple Intelligence, the system utilizes local foundation models to route actions dynamically. Instead of matching text to static templates, the LLM treats your application’s App Intents as tools. The model reads the schema of your intents, understands what parameters they accept, scans the Spotlight index for relevant App Entities, and compiles an execution plan.

Furthermore, App Intents 2.0 eliminates the launch overhead associated with host app wakeups. Intents are executed in a specialized, lightweight extension context. This out-of-process model ensures that invoking an action from the Lock Screen, Action Button, or Siri does not force the entire host application into memory, significantly reducing system-wide latency and power consumption.

---

Technical Architecture of App Intents 2.0

To successfully migrate, you must understand three core components of the new framework:

1. App Intents (AppIntent): The executable actions your app exposes. They define the parameters required, perform the operation, and return a result (either visual or data-driven).
2. App Entities (AppEntity): The data types your app manages (e.g., a task, a document, or a playlist). Entities are indexed by Spotlight, allowing Apple Intelligence to resolve natural language references (e.g., “Send the Q3 Report to Sarah”) to specific database records.
3. App Shortcuts (AppShortcutsProvider): Pre-packaged combinations of intents and entities that are registered with the system upon app installation, making them immediately discoverable via Siri and the Shortcuts app without user configuration.

---

Implementing the Migration Path

The following implementation demonstrates how to migrate a messaging action from SiriKit’s INSendMessageIntent to an App Intents 2.0 structure in Swift 6. This codebase illustrates semantic entity resolution, Spotlight indexing integration, and asynchronous execution safety.

1. Defining the App Entity

Instead of relying on SiriKit’s INPerson or custom vocabulary files, we define a strongly-typed RecipientEntity conforming to AppEntity.

import AppIntents
import Foundation
import CoreSpotlight

// A semantic entity representing a messaging recipient, indexed in Spotlight
public struct RecipientEntity: AppEntity, Sendable {
    public static var defaultQuery = RecipientQuery()
    
    public static var typeDisplayRepresentation: TypeDisplayRepresentation {
        TypeDisplayRepresentation(
            name: "Message Recipient",
            numericFormat: "Recipients"
        )
    }
    
    // Unique identifier used to locate the recipient in the local database
    public let id: String
    
    // The display name shown in Siri dialogs and the Shortcuts UI
    public let displayName: String
    
    // The email or phone number associated with the contact
    public let contactHandle: String
    
    public var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: "\(displayName)",
            subtitle: "\(contactHandle)"
        )
    }
}

// Query provider enabling the system to resolve user references to RecipientEntities
public struct RecipientQuery: EntityQuery, Sendable {
    public init() {}
    
    // Locates a single entity by its unique ID
    public func entities(for ids: [String]) async throws -> [RecipientEntity] {
        // In production, fetch from database or contact store
        return ids.compactMap { id in
            RecipientEntity(id: id, displayName: "User \(id)", contactHandle: "user\(id)@iosdev.in")
        }
    }
    
    // Resolves search queries typed in Spotlight or spoken to Siri
    public func entities(matching query: String) async throws -> [RecipientEntity] {
        // Simulate local database query matching the display name
        guard !query.isEmpty else { return [] }
        return [
            RecipientEntity(id: "101", displayName: "Aarav Sharma", contactHandle: "+919876543210"),
            RecipientEntity(id: "102", displayName: "Diya Patel", contactHandle: "diya@iosdev.in")
        ].filter { $0.displayName.localizedCaseInsensitiveContains(query) }
    }
    
    // Provides suggested values when the user configures the action manually
    public func suggestedEntities() async throws -> [RecipientEntity] {
        return [
            RecipientEntity(id: "101", displayName: "Aarav Sharma", contactHandle: "+919876543210"),
            RecipientEntity(id: "102", displayName: "Diya Patel", contactHandle: "diya@iosdev.in")
        ]
    }
}

2. Defining the App Intent

Next, we implement the SendMessageIntent to replace the deprecated INSendMessageIntentHandler.

import AppIntents
import SwiftUI

public struct SendMessageIntent: AppIntent, Sendable {
    public static var title: LocalizedStringResource = "Send Message via iOS Dev India"
    public static var description = IntentDescription("Sends a secure message to a registered contact using App Intents 2.0.")
    
    // Mark as an action that modifies state
    public static var isDiscoverable: Bool = true
    
    // The primary recipient (parameter mapped to the App Entity)
    @Parameter(title: "Recipient", description: "The person to receive the message.")
    public var recipient: RecipientEntity
    
    // The text content of the message
    @Parameter(title: "Message Body", description: "The content of the message to send.")
    public var body: String
    
    public init() {}
    
    public init(recipient: RecipientEntity, body: String) {
        self.recipient = recipient
        self.body = body
    }
    
    // The execution entry point called by Apple Intelligence or the Shortcuts runner
    @MainActor
    public func perform() async throws -> some IntentResult & ReturnsValue<String> & ProvidesDialog {
        // Execute network request or save to database safely
        let messageId = UUID().uuidString
        print("Sending message '\(body)' to \(recipient.displayName) (ID: \(recipient.id)) with MessageID: \(messageId)")
        
        // Return result status along with dialog feedback for Siri voice responses
        return .result(
            value: messageId,
            dialog: IntentDialog("Successfully sent message to \(recipient.displayName).")
        )
    }
}

3. Exposing App Shortcuts

To make our intent discoverable instantly by Siri and Spotlight, we register it with an AppShortcutsProvider.

import AppIntents

public struct MessageShortcutsProvider: AppShortcutsProvider {
    @AppShortcutsBuilder
    public static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: SendMessageIntent(),
            phrases: [
                "Send a message on \(.applicationName) to \(\.$recipient)",
                "Message \(\.$recipient) using \(.applicationName)"
            ],
            shortTitle: "Send Message",
            systemImageName: "message.fill"
        )
    }
}

4. SwiftUI View Annotations Integration

To link a SwiftUI component directly to an intent so that Siri can click or tap it when it appears on the screen, use the View Annotations API:

import SwiftUI
import AppIntents

struct MessageDetailView: View {
    let recipient: RecipientEntity
    @State private var messageText: String = ""
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Chatting with \(recipient.displayName)")
                .font(.headline)
            
            TextField("Type your message", text: $messageText)
                .textFieldStyle(.roundedBorder)
            
            Button("Send") {
                Task {
                    let intent = SendMessageIntent(recipient: recipient, body: messageText)
                    _ = try? await intent.perform()
                }
            }
            // Bind the SwiftUI button directly to the App Intent for on-screen Siri detection
            .associateIntent(SendMessageIntent(recipient: recipient, body: messageText))
        }
        .padding()
    }
}

---

The Verdict: Evaluating the App Intents 2.0 Shift

Transitioning to App Intents 2.0 is a critical architectural update that impacts discoverability and system integration.

When to Migrate Immediately

• Apple Intelligence Target: If your roadmap includes surfacing actions inside the Siri voice overlay or contextual suggestions in Apple Intelligence.
• Spotlight-Heavy Apps: Apps like document managers, CRM clients, or notes apps that benefit from local semantic search indexing.
• Widget-Driven Systems: Since WidgetKit now relies exclusively on App Intents for interactive timelines, migrating intents is necessary to keep widgets operational.

When to Delay or Phase

• Complex Data Dependencies: If your intent execution path relies on a massive host application graph (e.g., Core Data, local network state, heavy third-party SDKs) that cannot easily run in a 30MB extension memory limit.
• Cross-Platform Shared Codebases: If your actions are generated dynamically from non-native bindings (e.g., Flutter, React Native), the compile-time metadata extraction of @Parameter and AppIntent macros will require custom native bridging code.

The Hidden Cost

The primary hidden cost of App Intents 2.0 is memory management within App Extensions. Unlike SiriKit, which executed in a background thread of the host application under certain configurations, App Intents are loaded out-of-process. The OS enforces a strict 30MB RAM limit on these extensions.

If your dependency injection setup loads heavy classes or establishes database connections that fetch massive datasets, the intent extension will crash silently with an OOM (Out Of Memory) exception. Developers must isolate their database access layers and use lightweight repositories for App Entity resolution.

---

Related Reading

To fully understand modern iOS architecture patterns, read our deep-dives on Agentic Workflows & App Intents and how to handle thread safety with Swift 6.4 Concurrency. For hardware optimizations, see the Core AI Deep Dive.

---

External References

• Apple Developer: App Intents Framework
• Swift.org: Swift Evolution Proposals