Apple just opened up Siri AI for developers whose app features fall outside its predefined schemas. You can now expose custom actions through App Intents, describe your app’s content with App Entities, and add skills that help Siri handle more complex requests.

This is a big deal. Now that Siri AI is open to ALL apps it might actually become useful. And if it's even somewhat decent (it doesn't have to be the best), it will be a dominant player in the AI assistant space because it's built-in to all iPhones. It's what the vast majority of iPhone users will default to if it becomes even remotely useful.

Apple announced this expansion on November 3, 2026. It’s a developer preview, so there are limits on testing and availability. But if you’ve already invested in App Intents and built them for your app, then you've already done most of the work.

What changed with Siri AI for developers?

Apple’s app schemas give the system a shared understanding of familiar actions and content. A schema defines a particular capability or data type, and a domain groups related schemas, such as messaging or calendar actions.

The new preview lets developers bring custom actions and content to Siri AI beyond those predefined schemas.

That’s the part I’m excited about. Siri becomes more useful when it can work with the apps people actually use. If it can reliably handle everyday tasks across those apps, I think more people will start reaching for it.

That's your opportunity. If you take the time to build a great App Intent setup for your app and Apple finally gets Siri AI right, then your app is in an amazing position. In my opinion, this is a small amount of work for a potentially big payoff. I'll take that bet.

How do App Entities, tools, and skills work together?

Siri needs to understand what your app contains and what it can do. These components provide that information:

App Entities describe your app’s content

An App Entity represents an app-specific concept in a form the system can understand.

Your food app already knows what a menu item is. Siri needs you to describe that concept and provide a way to find the right item.

Technically, AppEntity is a Swift protocol. You can adopt it on an existing data model or create a separate type that represents the relevant information. You don’t have to expose your entire database model.

struct FoodItemEntity: AppEntity {
    static let typeDisplayRepresentation: TypeDisplayRepresentation = "Food Item"
    static let defaultQuery = FoodItemQuery()

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

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

struct FoodItemEntity: AppEntity {
    static let typeDisplayRepresentation: TypeDisplayRepresentation = "Food Item"
    static let defaultQuery = FoodItemQuery()

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

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

struct FoodItemEntity: AppEntity {
    static let typeDisplayRepresentation: TypeDisplayRepresentation = "Food Item"
    static let defaultQuery = FoodItemQuery()

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

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

struct FoodItemEntity: AppEntity {
    static let typeDisplayRepresentation: TypeDisplayRepresentation = "Food Item"
    static let defaultQuery = FoodItemQuery()

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

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

App Intents define actions

An App Intent describes an action, the inputs it needs, and the code that performs it.

For example, an “Add Food Item to Cart” intent might accept a food item and a quantity. Your Swift code then updates the cart.

App Entities and App Intents are established parts of Apple’s frameworks. The new tool support builds on that work, giving Siri AI access to eligible custom actions.

struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

App Intents and the ToolIntent Protocol

Your App Intents can easily conform to the ToolIntent protocol by adding the @AppIntent(.tool) macro. Doing this will make your tools available to Siri AI under certain circumstances (more on that below).

This is why if you've already built out your App Intents, you've done most of the work.

@AppIntent(.tool) // Make your App Intent a tool with this Macro
struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

@AppIntent(.tool) // Make your App Intent a tool with this Macro
struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

@AppIntent(.tool) // Make your App Intent a tool with this Macro
struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

@AppIntent(.tool) // Make your App Intent a tool with this Macro
struct AddItemToCartIntent: AppIntent {
    static let title: LocalizedStringResource = "Add Item to Cart"

    @Parameter(title: "Food Item") var foodItem: FoodItemEntity
    @Parameter(title: "Cart") var cart: CartEntity

    static var parameterSummary: some ParameterSummary {
        Summary("Add \(\.$foodItem) to \(\.$cart)")
    }

