Apple Foundation Models on macOS 27: Local AI, fm CLI, Python SDK and PCC Boundaries

Short answer: Apple Foundation Models on macOS 27 are an operating-system model surface, not a downloadable open-weight model or a general cloud API. A compatible Apple-silicon Mac with Apple Intelligence enabled can use the on-device model through the Foundation Models framework; macOS 27 also adds the pre-installed fm command-line tool, while Apple’s Python SDK supports prompt experiments and batch evaluation. A separate PrivateCloudComputeLanguageModel route can reach Apple’s larger server model when the app and user satisfy Apple’s current eligibility and quota rules. The safe starting point is to check runtime availability, record the route and device, test a small consented dataset, and treat every model, quota, region, and beta detail as version-sensitive.

This guide answers the practical macOS 27 question: what can a developer access today, which boundary is local versus server-assisted, and how can the first evaluation avoid mistaking a community claim or an Apple demo for an independent benchmark?

Foundation Models in one decision table

Apple’s Foundation Models documentation and the macOS 27 “What’s New” page are the authority for the framework surface. The table separates the four routes because they have different access, privacy, cost and failure assumptions. A shared LanguageModel protocol does not make their operational boundaries interchangeable.

What Apple is—and is not—exposing

The public developer contract is an API, not a model download. Apple documents a system model object, a session, availability checks, guided generation, tools, image prompts and (in the newer framework) model-provider abstractions. It does not, in the current developer material checked for this article, publish a downloadable Foundation Model weight file, a public model card with a developer-selectable model-size ID, or a universal “Apple 3B” or “Apple 20B” identifier for SystemLanguageModel.

That distinction matters because the launch discussion in r/LocalLLaMA contains questions and conflicting comments about model size, context and tokens per second. Those comments are useful discovery signals, but they are not Apple documentation or controlled measurements. Do not build a capacity plan from a reply claiming a particular parameter count or speed.

Access prerequisites on macOS 27

• Hardware: Apple says macOS 27 is compatible with Macs using Apple silicon, including M-series and A-series chips. An Intel Mac is outside that macOS 27 compatibility statement.
• Apple Intelligence: The system model still needs Apple Intelligence enabled on a compatible device. The framework exposes availability instead of promising that every installation can answer immediately.
• Software: Build a Swift app with the macOS 27 SDK/Xcode 27 materials when you need the new platform features. Apple’s current pages also label the Xcode 27 materials as beta, so keep a final-OS verification step.
• Language and region: Apple Intelligence features vary by language and region. The device may be eligible for macOS 27 while a particular Apple Intelligence capability is not available in the user’s configured language or region.
• Python path: Apple’s official Foundation Models SDK for Python README lists macOS 26.0+, Xcode 26.0+, Python 3.10+ and Apple Intelligence enabled on a compatible Mac. That package minimum is not a promise that every macOS 27-only feature exists on an older SDK.

The Python minimum is easy to misread. The SDK repository supports the earlier Foundation Models baseline, while the macOS 27 SDK adds image and server-model capabilities described in Apple’s WWDC26 material. Pin the SDK and OS used for an evaluation, and check the feature’s current documentation before treating a successful import as proof that a newer capability is available.

Model access: use availability, not guesses

For the on-device route, start with SystemLanguageModel and ask whether the model is available. Apple documents availability reasons such as a device that is not eligible or a model that is not ready. This check belongs in the app’s normal state machine, not only in a developer command. A graceful unavailable state is necessary for unsupported hardware, disabled Apple Intelligence, regional rollout differences and model preparation.

Use contextSize and tokenCount(for:) where the current SDK exposes them. The model can change with an OS update, and hard-coding a context number or assuming that a prompt tuned on one Mac is portable can turn into a silent quality regression.

The official tooling paths

fm for a fast first pulse

Apple’s WWDC26 session on the fm CLI and Python SDK says fm comes pre-installed with macOS 27. The documented command family includes fm for help, fm chat for an interactive conversation, fm respond for inline responses, and fm schema for schema-oriented structured output. The session also demonstrates image input, a model-selection option and switching a chat to Private Cloud Compute.

On a target Mac, begin with fm --help and a harmless synthetic prompt. Treat the exact flags and model-selection syntax as OS-version-sensitive; the command’s help output is the current local contract. Never give an LLM unrestricted file-write, deletion, shell, purchase or messaging authority merely because Apple’s session demonstrates an automation. Add a reviewable plan and an explicit user confirmation before any consequential action.

Python for repeatable prompts and evaluation

