Jun 9, 2026 · 9 min read

Siri AI for Developers: App Intents, Personal Context, and Custom Skills (2026)

Siri in 2026 is not the Siri you’ve been ignoring for ten years. Under the hood, it’s now a 1.2 trillion parameter model built on a Mixture of Experts architecture, and Apple has completely rebuilt how third-party apps integrate with it. SiriKit is deprecated. App Intents is the only path forward. And the capabilities gap between “Siri-enabled” and “not Siri-enabled” apps is about to become a competitive differentiator that users actually notice.

This guide covers everything you need to know as a developer: migrating from SiriKit, implementing App Intents, exposing your app’s data and actions to Siri AI, handling streaming responses, and managing privacy correctly. Let’s get into it.

The New Siri: What Changed

The new Siri operates on four pillars:

Personal context — Siri understands the user’s data, habits, relationships, and preferences across apps
World knowledge — General knowledge powered by the Foundation Models (AFM) architecture
App actions — The ability to perform actions inside third-party apps
On-screen awareness — Understanding what’s currently visible on screen

For developers, pillars 1 and 3 are where you plug in. You define what data your app exposes (entities) and what actions Siri can perform (intents). Siri’s AI handles natural language understanding, disambiguation, and multi-step reasoning across apps.

The launch partners tell you how seriously Apple is taking this: Uber, Amazon, YouTube, WhatsApp, and AllTrails all ship with deep Siri AI integrations. Users can say “Book me an Uber to the restaurant I’m meeting Sarah at” and Siri chains together calendar context, contact lookup, and the Uber booking intent without the user specifying an address.

SiriKit Is Dead: Migrating to App Intents

If you’re still using INIntent subclasses and SiriKit domains, here’s the reality: SiriKit is deprecated as of iOS 26. Apple won’t remove it immediately, but new Siri AI features only work with App Intents. No exceptions.

The migration isn’t trivial, but it’s well-structured. Here’s what maps to what:

SiriKit Concept	App Intents Equivalent
`INIntent` subclass	`AppIntent` struct
`INIntentHandler`	`perform()` method
Intent definition file (.intentdefinition)	Swift code with macros
`INObject`	`AppEntity`
`INParameter`	`@Parameter` property wrapper
Domain-specific intents	Open-ended, define your own

The biggest shift: SiriKit gave you predefined domains (messaging, payments, workouts). App Intents lets you define anything. Your fitness app isn’t limited to “start a workout” — it can expose “show my progress this week” or “adjust my calorie goal” or whatever makes sense.

Implementing App Intents for Siri AI

Let’s build a real example. Say you have a task management app and you want Siri to be able to add tasks, query tasks, and mark them complete.

Step 1: Define Your Entities

Entities are the data objects Siri can reference. They need to conform to AppEntity:

import AppIntents

struct TaskEntity: AppEntity {
    static var typeDisplayRepresentation: TypeDisplayRepresentation = "Task"
    
    static var defaultQuery = TaskEntityQuery()
    
    var id: UUID
    var title: String
    var dueDate: Date?
    var priority: TaskPriority
    var isComplete: Bool
    
    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(
            title: "\(title)",
            subtitle: dueDate.map { "Due \($0.formatted(.dateTime.month().day()))" } ?? ""
        )
    }
}

struct TaskEntityQuery: EntityQuery {
    func entities(for identifiers: [UUID]) async throws -> [TaskEntity] {
        try await TaskStore.shared.fetch(ids: identifiers)
    }
    
    func suggestedEntities() async throws -> [TaskEntity] {
        try await TaskStore.shared.fetchRecent(limit: 10)
    }
    
    func entities(matching query: String) async throws -> [TaskEntity] {
        try await TaskStore.shared.search(query)
    }
}

The EntityQuery is crucial — it’s how Siri resolves natural language references like “my dentist appointment task” into actual objects in your app.

Step 2: Define Your Intents

Each action Siri can perform is an AppIntent:

struct AddTaskIntent: AppIntent {
    static var title: LocalizedStringResource = "Add Task"
    static var description: IntentDescription = "Creates a new task in your list"
    
    @Parameter(title: "Task Name")
    var name: String
    
    @Parameter(title: "Due Date", optionsProvider: nil)
    var dueDate: Date?
    
    @Parameter(title: "Priority", default: .medium)
    var priority: TaskPriority
    
    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$name)") {
            \.$dueDate
            \.$priority
        }
    }
    
    func perform() async throws -> some IntentResult & ProvidesDialog & ShowsSnippetView {
        let task = try await TaskStore.shared.create(
            title: name,
            dueDate: dueDate,
            priority: priority
        )
        
        return .result(
            dialog: "Added '\(task.title)' to your tasks",
            view: TaskConfirmationView(task: task)
        )
    }
}