    func perform() async throws -> some IntentResult {
        // add foodItem code goes here
        return .result()
    }
}

Skills provide extra guidance

An app skill is a Markdown file that helps Siri handle tasks involving your tools. It can explain which tool to prefer, how tools fit together, and relevant knowledge about your app.

Each skill has a name and description. Siri considers that metadata before loading the full instructions when relevant.

My advice is to get the tools working well first. If two actions are hard to tell apart, improve their design and descriptions before adding more instructions.

When can Siri discover your app’s custom tools?

Custom tools aren’t automatically considered for every request. Apple’s preview overview describes situations that make them available:

• Your app is open in the foreground.

• The person mentions your app by name.

• Your app has an active Live Activity, such as an ongoing delivery status.

• The person continues a conversation in the Siri app that already mentions your app.

• A relevant entity from your app appears in a search result.

These conditions make a tool available for consideration. Siri still needs to decide whether it fits the request.

Should you still use Apple’s schemas?

Yes, when an appropriate schema exists. Apple recommends adopting system-defined schemas wherever possible.

Check the schema’s supported experiences, too. Some integrate with Siri, while others are specific to Shortcuts.

You can use schemas for supported functionality and custom tools for the rest. Your entire app doesn’t need to fit one category.

How do you prepare your app for Siri AI?

Start with a few actions people would actually want to request. For a food app, that might be finding a menu item, adding it to a cart, and retrieving a previous order.

Build and test those before expanding. A long list of overlapping tools gives you more opportunities to confuse Siri AI and the inference time will increase making the request take longer.

1. Review your existing intents

For an eligible custom action, Apple’s integration guide shows how @AppIntent(.tool) adds conformance to the ToolIntent protocol.

There’s an important exception: don’t add the tool trait to an intent that already uses a schema Siri supports. That action is already integrated, and adding the trait causes a build error.

An intent using a Shortcuts-only schema can use the combined @AppIntent(.tool, schema:) form.

2. Make titles and descriptions specific

Siri uses intent and parameter descriptions to understand actions and supply the right inputs.

“Update Cart” leaves a lot open to interpretation. “Add Food Item to Cart” is clearer. A useful description could explain that it adds a selected item and quantity without placing an order.

Describe the parameters just as carefully. Does “quantity” mean individual items or meal bundles? Make that explicit.

Also localize the titles and descriptions for the languages your app supports. Apple’s App Intent documentation specifies localized strings for this metadata.

3. Make the relevant content discoverable

An action needs the right data. Siri must be able to resolve which menu item or previous order someone means.

Apple’s integration guide covers making entities available through Spotlight and supported queries. It also explains how to associate onscreen content with entities so someone can refer to “this item.”

This is another reason to start with a small workflow. You can check that the content and actions work together before exposing more features.

4. Add a skill when the workflow needs it

In Xcode, choose File > New > File from Template, select Skills Bundle under Resource, keep the suggested name, and select your app target.

Create a subfolder for each skill inside the bundle’s Skills folder, with a SKILL.md file inside it. Include the required name and description metadata, followed by your instructions.

Apple’s app skills guide explains the format. Skills provide guidance; they don’t guarantee a fixed sequence of actions.

How do you test Siri AI integration?

People won’t all ask for the same thing in the same way.

For your cart action, try requests such as:

• “Add two veggie burritos to my cart.”

• “Put a couple of veggie burritos in the cart.”

• “I want two veggie burritos.”

Also try incomplete requests. If someone says “Add a burrito,” what should happen when several burritos are available?

The Siri Evaluations framework lets you script conversations and check which intents Siri calls, which parameter values it supplies, which entities it finds, and how it responds.

Run variations more than once. Siri’s behavior can vary between runs, and one successful request doesn’t tell you much about reliability.

When a scenario fails, inspect the result. Was the action wrong? Was the quantity wrong? Was the item ambiguous? Improve the relevant intent, parameter, entity, or skill, then run it again.

Xcode’s Siri Integration Advisor also provides feedback on your App Intents implementation. For manual app-skill testing, Apple specifies a real supported device rather than Simulator.

When can you release a Siri AI integration?

As of November 11, 2026, the new custom-action integration is a developer preview. Xcode 27.3 beta includes the corresponding SDKs.

The preview supports iOS, iPadOS, macOS, and visionOS on devices that support Apple Intelligence, where Siri AI is available.

You can test through development-signed device builds and internal TestFlight builds. The new functionality isn’t available to external TestFlight testers or people installing your app from the App Store.

Apple says App Store submissions for these experiences will open in spring 2027. Its current preview documentation doesn’t provide a date for external TestFlight access. Check the latest availability guidance before planning your rollout.

Frequently asked questions

Can Siri complete a task across multiple apps?

Yes, when the apps expose the required actions and compatible content. For example, a request could retrieve an order from a food app and share it through a messaging app.

Your custom entities need suitable transferable representations so the receiving app can use the information. Apple covers this in its custom actions and content guide.

Do skills replace the Swift code in an App Intent?

No. Your App Intent’s implementation performs the action. A skill gives Siri guidance about using the available tools.

Does Siri automatically get access to all my app’s data?

No. Siri can use the content and actions you explicitly expose through the integration. Choose what each entity represents and make the relevant information available.

Apple also provides authentication and visibility controls for entity information, described in its integration guide.

Try Bitrig

Bitrig helps you build native Swift apps with AI and can help create App Intents and App Entities. Start with the feature your users would most appreciate being able to ask Siri to handle and add more as you go.