Sanniv Khare 7 min read

App Intents and AppFunctions: what a bank app exposes to AI

App Intents and AppFunctions: what a bank app exposes to AI

Short version: on iOS, give every banking App Intent an explicit authenticationPolicy (the default, .alwaysAllowed, runs it on a locked phone), and do not expose AppEntity types that carry balances or transactions yet. The iOS 27.3 beta 2 release notes list a known issue (190573761): when an entity or entity property requires unlock, “Siri AI might not request an unlock before it displays these entities.” On Android, Jetpack AppFunctions 1.0.0-rc01 (4 Nov 2026) only lets callers with the privileged EXECUTE_APP_FUNCTIONS permission run your functions, so the gate there is the system assistant, and your own code has to re-check the session.

Why we did this: we build Beacon-type banking apps in React Native with native modules on both platforms. Apple opened Siri AI to all developers on 3 Nov, Google moved AppFunctions to RC a day later, and the question from the bank side is the same on both: what may an assistant show or do while the phone sits on a table?

This post is a review of Apple’s App Intents documentation and the iOS 27.3 beta 2 release notes, the AppFunctions release notes and guide, and Google Play’s policy deadlines page, read on 17 Nov 2026. The code is a sketch to adapt and compile against your own targets.

What Apple announced and what is still open

Apple’s news post of 3 Nov 2026: “Starting today with the iOS 27.3, iPadOS 27.3, macOS 27.3, and visionOS 27.3 betas, a new Developer Preview enables any developer to integrate their app with Siri AI.” Customers get it “in a few months”, and App Store submission opens “in the spring”. It needs an Apple Intelligence device set to a supported language, and “Siri AI is currently unavailable in the EU in iOS, iPadOS, and watchOS.”

Siri AI uses App Intents, the same framework as Shortcuts and Spotlight. That matters for a bank app that already ships App Intents for Shortcuts: those intents become reachable by a far more capable caller without a line of code changing.

The iOS 27.3 beta 2 release notes have two App Intents items: the new Video schema domain, and the known issue 190573761 quoted above, with no workaround listed.

The three authentication policies

From Apple’s IntentAuthenticationPolicy reference (iOS 16 and later):

Case Apple’s description
alwaysAllowed “allows the app intent to run at any time, including when the device is locked”
requiresAuthentication “requires authentication before running the app intent”
requiresLocalDeviceAuthentication “requires the person to unlock the device running the intent”

Where you can set it:

  • On an intent: AppIntent.authenticationPolicy. Apple: “The default value of this property is IntentAuthenticationPolicy.alwaysAllowed.”
  • On an entity: AppEntity.authenticationPolicy, “The authentication policy to enforce when the system accesses this entity.”
  • On an entity property, per the 27.3 release note wording.

The default is the trap. An intent written for Shortcuts a year ago, with no policy set, runs on a locked device.

Two related properties worth checking in the same pass: isDiscoverable (iOS 17 and later; set it to false and “system features can’t access it”, while your app and widgets still can), and openAppWhenRun, which Apple now marks deprecated in favour of supportedModes.

Our expose or hold list

For a banking app on the 27.3 betas, we sort every candidate action by what it reveals and what it changes:

Decision table: branch finder and block card exposed, balance, transactions and payees held

What we expose to Siri AI now, and what waits for the entity unlock fix.

  • Branch and ATM finder: public data, .alwaysAllowed. The one intent that should work on a locked phone.
  • Block card: an intent with .requiresLocalDeviceAuthentication. Blocking a lost card is the one action a customer wants from a voice assistant, and it is safe to over-trigger. The CardEntity it takes shows only a masked label (“Debit card ending 4821”) and carries the same policy.
  • Balance, transactions, payees as entities: held. These are exactly the case in 190573761: the entity requires unlock, and Siri AI may show it without asking. We revisit when a later beta lists the issue as resolved.
  • Pay a bill, transfers: not intents at all. They stay inside the app behind the app’s own login and step-up checks. A bank’s transaction signing does not belong in an assistant flow, whatever the policy.

The intent from the list, as a sketch:

Swift sketch of BlockCardIntent with requiresLocalDeviceAuthentication

The policy is a static property on the intent, next to the title.

perform() still checks the app’s own session before calling the card service. The authentication policy proves someone unlocked the phone; it does not prove the bank session is valid.

