Apple Foundation Models PCC: From Entitlement to Runtime

If you are building an iOS or macOS app with summarization, rewriting, translation, or document Q&A, Apple Foundation Models deserves a closer look.

The important part is not simply that Apple has another language model. The important part is the integration model: once an eligible developer account has been assigned the required entitlement, an app can access Apple’s Foundation Model through a native Swift framework without embedding an OpenAI, Claude, or Gemini API key in the product.

That sentence is easy to misunderstand.

Private Cloud Compute, or PCC, is not a generic REST endpoint that any app can call. An assigned entitlement does not guarantee that every device can use the model. A successful Xcode build does not prove that an Archive, TestFlight build, or real device request will work.

The real engineering problem is the complete path from account authorization to runtime availability.

On-device Foundation Models and PCC solve different problems

Foundation Models provides a unified Swift interface for Apple’s intelligence models. For application developers, the two most relevant execution environments are:

• An on-device model, optimized for local execution, lower latency, and strong privacy, but constrained by device resources.
• A Private Cloud Compute model, designed for larger context and more demanding reasoning while following Apple’s privacy-oriented cloud processing model.

Apple’s WWDC26 material describes the PCC model as supporting a 32K context window and multiple reasoning levels. That makes it more suitable for long documents and multi-step analysis, but it does not mean every task should be forced into the cloud.

A better product abstraction is a model policy:

Short text and lightweight rewriting
        ↓
On-device Foundation Model

Long documents and more demanding reasoning
        ↓
Private Cloud Compute

Specialized workflows and advanced agents
        ↓
Optional third-party model provider

There is another important boundary: Foundation Models does not turn a PDF into a knowledge base automatically. Your app still needs to extract text, preserve page structure, split content, assemble context, and write the result back to Markdown. The model is one part of the document pipeline, not the whole pipeline.

PCC access is a Managed Capability, not a cloud account

Apple’s developer access model is based on a Managed Capability. The capability eventually participates in the same chain as the App ID, entitlements, provisioning profile, and code signature.

Layer	Object	Question it answers
Account authorization	Capability Request / Team	Has Apple approved this team?
Application identity	App ID / Bundle Identifier	Which app is authorized?
Project declaration	Xcode Capability / .entitlements	What does this target request?
Signed artifact	Provisioning Profile / Code Signature	What does the installed app actually carry?

The PCC entitlement key looks like this:

<key>com.apple.developer.private-cloud-compute</key>
<true/>

Adding this key manually does not grant access. It is only a project declaration. The declaration becomes meaningful only when it matches Apple’s account authorization, the App ID, the provisioning profile, and the final signature.

How to request Apple Foundation Models PCC access

Apple’s web interface may change, but the current workflow follows this shape.

1. Confirm eligibility and team permissions

Apple’s current PCC documentation states that developers in the App Store Small Business Program with fewer than two million first-time App Store downloads can use Apple Foundation Models running on PCC with no cloud API cost, provided the account has been assigned the relevant entitlement.

This is not an unlimited, permanent free server promise. Eligibility, quotas, system support, and product policies still apply. If an app later exceeds the download threshold or the developer leaves the Small Business Program, Apple says the developer will be notified and will need to migrate to another solution within the stated transition period.

Before applying, verify that:

1. The correct Apple Developer team is selected.
2. The target App ID already exists.
3. The Bundle Identifier exactly matches the Xcode project.
4. The applicant has the required team role. Organization teams generally need the Account Holder to submit capability requests.
5. The product can explain why PCC is needed and what happens when it is unavailable.

2. Submit the Capability Request

The usual path is:

1. Sign in to Apple Developer.
2. Open Certificates, Identifiers & Profiles.
3. Go to Identifiers and select the target App ID.
4. Open Capability Requests.
5. Find Access to models on Private Cloud Compute and select Request.
6. Describe the app, the user flow that needs PCC, the test and distribution plan, and the fallback behavior.

“I want to try Apple’s new model” is a weak application rationale. A stronger explanation is concrete:

A user imports a PDF into MarkZen. The app extracts and structures the document locally, sends long-context chapter summarization to PCC, then writes the result back to Markdown. If PCC is unavailable, the app uses the on-device model for smaller tasks or explains that the long-context operation must be retried later.

3. Wait for the capability to become Assigned

The Capability Requests page is where you should verify the status. Assigned means that the entitlement has been allocated to the account or team scope.

It is an important milestone, but it is not the end of the process. You still need to configure the App ID and the Xcode target.

Configure Xcode: automatic signing first

For an individual developer or a small team, automatic signing is the most practical way to validate the first path through Debug, Release, and a real device.

In the app target:

1. Open Signing & Capabilities.
2. Confirm the Team and Bundle Identifier.
3. Enable Automatically manage signing.
4. Add Access to models on Private Cloud Compute.
5. Check that Xcode created or updated the .entitlements file.
6. Confirm that the current configuration uses a new managed provisioning profile.

If the project includes a widget, Share Extension, or another target, do not assume that the main app’s capability automatically applies to every extension. Configure only the targets that need the model and verify their Bundle Identifiers separately.

The signing flow looks like this:

Add the capability in Xcode
        ↓
Update project entitlements
        ↓
Update the App ID on Apple Developer
        ↓
