Apple’s New AI Tools for Developers: What App Builders Need to Know

I spent the weekend after WWDC 2026 reading Apple’s developer docs and rebuilding two of my apps against the new toolchain. Here’s what actually matters if you build Apple AI tools into a real product.

The short version: Apple gave developers a bigger on-device brain, a new framework for running your own models, free Private Cloud Compute access for smaller teams, and the kind of agentic coding in Xcode that finally makes “AI pair programmer” feel accurate. Almost every assumption we had about the Foundation Models framework a year ago is now wrong.

If you build for iOS, iPadOS, macOS, watchOS, tvOS, or visionOS, this is the update you’ve been waiting for. Apple AI tools stopped being a demo and started being a platform.

What actually shipped at WWDC 2026

Apple’s June 8, 2026 keynote wasn’t about a chatty new Siri, even though Siri AI was the headline. The developer story was buried in the Platforms State of the Union and a stack of WWDC26 sessions.

Apple Intelligence is Apple’s personal intelligence system that ships on-device and through Private Cloud Compute across iPhone, iPad, Mac, Apple Watch, and Apple Vision Pro.

Here’s the high-level view of what changed in the developer toolchain:

• The Foundation Models framework is no longer just for text. It now supports image input, third-party server models, multi-agent Dynamic Profiles, and it’s going open source.
• A new Core AI framework replaces the Core ML story for generative AI, with PyTorch conversion and ahead-of-time compilation.
• Xcode 27 is 30% smaller, Apple-silicon-only, and adds first-class agentic coding with Anthropic, OpenAI, and Google’s agents.
• App Intents is now mandatory. SiriKit is dead. Your app’s content becomes discoverable through Siri AI, Spotlight, and Shortcuts via entity and intent schemas.
• The Evaluations framework and an fm CLI with Python SDK ship alongside, so you can hill-climb prompts and run a Python-based eval pipeline.

Pull-quote: “Developers are at the heart of the Apple ecosystem, and our goal is to provide them with the best possible tools and technologies to build the future.” — Susan Prescott, Apple’s VP of Worldwide Developer Relations, Apple Newsroom, June 8, 2026

The Foundation Models framework in 2026

The Foundation Models framework is the Swift API Apple ships for tapping into Apple Intelligence’s on-device LLM. It launched last year with iOS 26, and 2026 is the year it grows up.

Foundation Models framework is Apple’s native Swift API for accessing on-device and Private Cloud Compute language models, with optional vision, tool calling, and dynamic profile support.

If you remember the 2025 version, you remember a 3-billion-parameter text-only model with a 4,096 token context window. None of that is true anymore.

Here’s what’s new per the Apple Developer WWDC26 Apple Intelligence guide and the What’s new in the Foundation Models framework session:

1. Multimodal prompts. You can pass images alongside text, and the on-device model can call Vision framework tools like OCR and barcode readers directly.
2. Server-side model support. The same Swift API now reaches Apple’s Private Cloud Compute models, plus Claude, Gemini, or any provider that conforms to the new Language Model protocol.
3. Dynamic Profiles. You can swap models, tools, and instructions on the fly inside a continuous session, the missing piece for real multi-agent app experiences.
4. Free Private Cloud Compute access for developers in the App Store Small Business Program with fewer than 2 million first-time App Store downloads.
5. Open source release of the framework later this summer, confirmed at the MacRumors Platforms State of the Union recap, June 9, 2026.
6. A Python SDK and an fm CLI for evaluating prompts from your laptop, pre-installed on macOS 27.

If you’ve ever written let session = LanguageModelSession() in Swift, your code isn’t changing. What the session can reach is.

Meet the new Apple Foundation Models

At WWDC26, Apple introduced the third generation of Apple Foundation Models, or AFM 3. There are five of them, and which one you get depends on the device and the request.

The full architecture and benchmark numbers come from Apple Machine Learning Research, “Introducing the Third Generation of Apple’s Foundation Models,” June 8, 2026, with a great plain-English explainer in 9to5Mac, “Apple’s third-generation Foundation Models explained,” June 11, 2026.

