Apple Foundation Models: Availability Is a Runtime Check

SystemLanguageModel is Apple’s on-device text model; device, region, Apple Intelligence state, readiness, language, and OS updates affect availability.

Last reviewed: September 2026
ParametersNot disclosed
Size (quantized)Not disclosed
Context lengthNot disclosed
Modalitytext
Licenseapple-proprietary
Min RAMNot disclosed
VersionSystemLanguageModel (OS-managed)
Released2025-09

What the framework describes

Apple documents SystemLanguageModel as its on-device text foundation model for Apple Intelligence. The SystemLanguageModel reference says availability depends on whether the device and region support Apple Intelligence. It also directs apps to check availability before using the model and exposes properties for the current model’s variant, context size, supported languages, locale checks, and token counting.

Those are runtime-oriented APIs, not a universal hardware guarantee. A symbol appearing in an SDK, a project compiling against the framework, or an older supported-device list does not establish that a model is ready for a person’s current app session. Apple’s documentation distinguishes availability states such as device ineligibility and a model that is not ready. An application needs an intentional state and fallback for each one.

There is another important boundary: Apple’s system model is versioned along with operating-system updates. The current framework reference describes multiple model versions corresponding to different OS ranges, and Apple’s Foundation Models updates page tells developers to test prompts as the system model changes. A parameter count published in an earlier research report is not necessarily a stable, user-visible specification for every future model version. The current framework provides contextSize and tokenCount(for:) so an app can inspect relevant runtime values instead of hard-coding a stale number.

Claim typeWhat official documentation supportsWhat still needs a runtime or product test
Model locationApple identifies SystemLanguageModel as an on-device text model for Apple Intelligence.Which route the application selected for a specific request, including any separate server path.
EligibilityDevice and region affect availability; the API returns availability states.Whether the model is ready on a user’s current device and settings at the moment of use.
LanguageThe framework exposes supportedLanguages and supportsLocale(_:) checks.Whether a specific prompt, dialect, format, and expected output work well for the app’s task.
ContextThe runtime exposes contextSize and tokenCount(for:).How much of the app’s complete request and output can be accepted and completed in its workflow.
Model versionApple updates system models with OS releases.Whether an app’s prompts and quality remain acceptable after the user updates the OS.

A Mac app scenario: summarize a private note

Imagine a macOS application that offers an on-device summary action for a selected note. A developer built the feature on one development machine and wants to say that it works on Mac without sending note text to a server. A safe decision requires more than a successful build: the user’s Apple Intelligence state, locale, current system model version, and selected request route all matter.

  1. Record the tested environment. Capture the Mac model family, macOS build, app build, region and language settings, and development SDK. Because the model can change with OS updates, keep the exact OS release alongside each result. Avoid turning one development machine into a universal Mac support statement.
  2. Check model availability in the running app. Before displaying the action as ready, read SystemLanguageModel.default.availability and handle the documented unavailable cases. A user may have an ineligible device, Apple Intelligence turned off, a model that is still becoming ready, or another unavailable state. Keep the selected state visible and explain what the person can do next.
  3. Check the requested locale and token budget. Inspect supportedLanguages or call supportsLocale(_:) for the locale the task needs. Use tokenCount(for:) to inspect the prompt and session transcript, and contextSize to understand the current runtime boundary. This prevents the app from assuming that the UI language and model language support are identical.
  4. Run a fixed, privacy-safe task. Use synthetic notes with reviewed reference summaries. Include names, dates, negation, and a short multi-paragraph example. Keep the prompt, requested output, and evaluation rubric fixed. Verify the returned summary against the specific task requirements instead of saying “the model works” based on an open-ended demo.
  5. Test unavailable and interruption states. Repeat with Apple Intelligence disabled, an unsupported locale, model-not-ready state, a long input, cancellation, and app relaunch. Record whether the app offers a useful retry, asks the user to shorten the input, or falls back to another route. A hidden fallback changes the privacy and behavior contract.
  6. Verify the request route and data boundary. If the product promise is local processing, confirm that the selected request uses the on-device SystemLanguageModel path. Check whether another feature, app service, analytics SDK, backup, or explicit Private Cloud Compute path transmits data. A successful Foundation Models call alone does not audit the whole application’s network behavior.
  7. Retest after operating-system model updates. Apple’s update documentation notes that the system model can change along with OS versions. Re-run the same prompt and acceptance set after a model-version update, and check token counts, output format, refusal behavior, and latency only if you have a defined measurement method and raw records. Preserve differences rather than silently changing the prompt to hide regressions.

