How do I build agentic app experiences?

To build agentic app experiences with Apple’s Foundation Models framework, the key idea is to think in terms of agents: configurations that act on your app’s behalf with a specific goal, instructions, tools, and model settings.

What to use

Apple’s newer guidance highlights Dynamic Profiles as the main primitive for agentic experiences. A dynamic profile lets you switch the model session into different modes for different stages of your app.

How it works

A good pattern is to break your app into phases, with each phase getting its own profile. For example, in the Craft app shown in the WWDC sessions:

• Analysis mode: inspect user-provided images and record what the model finds
• Brainstorming mode: use what was learned to suggest ideas
• Generation mode: create the final tutorial or output
• Guidance mode: help the user while they work through the task, using in-progress context

Each phase shares some context, but has different priorities, so each can use a different profile with its own:

• instructions
• tools
• model configuration
• generation behavior

Building blocks emphasized by Apple

From the sessions, the main pieces are:

• Dynamic Profiles for agent state and phase-specific behavior
• Dynamic instructions to steer the model for each phase
• Model selection/configuration per phase to use the best capability for each step
• Transcript management and history transforms to control what context carries forward
• Custom modifiers and lifecycle modifiers to adapt behavior over time
• Orchestration patterns like:
  • baton-pass
  • phone-a-friend
  • skills
• Tool calling mode so the agent can take actions in your app

Practical advice

Apple also stresses that the best agentic experiences come from collaborating on the implementation and design first before code is written. In Xcode, that means using agents to explore ideas, plan the feature, refine it, and then orchestrate broader tasks.

Security

If your agent can take actions in the app, you should also think about risk mitigation. Apple recommends threat modeling and adding guardrails, especially for sensitive actions.

In short

Build agentic app experiences by:

1. splitting your app into task-focused phases
2. defining a dynamic profile for each phase
3. giving each profile clear instructions, tools, and model settings
4. managing context carefully with transcript/history controls
5. using orchestration and tool calling to let the agent act
6. designing with safety and user control in mind

The most relevant sessions are:

• Build agentic app experiences with the Foundation Models framework
• What’s new in the Foundation Models framework
• Secure your app: mitigate risks to agentic features

If you want, I can also summarize the Dynamic Profiles API specifically.