Comparison: The 5 Apple Foundation Models (AFM 3)

Model	Where it runs	Size	What it’s best at
AFM 3 Core	On-device	3B parameters, dense	General text, default for most app prompts
AFM 3 Core Advanced	On-device (top Apple silicon)	20B sparse MoE, 1–4B active per request	Expressive voices, dictation, image understanding
AFM 3 Cloud	Private Cloud Compute	Server-class	Server-side workhorse, multimodal reasoning
ADM 3 Cloud (Image)	Private Cloud Compute	Server-class diffusion	Image generation, Genmoji, Image Playground
AFM 3 Cloud Pro	Google Cloud, NVIDIA GPUs	Largest	Agentic tool use, complex reasoning

Two things matter for how you build.

First, AFM 3 Core Advanced is the real story. It’s a 20-billion-parameter model with a sparse Mixture-of-Experts-style architecture built on a research technique Apple calls Instruction-Following Pruning, where the model lives in flash storage and pulls only the experts it needs into DRAM. That’s how you fit a 20B model onto an iPhone.

Second, AFM 3 Cloud Pro is the first Apple Foundation Model that doesn’t run on Apple silicon. It runs on NVIDIA GPUs inside Google Cloud, under an expanded version of Private Cloud Compute. Apple’s argument: the privacy guarantees still hold because the entire stack, from firmware to inference software, lives inside Apple’s attested trust boundary.

The human-evaluation numbers from the same Apple research post: AFM 3 Core was preferred over the 2025 on-device baseline on 45.6% of general text prompts (vs. 23.3% the other way). AFM 3 Cloud was preferred on 64.7% of prompts (vs. 8.7%), and delivered a roughly 36% relative improvement in overall response satisfaction. That’s the generational jump the framework was missing.

A real Foundation Models workflow

If you haven’t written any Foundation Models code yet, the 2026 version is a one-screen Swift snippet. Apple has documented a general guided-generation pattern that hasn’t really changed. Here’s roughly what production code looks like:

import FoundationModels

// 1. Create a session with a Dynamic Profile
let profile = DynamicProfile(
    model: .afm3Core,
    tools: [CalendarTool(), ReminderTool()],
    instructions: "You are a calm, concise daily planner."
)
let session = LanguageModelSession(profile: profile)

// 2. Multimodal input (new in 2026)
let prompt = MultimodalPrompt(
    text: "What's in this image and when should I schedule it?",
    image: photoFromCamera
)

// 3. Guided generation straight into a Swift struct
struct PlanItem: Codable, Generable {
    let title: String
    let suggestedDate: String
    let priority: Int
}

let plan = try await session.respond(
    to: prompt,
    generating: PlanItem.self
)

That block hits the on-device model by default. To fall back to Private Cloud Compute, you swap .afm3Core for .afm3Cloud. To call Claude or Gemini, you implement Apple’s new Language Model protocol, register the provider, and keep the same call site.

A few things I learned the hard way so you don’t have to: the on-device default runs around 30 tokens per second on an iPhone 16 Pro, per FrameSixty’s iOS 27 walkthrough, June 11, 2026. The on-device session context window is still capped at 4,096 tokens per Apple’s TN3193 technote. Use Dynamic Profiles to chunk and summarize for longer workflows. Apple’s built-in guardrails are strict by default, and you can disable the developer-applied layer if you need flexibility, but you inherit the responsibility for what your model says.

Core AI replaces Core ML for generative workloads

If you need to bring your own model, the framework story is now Core AI, not Core ML. 9to5Mac reported in March 2026 that Apple was preparing a Core ML replacement, and WWDC confirmed it on stage.

Core AI is Apple’s new framework for running generative AI models on device, with PyTorch tooling, ahead-of-time compilation, and dedicated Instruments.

What that gives you, per the Meet Core AI WWDC26 session:

• PyTorch models converted through Core AI PyTorch extensions into Core AI assets tuned for Apple silicon.
• Ahead-of-time compilation to lean on unified memory and the Neural Engine.
• Dedicated Instruments for profiling tokens per second, memory, and thermal behavior.
• A new model-authoring session, Dive into Core AI model authoring and optimization, and an integration session, Integrate on-device AI models into your app using Core AI.

