What’s new in Shortcuts

Hi! My name is Duraid and I'm a member of the Shortcuts team.

With Shortcuts, you can combine actions that you perform in your apps every day and quickly run them from different places across the system, like Siri, Control Center, Action Button, and more.

In this session, I'm going to share some exciting improvements coming to Shortcuts and how you can make your app's actions and content fit right in.

I'll start by going over updates to the way automations are set up, and a set of new automation types that are available. Next, I'll go over the Use Model action and a new way to debug its behavior. And finally, I'll cover storage, a feature that lets you persist data between runs of a shortcut. Let's dive in! With automations, you can make your shortcuts run automatically in response to events, for example, here's a shortcut that runs every time I leave work. It calculates my route home, and sends a message to my partner Helen with my estimated time of arrival.

Automations now live directly in the Shortcuts editor, alongside the actions that run in a shortcut and they're easier to set up than ever. To browse them and add one to a shortcut, you can visit the "Automation" section in the editor.

In addition to the current set of automations, there are also three new types available: the screenshot automation, which runs when a screenshot is saved, the keyboard automation, which triggers when an external keyboard is connected or disconnected, and the notification automation, which runs when a notification is received from a specific app. I'll dive into an example of how I can use the notification automation with an app I'm working on.

This is Soup Chef, an app that allows me to browse soups and order them for delivery.

When a soup delivery is close, my app sends a notification with the driver's name, and how soon to expect them.

I like to turn my porch lights on when I get that notification so the driver can find the door when it's late at night.

I'd love for that to happen automatically! To do this, I've created a shortcut that turns on my porch lights, and has my living room HomePod announce that my soup is about to arrive. The notification automation is triggered when I receive a notification from the Soup Chef app.

I don't want it running for every notification from the app so I've added a filter for the word "arriving." That way, it only runs when the app is notifying me that my soup is arriving. Now, my delivery person will always have a safe, well lit walk up to my front door.

This works well because my app provides a concise, informative notification. The driver's name makes it distinct, the verb "arriving" makes it specific, and the time until arrival makes it actionable. These details make the notification easy to parse and interpret within a shortcut.

If you follow the best practices for designing notifications in the Human Interface Guidelines, your users will be able to harness your notifications to build powerful automations like this one. Next, I'll talk about the Use Model action. The Use Model action lets you tap into the power of large language models, directly within your shortcuts. Now, it's more powerful than ever. With access to new, more capable Apple Intelligence models that have the ability to go out to the web for up-to-date information.

All of these models can work with content from your apps, like this example, where the action is able to find the events related to my upcoming trip to Montreal, when a large list of upcoming events is passed in.

Let's go back to the Soup Chef app. I'd like to build a shortcut that picks a soup I'll like and lets me quickly order it. I'll call it Soup of the Day.

To build this, my shortcut will need access to my app's soup data. Using an EntityPropertyQuery in App Intents, I've already exposed a Find Soups action that fetches all soups from my app with the ability to filter to the ones available today.

I've also built an action called Order Soup, which takes a soup as a parameter, asks me to confirm, and places the order.

I'll start building my shortcut by stringing these together with the Use Model action.

This shortcut finds today's available soups, then uses a model to pick one that matches my spice level preference. Let's run it! It picked a chicken tortilla soup. But in Soup Chef, that's one of the milder options on the menu. I'm looking for something spicier.

When a model produces a result you didn't expect, you might want to know exactly what the model saw, so you can understand what went wrong. There's a way to do exactly that: you can now inspect the model transcript and see everything that was passed to the model, in its raw format. I'll add a Show Content action right after the Use Model action. Next, I'll select the Transcript property on its output in the Show Content action.

And now, when I run my shortcut, I can see the transcript.

Here, I can see the exact soup entities that were passed to the model and I can expand each one to understand exactly what the model saw.

Here is the structured representation of a Soup entity that was passed to the model. And these are the properties exposed on that entity. With just the name and availability, the model doesn't have enough to accurately judge spice level. Adding an ingredients property, which lists each ingredient and its quantity, should give the model what it needs. Let's add that.

Here's my SoupEntity. It exposes properties for the name and availability of a given soup.

Let's add ingredients here as well as a simple array of strings.

Each string will contain an ingredient and its quantity per serving.

I've removed the "Show Content" action that was used to debug, and I'll try running the shortcut again with the change.

Now that the model has access to each soup's ingredients, it picked a Tom Yum soup that has some real heat! I think I'll order that one! For more on building App Intents for the Use Model action, check out "Develop for Shortcuts and Spotlight with App Intents" from WWDC25.

Finally, I'll talk about Storage! With Storage, you can now save content within a shortcut, to persist it between runs.

In the shortcuts editor, there's now a view that allows you to create, view, and edit the values that are stored in a shortcut. You can also create a global value which is shared across multiple shortcuts. This is useful for data you need to access in more than one shortcut, like an API key.

These three actions enable you to retrieve and update this data from within your shortcut, unlocking so many possibilities: from simple shortcuts that count or log items, like daily coffees, to advanced ones that track richer context across runs.

Let's take a look at how I can use storage to improve a shortcut I use every day.

I closely follow motor racing, and I have a shortcut that shows me a technical fact every morning! The Use Model action is designed to be deterministic which is great when you want predictable model output. But for this shortcut, I want fresh facts every morning.

I can use the Storage actions to achieve this. I'll start by retrieving a stored value that I'll name "Previous Facts". That'll be my list that contains every past fact.

Next, I'll pass it to the model, and ask the model to stay away from these previous facts.

Once the model responds with a fact, I'll use the "Add to List" action which outputs a list with the new fact appended. I can use the setter action to store the new list. Now, my shortcut will come up with something new every day! The great thing is that storage works with any type of data in Shortcuts, including App Entities. Using Storage, I'd like to make a final improvement to my Soup of the Day shortcut. I've noticed that when I run it, the model often picks the same soup several days in a row. I want to give the model a memory of recent selections so it can pick a different one every day. Just like my motor racing example, I'll use the Storage actions here.

With that, the Use Model action knows not to repeat past picks. And now, once I've run the shortcut a few times, when I open the storage view there's a list of previous soups! I've been building and running this shortcut on my iPhone, but the great thing is its stored values sync across my devices, so if I'm using my iPad, I can run the shortcut there and it'll remember my past soups. Because these values sync across devices, entities need a consistent identity across every device. An entity saved on iPhone should be identified by your iPad or Mac app as the same entity. For example, here's a simple shortcut that retrieves a stored soup and passes it into my "Order Soup" intent. Since the stored value may have originated on a different device, the order intent needs to recognize the soup no matter which device originally stored it.

To make this work, I ensured my identifier comes from a source that produces the same value on every device, not one that varies per device. My Soup app is backed by an online database of soups, so I use each soup's database row ID as its stable entity identifier.

So those are some of the new capabilities coming to Shortcuts! Next, try building shortcuts that integrate with your app to get a sense of what your users might want to automate. Refine your notifications so your users can build powerful automations. And finally, test your App Entities to make sure they play well with the Use Model action and Storage in Shortcuts.

"Your soup is almost here." Well, time to go pick up my soup! Thanks for joining me!