Apple Intelligence: What On-Device AI Means for Your Bill

Prices and model names in this article were updated on 31 October 2026.

Apple's Foundation Models framework lets an app run a language model on the user's iPhone, iPad or Mac. There is no API key, no network call and no per-token charge. At WWDC on 8 June 2026 Apple introduced its third generation of models (AFM 3) and widened the offer. Apps can now also call Apple's Private Cloud Compute (PCC) model. Apple says PCC "is available with no cloud API costs to developers who have less than 2 million first time downloads."

For apps whose users are on Apple devices, that moves a share of LLM spend to zero. The rest of this article covers how large that share can be.

What runs where

Apple's 2026 line-up has two on-device language models and two server language models, plus ADM 3 Cloud for image generation. Sizes and stated uses below come from a developer write-up of Apple's WWDC material. The second table, on access and cost, comes from Apple's own WWDC session.

What a third-party app can call, per Apple's session "What's new in the Foundation Models framework":

Apple describes the PCC model as "the very same one that powers many of the Apple Intelligence features". The session does not name it. Users get a daily PCC allowance, higher with an iCloud+ subscription. Apple gives no numbers for either. The session does not say what happens to PCC costs above 2 million downloads.

The same write-up lists the supported devices. They are the iPhone 16 family, iPhone 15 Pro and Pro Max, iPad mini with A17 Pro, M1-or-later iPads and Macs, and Apple Vision Pro. Mainland China has no Apple Intelligence pending regulatory approval. The new Siri is not available on iPhone or iPad in the EU at launch.

The Foundation Models API

The framework is a Swift API. Apple added a Python SDK (apple_fm_sdk) in 2026. Apple says it "gives you direct access to the very same on-device model." macOS 27 also brings the models to the command line through an fm tool.

A summarisation call, with the availability check you need before relying on the model:

import FoundationModels

func summarize(_ feedbackText: String) async throws -> String? {
    let model = SystemLanguageModel.default
    guard case .available = model.availability else {
        return nil  // not eligible, turned off or not ready: use your fallback
    }
    let session = LanguageModelSession()
    let response = try await session.respond(
        to: "Summarize the following customer feedback concisely:\n\n\(feedbackText)"
    )
    return response.content
}

For structured extraction, the @Generable macro turns a Swift type into a schema the model must fill. @Guide constrains a field. This is Apple's version of the JSON-schema structured output that OpenAI and Anthropic offer.

import FoundationModels

@Generable
struct CustomerIntent {
    @Guide(.anyOf(["billing", "technical", "general"]))
    var category: String
    var urgency: String
    var sentiment: String
}

let session = LanguageModelSession()
let response = try await session.respond(
    to: "Classify this support message: \(message)",
    generating: CustomerIntent.self
)
let intent: CustomerIntent = response.content
print(intent.category)  // "billing", "technical" or "general"

The 2026 framework also reports token usage per response. Log it, because it tells you what the same traffic would cost on a paid API:

print(response.usage.input.totalTokenCount)
print(response.usage.output.totalTokenCount)

Two more 2026 changes matter for cost. Anthropic and Google publish Swift packages for their models, and a LanguageModel protocol lets local and server models back the same LanguageModelSession. Escalating from the free tiers to a paid model can therefore reuse the same session code.

The cost math for developers

Take a document summarisation feature: 10,000 daily users, each summarising one document a day, about 2,000 input tokens and 300 output tokens per request. That fits inside the 8,192-token context in Apple's sample.

Against a frontier model the saving is large. Against the cheapest API tier it is about $105 a month for this workload. Gemini 3.8 Flash's price doubles on 1 January 2027, to $1.50 / $7.50. The cheapest LLM APIs article covers the low end by task.

Quality is the open question. According to the dev.to write-up, Apple publishes only human-preference comparisons against its own 2025 models. For text, raters preferred AFM 3 Core in 45.6% of comparisons and the 2025 model in 23.3%. The write-up found no third-party benchmarks, so test the model on your own examples before you count the saving. The small language models guide has a 200-example test that fits this case.

Practical integration patterns for business apps

Where it falls short

Complex reasoning. Multi-step analysis, comparing several documents and careful argument still belong to frontier models such as Claude Sonnet 5.5 or GPT-6.1 Sol. The PCC model now has a reasoning option, which narrows the gap for some tasks at no cost below the download threshold.

Non-Apple users. If your app also runs on Android, Windows or the web, those users need a cloud path anyway. Older iPhones without Apple Intelligence support do too. For enterprise fleets that are not Apple-first, this limits the saving a lot.

Regional availability. Mainland China has no Apple Intelligence pending approval, and the new Siri is not on iPhone or iPad in the EU at launch. Check availability before you plan a feature around it.

Model changes. Apple shipped "a new on-device model, rebuilt from the ground up" in 2026. Prompts and evals tuned on the previous model need a re-run after each major OS release.

Limits you cannot see. PCC has a per-user daily allowance with no published number. The on-device model can report itself unavailable. Design the cloud fallback first.

The hybrid strategy for Apple platform apps

1. Default to the on-device model for summarisation, classification, extraction and short generation.
2. Move to the PCC model when the input exceeds the on-device context or the task needs reasoning. It is free below 2 million first-time downloads.
3. Escalate to a paid cloud model only when the user asks for depth or the task type requires it.
4. Cache cloud results for repeated questions, so you pay once per answer rather than once per user.
5. Track the escalation rate, because it sets your bill.

The arithmetic is simple. Monthly cloud cost = requests per month × share escalated × cost per request. Take the example above and let 10% of the 300,000 monthly requests escalate to GPT-6.1 Sol. The bill is 30,000 × $0.0070 = $210 a month instead of $2,100.

The case is strongest for apps with large Apple user bases doing routine language tasks. Take a CRM app with 50,000 daily users, each running one such summary a day. It would pay $10,500 a month on GPT-6.1 Sol and $525 on GPT-6 Luna. On the device it pays nothing. Against the frontier price that is real money. Against the cheap tier the stronger arguments are latency, offline use and data that never leaves the phone. The October 2026 pricing snapshot has the current prices behind these figures.

What to do next

List the LLM features in your iOS or macOS app and the token counts of a typical request. Mark the ones that fit in 8,192 tokens and need no reasoning. Those are candidates for the on-device model. Run your eval on device against your current cloud model, then price the escalation share with the formula above. If you want help with the test or the routing, we do this work at Divero.

Sources

• Apple: What's new in the Foundation Models framework (WWDC26, session 241)
• MacRumors: Apple outlines AI and developer tool updates at the 2026 Platforms State of the Union
• Apple's third-generation foundation models: a developer's read on WWDC 2026 (dev.to)
• Exploring the Foundation Models framework (Create with Swift)
• OpenAI models
• Anthropic pricing
• Gemini API pricing