What's the difference between Apple Core AI, Foundation Models, and MLX?

Three layers of the iOS 27 on-device AI stack, with different jobs. Foundation Models is the sealed system LLM Apple ships with the OS — you call into it, you don't choose the model, and the API is high-level (generate text, structured output, tool use). Core AI is the lower-level inference framework introduced at WWDC 2026 — you bring your own model file, specialize it for the target hardware, and run inference with explicit control over CPU/GPU/Neural Engine scheduling. MLX is Apple's open-source array framework for training and research, the layer underneath both, where you build and train custom models on Apple silicon. As a rule: Foundation Models for default AI features in your app, Core AI when you need to ship a specific third-party or custom model on-device, MLX when you're training.

Should I use Apple Foundation Models or call out to Claude / ChatGPT instead?

Use Foundation Models when your app needs simple on-device intelligence — text summarization, structured output extraction, writing tools — without latency or privacy concerns of a server round-trip. It's free, runs offline, and ships with the OS. Use cloud Claude / ChatGPT / Gemini when you need frontier capability your app's users will pay for (Foundation Models is intentionally a small on-device model and cannot match Fable 5 or GPT-5.5 on hard reasoning), or when your app already integrates with a cloud LLM provider for cross-platform parity. Hybrid is common in production iOS apps in 2026: Foundation Models for fast on-device tasks, cloud LLM for hard tasks gated behind a paywall.

Did Apple actually replace Core ML with Core AI?

Not replace — added alongside. Core ML is still present in iOS 27 for traditional ML model deployment (vision, audio, time-series, traditional ML pipelines converted from frameworks like PyTorch or TensorFlow). Core AI is a new framework that sits below Foundation Models and Core ML for cases where developers want explicit control over LLM-style model execution on Apple silicon. The distinction Apple draws: Core ML is the converter+runtime for fixed models with the converter making hardware decisions; Core AI gives you the model-execution surface where you drive specialization, caching, and inference scheduling yourself. Both will coexist in iOS 27, with Apple positioning Core AI as the right choice for new LLM-style integrations and Core ML for existing converted-model workflows.

Can I run Llama 5 or Qwen 3.6 on iPhone using Core AI?

Technically yes for smaller models; practically constrained by device RAM. Core AI gives you the Swift API to load model files (.aimodel format), specialize them for Apple silicon, and run inference across the CPU, GPU, and Neural Engine. The constraint is RAM: iPhone 17 Pro ships with 12 GB unified memory; iPad Pro M5 with 16 GB. That fits 7B parameter models comfortably at 4-bit quantization (~4 GB), 13B models with tight headroom, and rules out 70B+ models. Practical recipe in mid-2026: take a 3B–7B parameter open model (Llama 5 8B, Qwen 3.6 7B, Gemma 4 4B), export it with Apple's Core AI PyTorch extensions (coreai-torch; ready-made recipes for many open models are in apple/coreai-models), compress it to 4-bit with Core AI Optimization, package it as an .aimodel, ship with your app or download on first run. Inference at conversational latency on Neural Engine is achievable. The MLX community has working examples for most current open-weight models.

Apple Core AI vs Foundation Models vs MLX: which should I use now that iOS 27 has shipped?

iOS 27 has been public since September 14, 2026, so all three are production options. Use Foundation Models first: Apple's on-device system model (and, with a managed entitlement, the Private Cloud Compute model) behind one Swift API, free and offline. Use Core AI when you must ship your own model: you export it from PyTorch to a .aimodel file with Apple's coreai-torch tools or a recipe from apple/coreai-models, and Core AI specializes and runs it on the CPU, GPU and Neural Engine. Use MLX on a Mac for training, fine-tuning and research; it is not what you ship inside an iPhone app, and the official path into Core AI starts from PyTorch, not MLX.

Quick Answer

Apple Core AI vs Foundation Models vs MLX: Which iOS 27 AI Framework?

Published: June 15, 2026 • Updated: October 20, 2026

Apple Core AI vs Foundation Models vs MLX: Which iOS 27 AI Framework (October 2026)

Apple’s WWDC 2026 reorganized the on-device AI stack into three distinct layers: Foundation Models for system-LLM features, Core AI for custom model execution, and MLX for research and training. This page explains what each does, when to use which, and the practical limits in iOS 27.

Last verified: October 20, 2026, against Apple’s Core AI and Foundation Models documentation, the apple/coreai-models repository and the iOS 27 release. First written June 15, 2026 from WWDC 2026 sessions and iOS 27 developer beta 1.

What changed as of October 2026

