Migrating from SiriKit to App Intents in iOS 27: The Deprecation Clock and the Production Path

This migration guide pairs with Making Your App Siri-Actionable in iOS 27. Start there if you need the mental model for actions, entities, App Shortcuts, donations, and snippets before converting existing SiriKit code.

What broke

At WWDC 2026, Apple gave SiriKit a formal deprecation notice and made App Intents the only framework the rebuilt Siri can call into. SiriKit code still compiles under iOS 27, but it emits deprecation warnings in Xcode 27, and — this is the part that bites immediately — apps that expose their actions only through SiriKit are invisible to the new Siri the moment iOS 27 ships this fall.

There are two deadlines, and most teams plan around the wrong one.

• The hard deadline is roughly two to three years out — somewhere around the iOS 29 cycle — when SiriKit voice functionality is removed entirely. That is the date that makes the migration feel deferrable.
• The soft deadline is iOS 27 GA in fall 2026. From that day, the new Siri routes exclusively through App Intents. If your actions are not modeled as intents, Siri cannot see them, cannot trigger them, and cannot chain them into the cross-app workflows that are the entire point of the new assistant.

The soft deadline is the one that costs you discoverability. Plan around it.

Why this is not a rename

SiriKit and App Intents are built on different architectural principles, and the difference is the reason Apple is forcing the migration instead of supporting both indefinitely.

SiriKit, shipped with iOS 10 in 2016, gave you a fixed set of system intent domains — messaging, payments, workouts, and a handful of others. You adopted a domain and filled in the blanks. If your feature did not map to an Apple-defined domain, Siri could not reach it. It required a separate Intent Extension target and XML-adjacent .intentdefinition files.

App Intents inverts this. The new Siri is a reasoning assistant: it interprets a vague request, decides which app actions to call, passes the result of one action into the next, and explains what it did. That only works if your app exposes its actions as composable, well-described units the model can reason about. App Intents is that surface — Swift structs conforming to AppIntent, no separate extension target, no definition files.

You are not renaming an API. You are converting from "fill in Apple's fixed slots" to "describe your app's capabilities so a model can orchestrate them."

The migration, in order

Step 1 — Inventory what you have

Before touching code, list every SiriKit intent your app exposes. Look for:

• INExtension principal classes and your Intents extension target.
• Custom intents defined in .intentdefinition files.
• Adopted system domains (INSendMessageIntent, INStartWorkoutIntent, and similar).
• Any INInteraction donations you make to drive Siri suggestions.

For each one, write down the action it performs, its parameters, and the user-facing phrase it answered to. This list is your migration scope and your regression checklist.

Step 2 — Run the Xcode conversion

Apple made the mechanical transformation simple. Open your .intentdefinition file in Xcode 27 and use Convert to App Intent. Xcode generates the equivalent Swift scaffold. The structural work is handled; you supply the business logic.

A SiriKit-era custom intent that looked like a generated INIntent subclass becomes an AppIntent struct:

import AppIntents

struct LogWaterIntent: AppIntent {
    static let title: LocalizedStringResource = "Log Water"

    // Parameter names and types MUST match your old intent definition
    // or existing user Shortcuts break.
    @Parameter(title: "Amount (ml)")
    var amountMilliliters: Int

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

    @MainActor
    func perform() async throws -> some IntentResult & ProvidesDialog {
        try await HydrationStore.shared.log(milliliters: amountMilliliters)
        return .result(dialog: "Logged \(amountMilliliters) ml.")
    }
}

Step 3 — Preserve existing Shortcuts (do not skip this)

Users who built Shortcuts on your SiriKit intents will have them silently break if the migrated intent does not line up. Two rules:

1. Parameter names and types must match the old intent definition exactly. A renamed parameter is a broken Shortcut.
2. Use CustomIntentMigratedAppIntent to tie the new App Intent back to the old custom intent identifier, so the system maps existing user Shortcuts onto the replacement.

struct LogWaterIntent: AppIntent, CustomIntentMigratedAppIntent {
    static let intentClassName = "LogWaterIntent" // old generated class name
    // ...
}

This is the single most common production regression in a SiriKit migration: the code compiles, the new Siri works, and a month later support tickets arrive because everyone's automations quietly stopped firing.

Step 4 — Model your data as entities

SiriKit thought in terms of actions only. The new Siri reasons over your content too. Anything a user might refer to — a document, a meal, a saved location — should be an AppEntity so Siri can resolve "that one," chain it into the next action, and surface it in Spotlight's semantic index.

struct Meal: AppEntity {
    static let typeDisplayRepresentation: TypeDisplayRepresentation = "Meal"

    let id: UUID
    @Property(title: "Name") var name: String

    var displayRepresentation: DisplayRepresentation {
        DisplayRepresentation(title: "\(name)")
    }

    static var defaultQuery = MealQuery()
}

Where a system-defined schema exists for your category (App Intent Domains added task management, photo editing, communication, media, finance, and more in iOS 27), adopt it. System schemas mean your intents benefit automatically from future Siri language-understanding improvements with no code change on your side.

Step 5 — Provide zero-config phrases with AppShortcuts

AppShortcuts give your top actions natural-language invocation without the user configuring anything:

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

For AI features that need streaming or follow-up prompts after migration, continue with App Intents 2.0 for AI Features.

Step 6 — Validate through real system pathways

iOS 27 ships an App Intents Testing framework that validates your full integration — Siri, Shortcuts, and Spotlight — through real system pathways, without UI automation. Use it. The failure mode it catches is the one that is otherwise invisible: an intent that runs, never throws, and quietly does the wrong thing.

The privacy control worth knowing about

iOS 27 lets you declare, per intent, whether an interaction is permitted to route to the cloud at all. The new Siri sends complex queries to a server model when the on-device model is not enough; for regulated data — health, legal, finance — you can pin an intent to on-device only via the per-intent privacy manifest declarations. If you ship anything handling sensitive data, audit every migrated intent against your compliance requirements and set this explicitly rather than relying on the default.

For deeper context on cloud routing, read Private Cloud Compute and the Language Model Protocol.

A realistic timeline

For an app with a handful of intents, this is hours of work, not sprints — the Xcode conversion does the structural lifting and you supply perform() logic. The cost scales with how much of your content you model as entities, which is also where the real upside is: entities are what let the new Siri do anything interesting with your app.

Do the inventory now. Run the conversion. Get CustomIntentMigratedAppIntent right so you do not break existing automations. Ship before the public beta hardens user expectations in mid-July, and well before GA this fall.

Sources and further reading

• Apple Developer — App Intents framework: https://developer.apple.com/documentation/appintents
• Apple Developer — WWDC26 Apple Intelligence guide: https://developer.apple.com/wwdc26/guides/apple-intelligence/
• WWDC 2026 sessions: "Discover new capabilities in the App Intents framework" and the companion "Code-along: Make your app available to Siri"

API names and behaviors reflect WWDC 2026 beta material and may change as Apple ships beta updates. Verify against Apple's developer documentation before relying on them.