Regenerate or download the provisioning profile
        ↓
Sign the app with the final entitlement

For CI or manual signing, make that process explicit. After changing the App ID capability, regenerate the distribution profile and ensure that CI is not using an old cached profile.

The smallest PCC call

The following example shows the basic PCC session. Because this API is evolving, always check the current Xcode and SDK documentation for availability checks and error types.

import FoundationModels

let model = PrivateCloudComputeLanguageModel()

guard model.isAvailable else {
    // Fall back to the on-device model or explain the unavailable state.
    return
}

let session = LanguageModelSession(model: model)

do {
    let response = try await session.respond(
        to: "Summarize this document in five concise bullet points."
    )
    print(response)
} catch {
    // Production code should distinguish quota, network, and service errors.
    print("Foundation Models request failed: \(error)")
}

There is no URLSession, Bearer token, or application-owned API key in this example. That does not mean PCC is a public HTTP API. The system framework, device state, and entitlement system coordinate access.

Foundation Models can also work with third-party providers that conform to its model abstraction. Keep the billing and authentication boundaries clear: Apple’s PCC conditions apply to Apple’s model, while a third-party provider decides whether its model needs an API key and how it charges for usage.

What to verify after Build Succeeded

This is the most important part of the workflow.

Check the Xcode configuration

Make sure Signing & Capabilities has no red errors and that the Team, Bundle Identifier, certificate, and provisioning profile match. Pay special attention to configuration scope. A capability enabled only for Debug does not prove that Release or Archive contains it.

Inspect the signed app, not just the source file

For a signed .app, inspect the final entitlements:

codesign -d --entitlements :- "/path/to/MyApp.app"

You can also decode the embedded provisioning profile:

security cms -D \
  -i "/path/to/MyApp.app/embedded.mobileprovision" \
  -o /tmp/profile.plist

/usr/libexec/PlistBuddy \
  -c "Print :Entitlements" \
  /tmp/profile.plist

Confirm that the signed artifact contains com.apple.developer.private-cloud-compute and that the App Identifier, Team Identifier, and distribution type match the build you are testing.

Complete Archive and device validation

Treat validation as a sequence:

Debug build succeeds
        ↓
Release build succeeds
        ↓
Archive and TestFlight upload succeed
        ↓
The compatible device installs the app
        ↓
Runtime availability check passes
        ↓
The request succeeds and failure has a fallback

Device support, Apple Intelligence settings, region, system state, network conditions, and quotas can all affect PCC availability. A valid signature and an available model are separate facts.

A practical architecture for document apps

For a PDF-to-Markdown product such as MarkZen, I would split the AI workflow into four layers:

PDF import
  ↓
Local text extraction, page preservation, and structure detection
  ↓
On-device model for short tasks: heading cleanup and local rewriting
  ↓
PCC for long-context tasks: chapter summaries, action items, and cross-section rewriting
  ↓
Markdown validation and export

This design limits the impact of model unavailability. If PCC is temporarily unavailable, short operations can continue on-device. When network access or quota becomes available again, the app can retry only the long-context operation.

For advanced coding, multi-tool agents, web-connected workflows, or specialized models, a third-party provider may still be the better choice. Apple PCC’s advantage is system integration, privacy-oriented processing, no user-managed API key, and low platform friction. It does not need to replace every frontier model.

Three common mistakes

Mistake 1: Manually adding the entitlement and assuming access is granted

The .entitlements file is a declaration. It cannot bypass Managed Capability approval or refresh an old provisioning profile. Confirm account authorization first, update the App ID and profile, then inspect the signed artifact.

Mistake 2: Treating a Debug success as a Release success

This usually comes from configuration scope, an expired distribution profile, a cached CI profile, or inconsistent settings between the main app and an extension. Comparing the actual signing configuration and final .app is more useful than repeatedly cleaning the build folder.

Mistake 3: Interpreting “no API key” as “unlimited and always free”

The current terms include program membership, download thresholds, account assignment, quotas, and device requirements. A production app needs a plan for unavailable regions, unsupported devices, exhausted quotas, and transient service errors.

The conclusion: use PCC by default, but do not make it your only path

If your product targets Apple users and focuses on summarization, rewriting, translation, document organization, or Markdown cleanup, Foundation Models PCC is worth evaluating as a default engine. It can reduce API key management, backend proxying, and per-token infrastructure complexity.

The reliable architecture accepts three facts: PCC has an application gate, runtime availability is conditional, and its strengths are different from those of the strongest general-purpose models. Use the on-device model for lightweight tasks, PCC for longer and more demanding tasks, and third-party providers as optional advanced backends behind a replaceable adapter.

If you are applying for PCC or debugging entitlements, Archive, TestFlight, quotas, or runtime availability, share the exact failure mode. Those details are often more useful to other Apple developers than another generic model comparison.

References

• PrivateCloudComputeLanguageModel — Apple Developer Documentation
• Build with the new Apple Foundation Model on Private Cloud Compute — WWDC26
• What’s new in the Foundation Models framework — WWDC26
• Private Cloud Compute — Apple Developer
• Provisioning with managed capabilities — Apple Developer
• Private Cloud Compute entitlement — Apple Developer Documentation

---

Originally written for Apple platform developers building privacy-aware AI features.