Add iOS app intents

Make the right parts of your app visible to the system

App Intents are one of the clearest ways to make an iOS app more useful outside its own UI. Instead of treating your app as a sealed destination that only works after someone launches it and taps around, use Codex to expose the actions and objects that should be available to Shortcuts, Siri, Spotlight, widgets, controls, and newer assistant-driven system experiences.

That is useful today for discoverability and automation, and it is a strong preparation step for a more assistant-driven future. If your app already knows how to compose, open, filter, route, or summarize something valuable, App Intents give the system a structured way to ask for that capability.

Start with actions and entities, not with every screen

The best first App Intents pass is usually not “mirror the whole app.” Ask Codex to identify:

• the few actions a user would want to trigger without navigating the full interface
• the app objects the system needs to understand to route those actions correctly
• the workflows that should open the app in a specific state versus the ones that should complete directly from a system surface

Apple’s App Intents guidance is a good frame here: define the action, define the entity surface the system needs, then make those actions discoverable and reusable across system experiences. The most useful references are Making actions and content discoverable and widely available, Creating your first app intent, and the system-experience sample Adopting App Intents to support system experiences.

Think in system surfaces, not just in shortcuts

The opportunity is broader than “add one shortcut.” A good App Intents surface can make your app useful in several places:

• Shortcuts, where users can run actions directly or compose them into larger automations
• Siri, where the app can expose meaningful verbs and deep links instead of only opening generically
• Spotlight, where app entities and app shortcuts become discoverable system entry points
• widgets, Live Activities, controls, and other intent-driven UI surfaces
• newer assistant-facing experiences, where structured actions and entities are much easier for the system to understand than arbitrary UI flows

Follow a real app pattern

This usually works best when the app adopts a structure like this:

• a dedicated App Intents target instead of scattering intent types across unrelated app files
• AppShortcutsProvider entries for high-value user actions like composing a post or opening the app on a specific tab
• small AppEntity types for things the system needs to reason about, such as accounts, lists, and timeline filters
• intent handling that routes back into the main app scene cleanly, so an invoked intent can open the right compose flow or switch the app to the right tab

That is the pattern I would ask Codex to follow for most apps: start with a small system-facing action layer, keep the entity surface narrow, and wire a predictable runtime handoff back into the app when the intent needs the main UI.

Ask Codex to design the first intent surface

The strongest prompt here is one that gives Codex your app’s core objects and top user actions, then asks it to choose the smallest useful first App Intents surface instead of blindly exposing everything.

Practical tips

Expose verbs users actually want outside the app

Good first intents are usually things like compose, open, find, filter, start, continue, or inspect. If an action is only useful after a long in-app setup flow, it may not belong in the first App Intents pass.

Keep entities smaller than your model layer

The system usually does not need your full persistence model. Ask Codex to define the smallest app entity surface that still gives Siri, Shortcuts, and Spotlight enough context to route and display the action correctly.

Treat this as assistant infrastructure, not only a shortcuts feature

Even if your first release only visibly improves Shortcuts or Siri, the deeper win is that your app starts speaking in structured actions and entities. That makes it easier to participate in future system and AI-driven entry points than an app whose capabilities are only encoded in taps and view hierarchies.