The official Python SDK is useful when the question is “which prompt and output contract survives a small test set?” Apple documents asynchronous sessions, streaming text, guided generation, tool calling and batch analysis through the Python ecosystem. That makes it suitable for a local notebook or script that records inputs, outputs, model route, device/OS metadata and pass/fail checks. It is not evidence that a Python process can use the Foundation Models runtime on Windows, Linux or an Intel Mac.

Swift and Core AI are different layers

The native Swift framework is the app-integration path for Apple’s system model and conforming providers. Core AI is the separate macOS/iOS/Xcode 27+ route for loading and running custom models on Apple silicon. Apple’s Core AI integration documentation shows how a custom model can participate in a Foundation Models session; it does not turn that custom model into Apple’s system model, and Apple’s example model size is not a universal hardware requirement or performance guarantee.

A small official-pattern Python check (unexecuted)

The following is a deliberately small adaptation of Apple’s repository example. It is not executed in this package: no authorized Mac, Apple Intelligence session or account credential was available. The purpose is to show the first availability branch, not to claim a working result on your machine.

import asyncio
import apple_fm_sdk as fm


async def main():
    model = fm.SystemLanguageModel()
    is_available, reason = model.is_available()

    if not is_available:
        print("Foundation Models unavailable:", reason)
        return

    session = fm.LanguageModelSession()
    response = await session.respond(
        "Return one sentence describing a synthetic product brief."
    )
    print(response)


if __name__ == "__main__":
    asyncio.run(main())

Prerequisites: a compatible Apple-silicon Mac, Apple Intelligence enabled, the Xcode/SDK agreement accepted, Python 3.10 or newer, and the package installed with pip install apple-fm-sdk. Expected flow: construct the system model, receive an availability result, create a session, then await a response. Failure cases to preserve: unavailable device or model, an SDK/OS mismatch, a blocked or malformed guided output, cancellation, and a model response that is unsuitable for the feature. The method names and return shape should be rechecked against the installed SDK before use.

On-device versus Private Cloud Compute

There is a documented version nuance around context. The WWDC26 code note shows 4096 for macOS 26.0 and 8192 for macOS 27 on newer devices, while the same session’s comparison describes the on-device model as 4K and PCC as 32K. The safe engineering rule is to call the current contextSize property and leave room for system- and device-level variation. Do not publish one universal on-device number as if it applied to every Mac.

PCC is therefore a fallback or deliberate route, not an invisible extension of local inference. The session can use the same broad Foundation Models abstractions, but the app must make connectivity, quota, eligibility and user-facing failure states explicit.

Eligibility, quotas and beta boundaries

Apple’s App Store Small Business Program page describes the PCC eligibility condition used in the current macOS 27 materials: an app enrolled in the program with fewer than 2 million total first-time App Store downloads can apply for the Private Cloud Compute entitlement. The entitlement, account status and approval are not inferred from an app’s local test. Ask Apple’s developer systems for the current state before designing a cost model.

For an eligible PCC integration, Apple’s WWDC26 guidance recommends checking quotaUsage.isLimitReached, detecting isApproachingLimit, and offering the documented limit-increase suggestion in persistent UI rather than throwing a dismissible alert. Use Xcode’s “Simulate Apple Foundation Models Availability” debug option to exercise those states. This is a product requirement as much as an API detail: a daily limit should not look like a random outage.

The Foundation Models overview also carries Apple’s beta-software notice, and the PCC type is documented as beta in the current API lineage. macOS 27 itself is available, but a page, SDK or API marked beta can change. Recheck the release notes, availability cases, entitlement process and current signatures immediately before shipping.

Privacy and consent: keep the route visible

• On-device: explain that the selected Apple system-model route is designed for local inference, but do not extend that promise to a provider selected through the LanguageModel protocol.
• PCC: disclose that the request leaves the device and needs a network, then link your product’s behavior to Apple’s current PCC privacy and quota documentation. Apple’s “not stored” and “used only for the request” wording is a vendor claim and should remain attributed.
• Third-party provider: use the provider’s own authentication, contract, billing and retention terms. Never put a provider API key in a shipped binary; use a backend or the provider’s documented secure flow.
• User data: start with synthetic or redacted inputs. Obtain consent before processing personal messages, recordings, documents or images, and log only what is necessary for an evaluation.
• Tools: keep tools narrow and auditable. A model can propose a file move or an email; the application should validate the arguments and obtain confirmation before executing a consequential action.

A safe first evaluation workflow