iOS 27 is out. It shipped to the public on September 14, 2026; the frameworks below are no longer beta APIs. Core AI is listed in Apple’s documentation for iOS, iPadOS, macOS, Mac Catalyst, tvOS, visionOS and watchOS 27.0+.
The Core AI model file is .aimodel, not .aiasset. The June version of this page used the wrong extension (corrected). AIModelAsset is the Swift type for an unspecialized model; the file on disk is .aimodel (compiled ahead of time: .aimodelc).
The official path into Core AI starts from PyTorch, not MLX. Apple ships Core AI PyTorch extensions (coreai-torch) to export models, Core AI Optimization for quantization and palettization, and apple/coreai-models with export recipes for open models (Qwen, SAM 3 and others), a Swift runtime package and coding-agent skills. The June page said MLX exports straight to Core AI; Apple documents no such path, so that line is corrected below.
Foundation Models opened up. iOS 27 adds PrivateCloudComputeLanguageModel (Apple’s server model, one line of code, behind a managed entitlement) and LanguageModelExecutor, which lets you plug another model provider into the same LanguageModelSession API.
New hardware. iPhone 18 Pro and Pro Max shipped in September with 12 GB of RAM (same as iPhone 17 Pro); the base iPhone 18 moves to spring 2027.
MLX is at v0.32.4 (October 14, 2026).

TL;DR

Foundation Models — Apple’s sealed system LLM. Free, ships with iOS 27, high-level API. Use for default on-device intelligence in apps.
Core AI — Low-level inference framework. Bring your own model. Use when you ship a specific third-party or custom model on iPhone/iPad/Mac.
MLX — Open-source array framework. Use for training, research, and quantizing models before deploying via Core AI.
Core ML — Still around for traditional ML conversion workflows.

The new stack at a glance

Layer	Surface	Model	Who decides quantization	Use case
Foundation Models	High-level Swift API	Apple’s on-device LLM (sealed)	Apple	Default LLM features in any app
Core AI	Mid-level Swift API	You bring your own (.aimodel)	You, via Core AI Optimization at export; SpecializationOptions on device	Ship custom or third-party LLM on-device
Core ML	High-level Swift API	You bring your own (converted .mlmodel)	Core ML converter	Traditional ML — vision, audio, classification
MLX	Python + Swift framework	Anything you build	You	Training, research, model conversion

When to use Foundation Models

Foundation Models is the easiest path and the default Apple wants most apps to take. iOS 27 gives every app access to:

Text generation — single-shot completion, streaming responses, conversational turn-taking
Structured output — Swift type-safe outputs via the @Generable macro
Tool use — your app declares Swift functions; the model calls them
Image input — Foundation Models can now accept images alongside text (new in iOS 27)
Custom skills — fine-tune behavior with developer-supplied skill definitions
Server option — same API surface can run on Apple’s Private Cloud Compute servers when the on-device model is insufficient (PrivateCloudComputeLanguageModel; requires a managed entitlement)
Other providers — since iOS 27, a LanguageModelExecutor can bridge LanguageModelSession to another model, local or server-side

The big trade-off: you don’t pick the model. Apple ships one on-device LLM and one server LLM, and you call them. They are intentionally small-to-medium models tuned for Apple’s privacy + battery constraints. They are not GPT-5.5 / Fable 5 / Gemini 3.5 Pro replacements.

Use Foundation Models when:

You want “smart text” features without managing model files
Latency, privacy, and offline operation matter more than peak quality
Your app should “just work” on every iOS 27 device

When to use Core AI

Core AI is the right tool when you need a specific model on-device that Foundation Models doesn’t ship. Apple’s framing: Core AI is the same inference framework that runs Apple Intelligence, now opened up for your app.

The Swift API revolves around five concepts:

AIModelAsset — unspecialized model (loaded from an .aimodel file); inspect structure and metadata cheaply
AIModel — specialized model for a specific device; runs inference
AIModelCache — stores device-specific artifacts so you don’t re-specialize on every launch
InferenceFunction — owns the weights and buffers; Sendable so you can run concurrently
ComputeUnitKind / SpecializationOptions — target CPU, GPU, or Neural Engine

The workflow: export your PyTorch model to an .aimodel file with coreai-torch (or use a recipe from apple/coreai-models) → load it → specialize it for the user’s device (one-time, cached) → instantiate an InferenceFunction → run inference with NDArray inputs and outputs.

Use Core AI when:

You’re shipping a specific model — your own, or a third-party open model
You need control over which compute unit runs inference
Foundation Models is too generic or too small for your workload

