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 type | What official documentation supports | What still needs a runtime or product test |
|---|---|---|
| Model location | Apple 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. |
| Eligibility | Device 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. |
| Language | The framework exposes supportedLanguages and supportsLocale(_:) checks. | Whether a specific prompt, dialect, format, and expected output work well for the app’s task. |
| Context | The 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 version | Apple 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.
- 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.
- Check model availability in the running app. Before displaying the action as ready, read
SystemLanguageModel.default.availabilityand 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. - Check the requested locale and token budget. Inspect
supportedLanguagesor callsupportsLocale(_:)for the locale the task needs. UsetokenCount(for:)to inspect the prompt and session transcript, andcontextSizeto understand the current runtime boundary. This prevents the app from assuming that the UI language and model language support are identical. - 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.
- 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.
- 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.
- 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.