Publish the scope, not a guessed device list

For an app team, a useful support statement describes the mechanism: the application checks SystemLanguageModel availability at runtime, checks whether the locale is supported, and handles model readiness. If a product needs a public device list, derive it from Apple’s current eligibility guidance and validate the exact supported operating-system range. Do not infer availability from “Apple silicon,” a chip family, a framework import, or an article written for an older system version.

The same discipline applies to context and model size. Apple’s developer API can provide the runtime context size, while research publications describe particular model generations and configurations. These are not interchangeable evidence. If the app sets a maximum prompt size, disclose whether the number came from the runtime or a fixed assumption. If a request is too long, test and document truncation or a user-guided shorter-input path rather than promising that every document fits.

This page does not claim that Cove uses Apple Foundation Models or that a specific Cove app is available on Apple platforms. It describes Apple’s public framework boundary and an evaluation method. For a Mac-specific checklist covering region, locale, and local-execution proof, see the Apple Foundation Models on macOS guide. For broader model comparison, use the on-device model leaderboard, and treat any unmeasured device or quality claim as unknown.

Frequently asked questions

Is Apple Foundation Models an on-device model?

Apple describes SystemLanguageModel as its on-device text model. The framework also relates to server-side options such as Private Cloud Compute. An app should record the route it selected rather than assuming every request associated with the framework stayed on device.

Can every Mac use Apple Foundation Models?

Do not assume so. Apple says availability depends on device and region, and the model may not be ready. Query availability during the app session and handle each state. A successful build only proves compilation, not that the model is available to a particular user.

Does Apple publish a fixed context size for every current system model?

The framework exposes a runtime contextSize property and token-counting APIs. Since the system model can change with OS updates, query the runtime and test the app’s prompt instead of treating an older research value as permanent.

How should I check language support?

Use the current supported-language set or call supportsLocale(_:) for the target locale. Then test the actual prompt and expected output. A locale check does not certify translation quality for every task or dialect.

Does a successful local request prove no information ever reaches a server?

No. It can establish that one request used the observed local model path, but it does not audit analytics, backups, crash reports, other app features, or later fallback. Review the full application data flow separately.

Editorial status: this English guide was revised against Apple Developer documentation on 2026-09-24. The Chinese edition is a complete translation for the site owner’s native-language review; that review is pending.

FAQ

Is Apple Foundation Models an on-device model?

Apple documents SystemLanguageModel as the on-device text foundation model used by Apple Intelligence. The framework also relates to server-side model options such as Private Cloud Compute, so an app should identify its selected route and check availability rather than treating the framework name as proof that every request stayed on device.

Can I assume every Mac can use Foundation Models?

No. Apple says availability depends on Apple Intelligence eligibility for the device and region, and the model may not be ready. Check SystemLanguageModel.availability at runtime and handle unavailable states. A compiling app, marketing device list, or framework import does not prove that a particular task is currently available on a user’s Mac.

Does Apple publish a fixed context size and parameter count for the current system model?

Apple’s current framework exposes contextSize and tokenCount(for:) so apps can inspect the system model available in that runtime. Apple has published parameter information for research generations, but the system model can change with OS updates; do not treat an older research parameter count as a permanent current-device specification.

How do I check whether my prompt language is supported?

Use the current SystemLanguageModel.supportedLanguages or supportsLocale(_:) API and record the result with the OS version. The locale check may account for language fallbacks; it does not establish quality for every task or dialect. Test the actual prompt and expected output in the language your app needs.

Does a successful Foundation Models request prove the data never left the device?

It proves that a request completed through the observed route only if the app records that route. It does not automatically audit analytics, backups, crash reports, network fallback, or other app services. Review the selected model path and data flow separately before making a privacy statement.

Citations