Practical examples mid-2026:

A photography app shipping a domain-tuned image-captioning model
A medical app running a specialized clinical-language model with HIPAA-relevant restrictions
A coding assistant shipping a code-specific 7B model for offline use

When to use MLX

MLX is the layer underneath, used by developers and researchers who train models or convert open-weight models for Apple silicon deployment. MLX gives you:

NumPy-like array operations on Apple silicon
Automatic differentiation
Unified memory model that avoids host↔device copies
Quantization to 4-bit and 8-bit for deployment
Fine-tuning (including LoRA via mlx-lm) on a Mac before deployment

You don’t ship MLX in a consumer app. Correction (October 2026): the June version said MLX has a direct export path to Core AI; Apple documents none. The supported route into Core AI is PyTorch → coreai-torch → .aimodel, so a model trained or fine-tuned in MLX has to come back through PyTorch weights first. The community ecosystem around MLX in mid-2026 has working ports of most current open-weight models (Llama 5, Qwen 3.6, Gemma 4, Mistral, DeepSeek V4 Flash, Phi family).

Use MLX when:

You’re training or fine-tuning a custom model
You need to convert an open-weight model to Apple silicon
You’re doing research on Apple hardware

Where Core ML still fits

Core ML hasn’t gone anywhere. iOS 27 keeps full support for .mlmodel files from coremltools conversions. The split:

Core ML — traditional ML model deployment, especially models converted from PyTorch / TensorFlow via coremltools. Fixed model, converter picks hardware. Best for vision classifiers, audio models, time-series, classical ML pipelines.
Core AI — LLM-style model execution where you want explicit control. Best for new generative AI integrations.

Existing Core ML deployments stay valid. Apple has not announced a deprecation timeline.

Practical sizing on current devices

Hardware running iOS 27 (October 2026):

Device	Unified RAM	Comfortable on-device model size
iPhone 18 Pro / Pro Max (Sept 2026)	12 GB	7B-13B at 4-bit quantization
iPhone 17 Pro	12 GB	7B-13B at 4-bit quantization
iPhone 17 (non-Pro)	8 GB	3B-7B at 4-bit
iPhone 16 series (most)	8 GB	3B-7B at 4-bit
iPad Pro M5	16 GB	13B-30B at 4-bit
MacBook Pro M5 Max	64-128 GB	70B+ at 4-bit

Apple Intelligence eligible devices (iPhone 15 Pro and later, plus Apple silicon iPads and Macs) get Foundation Models. Core AI runs on the same eligibility set.

Decision flow

Question 1: Does Foundation Models do what you need?
  Yes → Foundation Models. Done.
  No  → Continue.

Question 2: Do you need to ship a specific model?
  Yes → Core AI (production), coreai-torch + Core AI Optimization (build pipeline).
  No  → Continue.

Question 3: Is your model a converted traditional-ML pipeline?
  Yes → Core ML.
  No  → Core AI is probably the right answer.

Question 4: Are you training or doing research?
  Yes → MLX.

What competitors offer

For context — what other platforms ship in June 2026:

Google Android 16 — ML Kit + Gemini Nano on-device. Comparable to Foundation Models, less developer flexibility for custom models.
Windows 11 25H2 / Copilot+ PCs — Windows Agent Runtime + DirectML for custom model deployment. Comparable to Core AI.
Cross-platform — ONNX Runtime, llama.cpp, MLC LLM all work on Apple silicon but bypass Apple’s Neural Engine; Core AI is the right choice when you want NPU acceleration.

The big picture

The iOS 27 split — Foundation Models for default, Core AI for custom, MLX for training — is Apple’s bet that most developers want simplicity (Foundation Models) but a meaningful minority will ship custom models (Core AI). Mid-2026, both adoption paths look viable. If you’re starting an iOS app today and want any AI feature, default to Foundation Models. Reach for Core AI when you’ve hit a wall.

Sources

Apple Developer: Core AI documentation and Integrating on-device AI models in your app with Core AI
Apple Developer: Core AI overview
WWDC26 session 326: Integrate on-device AI models into your app using Core AI
GitHub: apple/coreai-models, apple/coreai-torch
Apple Developer: Foundation Models documentation, PrivateCloudComputeLanguageModel, LanguageModelExecutor
Apple Newsroom: Major updates for Apple’s software platforms are now available (September 2026)
MLX releases
MacRumors: iPhone 18 Pro and Pro Max RAM (confirmed via Xcode 27)

iOS 27 has been publicly released since September 14, 2026. The device-sizing table is our estimate from RAM, not an Apple specification.