2026-10-27

Apple's 20B on-device Mac model: about 2 GiB of RAM, weak at math, scriptable

An outside-in teardown of Apple's Core Advanced model behind macOS 27's fm command, for Mac users wiring a free local model into scripts.

Picture a solo consultant on a recent MacBook who runs a nightly script that reads the day's client emails, pulls out names and deadlines, and tags each one by project. Today that script probably calls a cloud API, which costs a little per run and ships client text off the machine. The alternative, a local open model, sits in memory next to the browser, the editor and a dozen tabs, and drains the battery on the train home. Neither is a great fit for small, frequent, private tasks.

macOS 27 changes the default. According to a teardown published October 25, 2026 by The AI Realist, every Mac that can run Apple Intelligence now has a language model any script can call, and typing fm respond in a terminal gets an answer. The author measured what that model costs from the outside and found it small in memory and frugal with power, but weak at math and impossible to tune.

What it is

The model is Core Advanced, the larger of Apple's two on-device models. Per the teardown, it has 20 billion parameters, of which 1 to 4 billion are active at a time. It powers Siri's new voices and dictation, and the apps that call it. A GitHub issue in the open-source apfel project describes the split independently: AFM 3 Core is a 3B dense model, and AFM 3 Core Advanced is a 20B sparse model that goes only to M3-or-newer Macs with at least 12 GB.

Here is how each finding maps to the consultant's problem, all from the author's own measurements on an M3 Max MacBook Pro with 48 GB:

Memory next to your apps. Two seconds after a long request, Apple's model and its safety models held 2.0 GiB. Google's Gemma 4 26B A4B at 4 bits, a comparable mixture-of-experts model, held about 15 GiB. The author attributes the gap to Apple keeping the model in a 4.95 GB file in flash, choosing experts per prompt rather than per token, and compressing to about 2 bits.
Battery. On the same 20 grade-school math problems, Apple's model used about a third of the energy of the best open build the author ran (Gemma 3 4B, Gemma 4 E4B and Qwen3 4B on the GPU). It runs on the Neural Engine, which drew 4.2 watts reading a long prompt and 3.8 writing, with the GPU idle.
Scriptability. The Main Thread's hands-on says fm offers single responses, interactive chat, token counting, structured-output schemas and a Chat Completions server, fm serve.

The teardown also reports what Apple's developer guide lists the model for: summarizing, extracting entities, understanding, refining and classifying text, creative writing, tags and game dialog. The same guide, per the author, lists basic math, code and logical reasoning as "capabilities to avoid."

Alternatives, from the sources:

apfel: an open-source CLI and OpenAI-compatible server over the same Apple model. Its macOS 27 plan commits to staying 100% on-device and working on macOS 26 too; the trade-off is that its server was measured about 0.6 s slower per request than Apple's own fm serve.
Open models such as Gemma or Qwen on the GPU: in the teardown they beat Apple's model on math, at the cost of much more memory and energy.
Cloud decision models: the Feeder app's evaluation notes Vercel-hosted models with 32,000 to 1,050,000-token context windows and no guardrail refusals, but they cost money per input token and send data off the Mac.

Who it's for

Pick this up if you have an M3-or-newer Mac with 12 GB or more and a pile of short, private text jobs: tagging, extraction, summaries, rewrites. The price is zero and the memory cost, per the author's numbers, is small enough to leave running.

Skip it if your task involves math, code or multi-step reasoning, which Apple itself steers developers away from and where the model finished last of four in the author's test. Skip it if you need a specific model version, a fine-tune or long inputs. And on an M1 or M2 Mac you get the smaller 3B Core model with a 4,096-token window instead, according to the apfel issue.

Before and after

Before, for the hypothetical consultant:

Script collects the day's emails.
Each one goes to a cloud API with an extraction prompt, or to a local open model the user had to download, start and keep in memory.
Results come back; API spend or RAM pressure is the background cost.

After:

Script collects the day's emails.
Each one goes to fm respond, or to the local fm serve endpoint with model name system, which existing OpenAI-compatible client code can call by changing the base URL, per The Main Thread.
Text stays on the Mac. On macOS 27 the SDK returns typed errors such as contextSizeExceeded, guardrailViolation and refusal, according to apfel's plan, so the script can route failures to a fallback instead of crashing.
Anything involving arithmetic or reasoning still goes elsewhere.

Try it

The Main Thread's walkthrough (macOS 27.0, M4 Max) starts by checking the model is available and the license accepted:

fm available
fm license --status
# first run only: read the terms, then accept if you agree
fm license --show
sudo fm license

Then it starts the local OpenAI-compatible server, bound to your own machine:

fm serve --host 127.0.0.1 --port 1976

The server's /v1/models listed one model, system, owned by Apple. Clients pass system as the model name and a placeholder API key. The author's Java examples use Java 25, JBang 0.138.0 and LangChain4j 1.20.0, and the same walkthrough on DEV Community includes the full Ask.java.

On macOS 27 the model also takes images; apfel's plan reports this works straight from the CLI:

fm respond --image photo.jpg "describe"

The teardown's scripts and data are in a public repository, linked from the article, if you want to rerun the memory and energy measurements on your own Mac.

Where it breaks

The headline numbers are one person's. The 2.0 GiB and one-third-energy figures come from the author's repository on one Mac. We found no independent reproduction, and no independent quality or speed comparison against Qwen or Gemma on other local runtimes. Treat them as of October 2026, unverified.
Math is weak. It solved 13 of 20 problems in the author's test, last of four.
No control. Feeder's evaluation notes that the model variant is read-only, so an app can't request a better one; the system picks core3 or coreAdvanced3. Custom adapters are gone: apfel reports SystemLanguageModel.Adapter was obsoleted in 27.0. The teardown's author guesses that Apple still ships its own per-feature adapters and retrains them each OS release, but labels that an assumption.
Small context. Feeder measured an 8,192-token window on macOS 27.0.1; M1 and M2 Macs get 4,096, per apfel. The Main Thread cites Apple guidance of 4,096 and says the exact model behind system is an open question, so check contextSize at runtime.
Refusals and gaps. Feeder notes the model can refuse content, fail a guardrail or not support an article's language. apfel reports the 3B model's image descriptions are coarse; it called a metal plaque "a glass bottle wrapped in foil."
The cloud escape hatch has strings. Private Cloud Compute offers a 32,768-token window, per Feeder, but needs a managed entitlement Apple grants on request, requires the App Store Small Business Program and fewer than 2 million first-time downloads, has daily limits, and Apple says expanded access "will be available for a fee in the future."
Unconfirmed provenance. Apple's "collaboration with Google" line and the author's claim that the tokenizer is the measurable Google part go beyond what we could verify.