The Android side: AppFunctions 1.0.0-rc01

The AppFunctions release notes list 1.0.0-rc01 on 4 Nov 2026 with three artifacts: appfunctions, appfunctions-compiler and appfunctions-testing. The only change in rc01: “Version bump to RC and remove legacy aggregation compiler option.” Two beta-era renames to watch if you started on an alpha: AppFunction became AppFunctionDeclaration (alpha13), and AppFunctionContext was removed (alpha12).

dependencies {
    implementation("androidx.appfunctions:appfunctions:1.0.0-rc01")
    ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-rc01")
}

From the AppFunctions guide:

  • “AppFunctions is available on devices running Android 16 or higher.” The guide’s service class carries @RequiresApi(36).
  • Functions are suspend functions annotated @AppFunctionDeclaration(isDescribedByKDoc = true); the KDoc becomes the description the agent reads.
  • A service extending AppFunctionService, annotated @AppFunctionServiceEntryPoint, hosts them; the library “generates an XML schema file that lists all the declared AppFunctions”.
  • “Discovering and calling other apps’ AppFunctions requires the privileged EXECUTE_APP_FUNCTIONS permission, which Android grants only to authorized system assistants.”
  • The guide does not describe any user confirmation step, and the page is marked experimental.

The same block-card action, as a sketch:

class CardFunctions(private val cards: CardRepo) {
    /**
     * Blocks the customer's card so it cannot be used.
     * @param cardId Id of the card to block.
     */
    @AppFunctionDeclaration(isDescribedByKDoc = true)
    suspend fun blockCard(cardId: String): Boolean {
        if (!cards.sessionIsValid()) return false
        return cards.block(cardId)
    }
}

There is no authenticationPolicy equivalent in what Google documents. So on Android the session and lock-state check lives in the function body, and anything that reads balances stays out until the bank’s own risk team has signed off.

Play’s rule from 14 April 2027

Google Play’s policy deadlines table carries an AppFunctions row, announced 29 Oct 2026, deadline 14 Apr 2027: “Developers building AppFunctions must comply with all existing Google Play policies”, and “AppFunctions are strictly prohibited from deceiving or manipulating AI agents”. The same sentence also prohibits bypassing security controls and interfering with other apps. For a bank, the practical reading is: KDoc descriptions must say exactly what the function does, and a function must never do more than its description.

Side by side

Question iOS and Android
Who can call iOS: Siri AI, Shortcuts, Spotlight (if discoverable)
Android: Callers with EXECUTE_APP_FUNCTIONS
Minimum OS iOS: iOS 16 for the policy API; Siri AI from 27.3 beta
Android: Android 16
Lock gate iOS: authenticationPolicy, default alwaysAllowed
Android: Not documented; check in code
Description the AI reads iOS: Title, parameters, entity display
Android: KDoc
Store rule iOS: Siri AI terms “more to share soon”
Android: Play policy from 14 Apr 2027

What to check in your own app

  1. Search the iOS target for every AppIntent and AppEntity type. Any without an explicit authenticationPolicy runs or shows on a locked phone.
  2. Set isDiscoverable = false on intents that exist only for widgets or in-app use.
  3. On the 27.3 betas, lock the phone and ask Siri for each exposed entity. If it shows without an unlock prompt, hold that entity.
  4. On Android, put a session check at the top of every @AppFunctionDeclaration function, and read your KDoc as an agent would: it is now part of your API contract.
  5. Watch the 27.3 release notes for 190573761 moving to resolved before exposing any account data.

Made by the team behind this post

Apps from our studio

  • Goes with this post

    BMDB.fun

    Your Bollywood world at a glance, with links straight to the OTT app that streams each film.

    Android TV · Web · Mobile

    Get
  • Goes with this post

    Cardigami

    Pop-up greeting cards that rise out of the fold on iPhone Duo.

    iPhone · App Store

    Get
  • Nix

    The Mac uninstaller that finds what the Trash leaves behind: caches, logs, derived data and saved states.

    macOS

    Get
  • OneClick QuitAll

    Quit every running app in one click. See memory and CPU first.

    macOS · Mac App Store

    Get

Need this built? Let’s talk.

We build and run apps for Mac, TV, mobile and the web, and write about what we learn.