Apple Put a Free, Fully Offline LLM in the Mac Terminal: Meet the fm Command

A post going viral on Facebook makes a big claim: Apple has put a free, fully offline language model inside the macOS Terminal, with no account, no API key, no internet and no token bill, working on any Apple Silicon Mac from the M1 up. The claim is real in substance — Apple really did ship this — but two words in it need a qualifier, and this guide gives you the full, verified picture: what shipped, how to use it, what it costs (nothing, for the on-device model), and where its limits are.

What Apple actually shipped

With macOS 27 (codenamed Golden Gate), Apple added a command-line tool called fm — short for Foundation Models — pre-installed at /usr/bin/fm. It talks to the same on-device language model family that powers Apple Intelligence features like Writing Tools, except now you can reach it from a Terminal window instead of only from inside an app built in Xcode. Apple demonstrated it in its WWDC26 session on scripting with Foundation Models, and it is documented as part of the Foundation Models framework that developers previously reached only through Swift code.

The important shift is not a new model. It is access: the model that used to require a project, a build and compiled Swift code now answers a one-line shell command, accepts piped text, returns structured JSON, and can even serve a local API endpoint for your scripts. No sign-up, no API key, no cloud account.

What you need before you start

• An Apple Silicon Mac — M1 or later. Intel Macs are not supported.
• macOS 27 — the fm tool ships with the OS; it is not a separate download.
• Apple Intelligence enabled, with the model available on your Mac. If the model has not downloaded yet, fm will tell you it is not ready.
• One admin step, once: review and accept the license. After that, any user on the Mac can ask questions from the command line.

Start by checking the tool and the model:

fm
fm available
fm license --status

Running fm with no arguments lists the commands it supports. fm available reports whether the system model is ready. If this is your first run, review the terms with fm license --show and accept them with sudo fm license if you agree. One first-hand report notes the machine answering System model available at this step.

Every command, explained

A note that applies to every flag below: exact options are OS-version-sensitive. The fm --help output on your own Mac is the current contract — if a flag here ever disagrees with it, trust the help output.

The two models: on-device vs Private Cloud Compute

This is where the viral post needs its qualifier. fm offers two models, and only one of them is offline:

So "free, fully offline, no token bill" is exactly true for the default system model — and that is the model most people will use most of the time. The pcc model is the bigger, server-side option you switch to deliberately with --model pcc when a job needs more room or image understanding. Nothing about your prompt is sent anywhere unless you choose that model.

Using it: from first question to script

The simplest possible use is one line:

fm respond "Summarise this release note in one sentence"

Because the answer goes to stdout, it composes with everything Unix already does. Pipe text straight in:

cat notes.txt | fm respond "List the three action items as JSON"

For work you want to parse reliably, build a schema first and pass it back in. This is the feature that turns the tool from a chat toy into a pipeline component — instead of regexing free text, you get JSON in a shape you defined:

fm schema object --name AppsIdentified --string app_names --array > schema.json
fm respond "What apps are visible in this screenshot?" --image Screenshot.png --model pcc --schema schema.json
# {"app_names": ["Messages", "Mail", "Calendar"]}

For interactive work, fm chat holds a conversation you can return to, and /model inside the chat switches it to the cloud model mid-session. And for tools that already speak the OpenAI-style API, fm serve is the bridge — point your client at your own machine instead of a cloud endpoint:

fm serve --host 127.0.0.1 --port 1976

Keep that terminal open while you use it, and keep the host at 127.0.0.1 so the server stays on your Mac. First-hand reports confirm the local server answers health checks and lists one model, system, owned by Apple. Beyond the CLI, Apple also published a Python SDK (apple_fm_sdk, Python 3.10 or later, Xcode required) that mirrors the Swift framework — including tool calling, streaming and guided generation — for researchers and data work in notebooks.

What it is good at — and what it is not