Step 3: Register With Siri AI via AppShortcutsProvider

struct TaskShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: AddTaskIntent(),
            phrases: [
                "Add a task in \(.applicationName)",
                "Create a \(\.$name) task in \(.applicationName)",
                "Remind me to \(\.$name) in \(.applicationName)"
            ],
            shortTitle: "Add Task",
            systemImageName: "plus.circle"
        )
        AppShortcut(
            intent: CompleteTaskIntent(),
            phrases: [
                "Mark \(\.$task) as done in \(.applicationName)",
                "Complete \(\.$task) in \(.applicationName)"
            ],
            shortTitle: "Complete Task",
            systemImageName: "checkmark.circle"
        )
    }
}

The phrases array isn’t a rigid voice command list — it’s training data for Siri’s AI. The model generalizes from these examples, so “finish that task” or “I’m done with the grocery list task” will also match your intent.

View Annotations API

The View Annotations API is new in iOS 26 and enables Siri’s on-screen awareness pillar. You annotate your SwiftUI views so Siri understands what’s on screen:

struct TaskListView: View {
    @State var tasks: [TaskEntity]
    
    var body: some View {
        List(tasks) { task in
            TaskRow(task: task)
                .siriAnnotation(entity: task) {
                    CompleteTaskIntent(task: task)
                    EditTaskIntent(task: task)
                    DeleteTaskIntent(task: task)
                }
        }
        .siriAnnotation(
            description: "A list showing \(tasks.count) tasks"
        )
    }
}

When the user says “mark the first one as done” while looking at your task list, Siri uses View Annotations to understand which “first one” refers to your first task entity, and routes to CompleteTaskIntent. Without annotations, Siri can’t resolve on-screen references.

Streaming Responses

For intents that take time (searching, generating content, processing data), Siri AI supports streaming responses. The user sees progressive updates instead of waiting:

struct SearchTasksIntent: AppIntent {
    static var title: LocalizedStringResource = "Search Tasks"
    
    @Parameter(title: "Query")
    var query: String
    
    func perform() async throws -> some IntentResult & ProvidesDialog {
        // Start streaming to show Siri is working
        let stream = StreamingIntentResult()
        
        stream.updateDialog("Searching your tasks...")
        
        let results = try await TaskStore.shared.search(query)
        
        if results.isEmpty {
            return .result(dialog: "No tasks found matching '\(query)'")
        }
        
        let summary = results.prefix(3).map(\.title).joined(separator: ", ")
        return .result(
            dialog: "Found \(results.count) tasks: \(summary)"
        )
    }
}

Streaming is especially important for intents that call external AI services. If your app uses tool calling to process user requests through an LLM before executing, the streaming feedback keeps Siri from appearing frozen.

Per-Intent Privacy Manifests

This is the part most developers will skip and then get rejected in App Review. Every App Intent that accesses user data now requires a privacy manifest declaring:

What data the intent accesses
Why it needs that data
Whether data leaves the device
How long it’s retained if sent externally

struct AddTaskIntent: AppIntent {
    // ... parameters ...
    
    static var privacyManifest: IntentPrivacyManifest {
        IntentPrivacyManifest(
            dataAccessed: [.userContent],
            purpose: .appFunctionality,
            dataSentExternally: false,
            retentionPolicy: .none
        )
    }
}

If your intent calls an external AI API to process the request, you must declare dataSentExternally: true and specify the retention policy. Apple reviews these declarations, and misrepresenting them is a rejection reason.

This ties into broader GDPR compliance requirements. For EU users, per-intent manifests give Apple the granularity to show exactly what each Siri action does with data — which is relevant given that Siri AI’s EU launch is delayed specifically for regulatory reasons.

Personal Context: How Siri Learns Your App

The personal context pillar is where the magic happens but also where developers have the least direct control. Siri builds a semantic index of the user’s data across apps. Your job is to donate content to this index:

// Donate entities to Siri's personal context
func donateToSiri(tasks: [TaskEntity]) {
    let donations = tasks.map { task in
        INRelevantShortcut(
            shortcut: .intent(ViewTaskIntent(task: task)),
            relevanceProviders: [
                INDateRelevanceProvider(
                    startDate: task.dueDate ?? .now,
                    endDate: task.dueDate?.addingTimeInterval(3600)
                ),
                INLocationRelevanceProvider(region: task.locationRegion)
            ]
        )
    }
    INRelevantShortcutStore.default.setRelevantShortcuts(donations)
}