If Core ML felt like the right tool for a CNN classifier and a wrong tool for an LLM, that’s because it was. Core AI is the right tool for an LLM.

Xcode 27 is where the agentic coding story lives

The single biggest day-to-day change for me has been Xcode 27. Apple’s developer news release calls it “the best place to code with agents,” and after two weeks in the beta, I don’t disagree.

Three things changed:

1. Agentic coding is real. Xcode 27 brings Anthropic’s Claude Agent, OpenAI’s Codex, and Google’s agents into the editor. Conversations have interactive planning, multi-turn Q&A, and a canvas that renders Markdown, code diffs, and previews side by side. Agents can run tests, try ideas in Playgrounds, and interact with the simulator through a new Device Hub.
2. The IDE got smaller and faster. Xcode 27 is Apple-silicon-only, 30% smaller than Xcode 26, and Xcode Cloud builds are now up to 2x faster for Metal and visionOS apps.
3. It’s pluggable. You can extend Xcode with custom skills, the Model Context Protocol, and the Agent Client Protocol. GitHub and Figma are the first two partners to ship seamless installs.

If you remember the rough edges of Xcode 26.3’s agentic coding release, the Apple Newsroom post from February 3, 2026 flagged the same problems I ran into. Most are fixed in 27. Crash recovery, credential storage, and project context are all more reliable.

App Intents is now the way your app shows up in Apple Intelligence

This is the part most teams will underestimate.

App Intents is Apple’s framework for exposing your app’s content and actions to Apple Intelligence, Siri AI, Spotlight, Shortcuts, and Visual Intelligence, all through a single system of schemas.

At WWDC26, Apple made App Intents the required path for Siri AI integrations. SiriKit is deprecated. Two new ideas changed what you can ship:

• Entity schemas contribute your app’s content to Spotlight’s semantic index, so it shows up in personal-context understanding across Apple Intelligence. Apple’s guide frames this as “discoverable by Apple Intelligence with attribution back to your app.”
• The View Annotations API gives Siri on-screen awareness. Siri can now act on what’s literally in front of the user, in any view you annotate, through a conversation. See the advanced App Intents session and a new AppIntentsTesting framework for validating the whole thing without UI automation.

The upshot: the same App Intents code that surfaces a button in Shortcuts now feeds Siri AI, Spotlight, and Visual Intelligence. One implementation, four surfaces.

How to start building with Apple AI tools this week

If you have an existing app, here’s the order I’d touch things in:

1. Adopt the Foundation Models framework in one screen. A “summarize this article” button or a “rewrite this in a friendlier tone” tool. Ship it, get telemetry on token usage and latency, then expand.
2. Turn on App Intents schemas for your core entities. You don’t have to redo your UI; the schema does the heavy lifting.
3. Try the free Private Cloud Compute tier. If you’re under 2 million first-time App Store downloads and in the App Store Small Business Program, Apple’s Private Cloud Compute access page walks through eligibility. You can run Apple Foundation Models on PCC with no per-token cost.
4. Bring your own model with Core AI if the on-device default isn’t strong enough for a specific task. The PyTorch conversion path is the lowest-friction on-ramp.
5. Wire an agent into Xcode 27 and set up the fm CLI plus Apple’s Python SDK on GitHub for evals.

The OS 27 developer betas are out today, June 8, 2026. The public release ships this fall. If you’ve been waiting for a real reason to upgrade your minimum OS target, this is it.

What I’m still watching

Three things I can’t fully verify yet: the on-device footprint of AFM 3 Core Advanced (weights live in flash, but the activation budget per request varies by use case), the exact scope of the open-source Foundation Models framework release later this summer, and the production latency of AFM 3 Cloud Pro on Google’s NVIDIA fleet. The security story is well documented; the perf story isn’t.

I’ll write follow-ups as those land. For now, open Xcode 27 beta, write ten lines of Foundation Models code, and feel the difference.