The on-device model is a small system model, and honest coverage says the same thing: it shines at short, well-defined chores — a tag, a label, a one-line rewrite, a few fields of JSON in a shape you described, sorting files by meaning, summarising a note. It is on-device AI for chores, not a place to draft a long article or a whole program. Longer writing and serious code still belong on a model chosen for that job. The practical pattern other users report is a split: a bigger hosted model plans and checks, while the Mac answers the small local turns without spending hosted tokens.

That split is also why this matters beyond convenience. Every short job you move to fm is a hosted generation you never pay for — the same render-don't-generate logic as running local tools instead of AI generation. The difference here is that Apple ships the model with the OS, so there is nothing to install, no key to manage and no bill at the end of the month for the on-device work.

Privacy, in plain terms

On the system model, prompts never leave your Mac. That makes it a genuine option for text you would never paste into a cloud chatbot: private notes, unpublished drafts, client material, anything under an NDA. The trade is capability — the local model is smaller and its context window is 8,192 tokens, so it will not hold a whole book in mind. Use fm token-count to check a prompt before you send it, and switch to pcc only when the job actually needs the bigger window or image input, knowing that choice sends the prompt to Apple's servers under Private Cloud Compute.

Honest limits before you rely on it

• Small context: 8,192 tokens on-device means short inputs. Long documents need chunking or the cloud model.
• Small model: expect solid short answers, not deep reasoning or expert-level long-form writing.
• Availability varies: the model must be downloaded and ready, Apple Intelligence must be enabled, and regional rollout differences exist. Check fm available rather than assuming.
• Flags change between OS versions: treat fm --help as the truth on your machine.
• Cloud model has limits: pcc is subject to usage limits, and it needs internet — it is not the offline story.
• Automation needs guardrails: never hand any LLM unrestricted file-write, deletion, shell or messaging power just because a demo shows automation. Review the plan and confirm before any consequential action.

Five things worth trying first

If you have a Mac on macOS 27, here is a sensible first hour with fm, in order of usefulness:

1. Ask one real question. fm respond "Explain this error message in plain words" — get a feel for the model's size and tone before you build anything on it.
2. Summarise a file. Pipe a long note or changelog in and ask for three bullets. This is the job the local model does best.
3. Extract structured data. Build one schema with fm schema, then run a messy input through it and watch clean JSON come out. This is the moment most developers see the point.
4. Count tokens before a big prompt. Run fm token-count on your prompt so you know whether it fits the 8,192-token on-device window or needs the cloud model.
5. Serve it locally. Start fm serve and point one existing script at 127.0.0.1 instead of a cloud endpoint. If the script works unchanged, you have just removed a bill and a data leak from that workflow.

Compare that with the cloud CLIs most developers use today, and the trade becomes clear:

The table is not an argument to replace cloud models. It is an argument to stop paying cloud prices for jobs a small local model does just as well — and to keep private text on the machine it already lives on.

Frequently asked questions

Sources

• Foundation Models from Python: the fm CLI — WWDC26 session 334 coverage, command reference and Python SDK details
• macOS 27 Ships a Foundation Model at the Command Line — context windows (8,192 on-device, 32,000 PCC) and schema examples
• macOS 27 Built-In LLM: Call Apple's AI from Terminal — zero-configuration access, M1 and 8GB RAM reporting
• macOS 27 Terminal Tool Grants Developers Direct Local Access to Foundation Models — /usr/bin/fm location and subcommand list
• Apple's Foundation Models CLI: A First Look from Java — first-hand license, availability and fm serve walkthrough
• Fm: The Local Model Already On Your Mac — what the small local model is genuinely good at
• fm Command for Apple AI — setup guide for the fm command

Bottom line: the viral post is right about the part that matters — a free LLM is now sitting in every Apple Silicon Mac's Terminal, and the on-device model really does work with no account, no API key, no internet and no token bill. Just remember the one qualifier: "fully offline" belongs to the system model. Choose pcc only when you need it, and keep the rest of your work on the machine you already own.