Once donated, Siri can reference your app’s data in cross-app queries. “What do I have due before my flight tomorrow?” can pull tasks from your app, calendar events, and travel bookings — all orchestrated by the 1.2T parameter model.

Building an AI Agent Inside Your App

The real power comes when you combine App Intents with Apple’s Foundation Models framework. Your app can become an AI agent that Siri orchestrates:

struct SmartScheduleIntent: AppIntent {
    static var title: LocalizedStringResource = "Smart Schedule Task"
    
    @Parameter(title: "Task Description")
    var description: String
    
    func perform() async throws -> some IntentResult & ProvidesDialog {
        // Use on-device Foundation Model to parse intent
        let session = LanguageModelSession(executor: .onDevice)
        
        let analysis = try await session.generate(
            prompt: "Parse this task and suggest a due date: \(description)",
            schema: TaskAnalysisSchema.self
        )
        
        let task = try await TaskStore.shared.create(
            title: analysis.title,
            dueDate: analysis.suggestedDate,
            priority: analysis.inferredPriority
        )
        
        return .result(dialog: "Created '\(task.title)' due \(task.dueDate!.formatted())")
    }
}

This pattern — Siri triggers your intent, your intent uses Foundation Models for reasoning, then executes the action — is how agent orchestration works on Apple’s platform. Siri is the orchestrator, your intents are the tools, and Foundation Models provide the reasoning.

What About Context Engineering?

If you’ve read about context engineering for AI applications, Apple’s approach handles it at the system level. Siri manages context across apps — your intent doesn’t need to know about the user’s calendar or messages. Siri provides relevant context to your intent through parameters it resolves from its semantic index.

However, prompt engineering still matters for how you describe your intents and parameters. Clear description fields and well-chosen phrases in your AppShortcutsProvider help Siri’s model match user requests to the right intent.

Availability and Limitations

A few realities to be aware of:

English first — Siri AI’s full capabilities launch in English. Other languages follow throughout 2026-2027
EU delayed — Due to Digital Markets Act negotiations, Siri AI features ship later in the EU for iOS
iOS 26+ only — App Intents work on older iOS versions, but the AI-powered features (natural language matching, cross-app orchestration, on-screen awareness) require iOS 26
Privacy processing — All personal context processing happens on-device or in Private Cloud Compute. Third-party apps never see other apps’ data

Migration Checklist

If you’re starting from scratch or migrating from SiriKit:

Audit your SiriKit intents — Map each INIntent to an equivalent AppIntent
Define entity schemas — Every piece of data Siri should reference needs an AppEntity
Add View Annotations — Annotate key screens so Siri understands on-screen content
Write privacy manifests — Every intent needs one. Do this early, not at submission time
Donate relevant shortcuts — Keep Siri’s personal context index updated
Test with natural language — Don’t just test exact phrases. Try variations, ambiguous requests, multi-step commands
Support streaming — Any intent that might take >1 second should stream progress

Frequently Asked Questions

Can I still use SiriKit in iOS 26?

SiriKit still works in iOS 26 — existing apps won’t break. But it’s officially deprecated, new features only work with App Intents, and Apple’s documentation strongly recommends migration. Expect SiriKit removal in iOS 27 or 28.

How does Siri AI decide which app to use for a request?

Siri’s 1.2T parameter model uses a combination of the user’s personal context (which apps they use for what), the intent descriptions you provide, the phrase examples in your AppShortcutsProvider, and the current context (on-screen content, recent activity). There’s no bidding or priority system — the AI makes the routing decision.

Do I need to pay for my app to work with Siri AI?

No. App Intents are free to implement. The Siri AI infrastructure (on-device model, Private Cloud Compute routing) is provided by Apple as part of iOS. If your intent internally calls a paid AI API, that’s your cost, but Siri’s orchestration layer is free.

What happens when Siri AI isn’t available (EU, non-English)?

Your App Intents still work as Shortcuts and can be triggered through the Shortcuts app, Spotlight, or direct invocation. You lose the natural language understanding and cross-app orchestration, but the intents themselves remain functional.

How do I test Siri AI integration during development?

Xcode 18 includes a Siri AI simulator that lets you type natural language queries and see which intents they resolve to. You can also test on physical devices running iOS 26 beta. Apple recommends testing with at least 20 varied phrasings per intent to verify the AI routing works correctly.

Can Siri chain multiple intents from my app in one request?

Yes. If a user says “Add a task to buy groceries and set it to high priority,” Siri can resolve this to a single AddTaskIntent with both parameters filled. For truly multi-step sequences (add task, then share it, then set a reminder), Siri can chain intents — but each step requires user confirmation in the current release.