1. Freeze the environment. Record Mac model/chip, macOS build, Xcode/SDK version, Python version, SDK version, Apple Intelligence language/region and the route under test.
2. Run availability first. Record the exact availability result and reason. Do not silently substitute PCC or a third-party model when the on-device route is unavailable.
3. Create a small, representative set. Use synthetic or consented examples that include normal inputs, ambiguous instructions, long context, malformed fields and a refusal/safety case. Define expected output before prompting.
4. Measure the contract, not just prose quality. Check structured-output validity, required fields, tool-call arguments, refusal behavior, cancellation, response time and context exhaustion. If a route changes, label the result by route.
5. Exercise failure states. For PCC, test no network, unavailable entitlement, near-quota and quota-reached states. For on-device, test device-not-eligible and model-not-ready states. For tools, test malformed and unauthorized arguments.
6. Use Apple’s evaluation tooling where it fits. Xcode’s Evaluations framework and the Python SDK’s batch-analysis path can help compare prompt revisions. A vendor demo or a notebook chart is an evaluation aid, not an independent benchmark.
7. Repeat after OS changes. Apple documents that model behavior and context can change with OS updates. Store a dated baseline and rerun the important cases before shipping a prompt-tuned feature.

What the community signal adds—and what it cannot prove

The r/LocalLLaMA seed post is valuable because it surfaced a real discovery question: people want to know what Apple exposes, whether it is genuinely local, and how it compares with downloadable models. The thread includes questions about model identity and first-use reports, but also contradictory claims about parameter count, context and speed. Some replies are clearly opinion, humour or second-hand information. None was accompanied by a controlled test that can establish a general performance result.

The editorial takeaway is narrower and more useful than a model verdict: document the access boundary and give readers a reproducible evaluation checklist. A Mac-specific prompt result should remain a Mac-specific observation with its OS and hardware recorded.

How this fits DMT’s existing coverage

If you are deciding whether to run an open model yourself, start with the local LLM hardware and runtime guide. For a model-selection experiment, the local-versus-hosted Qwen evaluation guide covers a different model and audience decision. Applebot crawling and training controls belong in the Applebot search and training controls article.

This article owns the macOS 27 Foundation Models developer surface: system-model access, fm and Python tooling, availability, PCC eligibility and safe evaluation. It does not replace the Gemini 3.8 Live API overview, and it is not a generic local-model benchmark or a full voice/transcription architecture guide.

Frequently asked questions

Does Apple publish a downloadable Foundation Model or public model ID?

Not in the current developer contract checked for this guide. Apple exposes model objects such as SystemLanguageModel and PrivateCloudComputeLanguageModel, not a public weight download or a universal parameter-count selector. Treat community model-size claims as unverified until Apple publishes a source.

Can Foundation Models run on an Intel Mac?

macOS 27’s compatibility statement covers Macs with Apple silicon, including M-series and A-series chips. An Intel Mac is not within that documented macOS 27 support boundary. Check the actual device and availability result rather than assuming that a package installation is enough.

Is Private Cloud Compute a normal API that needs my API key?

Apple’s WWDC26 integration describes PCC through the Foundation Models framework and says there is no developer API key or end-user authentication flow for that route. Access still depends on Apple’s entitlement/eligibility process, network connectivity and a per-user daily quota. That is different from a general public cloud endpoint.

Is the Python SDK only for macOS 27?

Apple’s repository currently lists macOS 26.0+, Xcode 26.0+ and Python 3.10+ as minimum requirements. Newer features such as image input or server-model access may require the macOS 27 SDK and current framework surface. Check the installed package documentation and compile/runtime version before relying on a feature.

Can Apple’s WWDC demo be treated as a benchmark?

No. It is an attributed Apple demonstration of a workflow. Use it to understand the intended API shape, then run a controlled, dated evaluation on the target Mac. Do not turn a vendor demo, a Reddit reply or a single local result into a general performance claim.

Bottom line

macOS 27 makes Apple’s Foundation Models surface easier to try: the native Swift framework remains the app path, fm lowers the cost of a first prompt, and the official Python SDK adds a practical evaluation loop. The important boundary is that “local AI on a Mac” does not mean open weights, universal model IDs or unlimited cloud-like capacity. Start on-device, check availability and context at runtime, keep PCC as an explicit quota- and entitlement-aware route, and measure the feature on the hardware and OS you intend to support.

Sources and scope

Primary sources checked for this guide include Apple’s Foundation Models documentation, What’s new in macOS 27, the fm and Python SDK session, the PCC session, the official Python SDK repository, Small Business Program eligibility, macOS 27 compatibility and the community discovery thread. Apple documentation and beta notes can change; recheck the current OS, SDK, entitlement, quota and region before publication or implementation.