> ## Content Index > Fetch the complete content index at: https://thomasadair.ghost.io/llms.txt > Use this file to discover other available public pages before exploring further. # Apple Built the Engine and Metered the Key - URL: https://thomasadair.ghost.io/apple-built-the-engine/ - Published: 2026-09-09T03:21:00.000Z - Updated: 2026-09-09T03:20:59.000Z - Description: Apple's own coreai-models repo ships every piece of on-device AI plumbing — export, runtime, authoring, compression. The bottleneck was never the silicon. It's a decision about who's allowed to put a model on your phone. - Author: Thomas Arthur Adair - Tags: field-notes, AI, on-device-ai, #field-note *A Field Note. This one’s outside my usual lane — a prediction, not a proof. I write these to check my own thinking, and this is me thinking out loud about where on-device AI goes next and who gets to decide whether you run it.* The stock answer to on-device AI is “why bother — just use the cloud.” It’s a good answer, right up until you notice the desktop already ran the experiment and returned a result nobody advertises. Here’s the result. Cloud LLMs got mass adoption at a speed we’d never seen — a chat box in a browser tab, no install, frontier quality on tap. And then, underneath that wave, a smaller counter-current started pulling the other way. People began running models *locally*. Not the majority, not loudly, but steadily and on purpose. Ollama turned “run a capable open model on your own machine” into a one-line command. LM Studio wrapped the same idea in a desktop app your non-technical friend can actually use — browse a model, download it, chat with it, all on the hardware in front of them. Nobody’s laptop is a datacenter. These people gave up quality at the top end, on purpose, to get something the cloud structurally can’t hand them. Four things drove it, and they’re worth naming because they don’t go away. Privacy — the prompt never leaves the machine, so there’s nothing to leak, subpoena, or train on without asking. Cost — no meter running per token, the model is just *there*. Offline — a plane, a basement, a bad connection, and it still works. And the one underneath the other three, the one people say last and mean most: no gatekeeper. Nobody can rate-limit it, deprecate it, change its manners overnight, or read over your shoulder. It’s yours. You can feel the whole argument compress into that single word — *mine* — the first time you watch a model answer with the wifi off. That whiplash — mass flight to the cloud, then a quiet pull back toward the machine on the desk — is the thing I can’t stop turning over. Because the same wave is now reaching the phone. And the phone is not a smaller version of the desktop story. It’s a *stronger* one. ## Why the pull is stronger on the phone, not weaker The desktop was where the local-model instinct got proven. The phone is where it actually matters, because the phone is where your life is. Think about what’s on it that isn’t on your laptop. Your messages, in full. Your photos, geotagged and face-tagged and going back years. Your location history, your health data, your keyboard’s private sense of how you write, who you text at 1am, what you actually search for versus what you’d admit to. The desktop holds your work. The phone holds *you*. So every reason people pulled models local on the desktop — privacy, no gatekeeper, it’s mine — doesn’t weaken on the phone. It gets sharper, because the data at stake is more intimate and the surface it could leak from is always in your pocket, always connected, always one permission dialog away from sending something somewhere. If the desktop counter-current was real — and Ollama and LM Studio existing, and being used, says it was — then the phone version of it should be larger, not smaller. The demand is sitting right there. Which makes the next part the strange part. ## The people loudest about AI are the ones withholding it The paradox that got me writing this: the platform that talks most insistently about putting AI in your pocket — Apple, primarily — is also the one most carefully *not* letting you run your own model on their phone. There’s no Ollama for iOS in any real sense. No “download a capable open model and just talk to it, offline, no account.” The most personal computer most people own is the one where running a model of your choosing is the hardest. The easy read is silicon. The phone can’t do it yet — not enough memory, not enough thermal headroom, the battery would die. That read is comfortable and, as of now, wrong. I know it’s wrong because Apple told on themselves in public. Go look at `apple/coreai-models` on GitHub. It is, quietly, the entire plumbing for exactly the thing they’re not shipping to users. Export recipes that take a popular open model straight off Hugging Face and turn it into a standalone on-device file — a `.aimodel` you drop into an app. A Swift runtime package for actually running those models on iOS and macOS. Python primitives for authoring your own. And — the detail that made me sit up — a compression toolkit, `coreai-opt`, for systematically quantizing and palettizing a model’s weights down to something that fits and runs on the hardware. Squeezing a model small enough for a phone is the *hard* part of on-device, and they built a tool whose whole job is doing it well. Read that inventory back. Export, runtime, authoring, compression. That is not a company that *can’t* run capable models on its phones. That’s a company that has quietly shipped every piece of the engine and is choosing, at the product and policy layer, how much of it a user is allowed to touch. The bottleneck was never the silicon. Apple’s own silicon has been embarrassingly good at this for years. The bottleneck is a decision — about what a phone is allowed to be, who’s allowed to put a model on it, and how much of that they want to own. There’s even a tell in how they shipped the repo. They’re explicit that they’re *not* accepting code contributions right now — a curated gallery, feedback welcome, pull requests closed on sight. That’s not hostility; it’s control. It’s the posture of a company that built the whole thing and wants to decide, case by case, who’s allowed to use it. Have they shown their full hand? Remains to be seen. Maybe this is a developer tool that stays a developer tool. Maybe it’s the staging ground for something they announce as if it were new. I genuinely don’t know — and anyone who tells you they do is reading tea leaves. But the plumbing existing changes the question. It stops being *can they* and becomes *will they, and on whose terms*. ## Where I think it actually goes — and where it doesn’t Here’s the part I’ll defend, and the part I won’t. The near future is not “train a model from scratch on your phone.” I want to be flat about that, because it’s the overclaim this whole topic invites. Training a model from nothing is a brutal amount of energy, memory, and data — the phone is the wrong machine for it, and hand-waving past that is how you lose the reader who actually knows. Full on-device training may come eventually. It is not the next step. The next step is *personalization*, and that one’s already feasible. Not retraining the model — adapting it. A small learned layer on top of a shipped base model — an adapter, a fine-tune measured in megabytes not gigabytes — that continuously shapes the thing to your data and your voice without any of that data leaving the device. The heavy, expensive base model is trained once, in a datacenter, by whoever. The part that makes it *yours* — the part that learns how you write, what you mean by “the usual,” which of your projects “the deck” refers to — that part is small, cheap, and can live and update entirely on the phone. That’s the wedge. Personalization first, on-device, private by construction. Full training later, if ever. And the counter, because a prediction without one is just a sales pitch. The cloud is not going away, and it shouldn’t. For a good while yet, the frontier lives there — the biggest models, the longest context, the heavy multi-step reasoning that a 2-to-3-billion-parameter on-device model simply cannot match. A phone model is a compact model, and compact means real trade-offs in raw capability. So the realistic near future isn’t local *replacing* cloud. It’s *hybrid* — the frontier and the heavy lifting stay remote, while the personal, private, always-on layer moves local first. The split isn’t small-versus-big model. It’s intimate-versus-general work. The stuff that’s *about you* has the strongest reason to run on the device that’s yours. The stuff that needs a datacenter’s worth of compute keeps calling home. That framing also lets me be fair to Apple, which I want to be, because the lazy version of this piece is “big company bad.” Their caution is genuinely part real constraint. Battery and thermals and memory are hard limits, not excuses. A 2–3B model is not a frontier model and will sometimes be wrong in ways that embarrass a company whose brand is *it just works*. Safety and UX at Apple’s scale are not trivial — ship a local model that says something ugly to a teenager and “but it ran on-device” is not a defense anyone accepts. All of that is real. And it is *also* true that a locked platform, a metered key, and a store you have to pass through is a business Apple has defended before and would rather not hand to a one-line `ollama run`. Both things are true at once. The interesting question — the one I actually care about — is which motive dominates the next few product cycles, and whether they ever let a normal person put a model of their own choosing on their own phone. Because that’s the real stake, and it’s why this piece isn’t really about Apple. Once people can carry their own model — shaped to them, running on their hardware, answering with the wifi off, in the manner *they* chose rather than the manner a platform defaulted them into — the center of gravity shifts. How you live and work stops being driven by what the platform decided is good for you and starts being driven by what you actually need. That’s the whole game. The desktop showed a sliver of it to the few people willing to type a command. The phone would show it to everyone. I don’t know if Apple unlocks the phone or spends a decade sitting on the decision. But they’ve already built the engine — we’ve all seen it. The only thing left to argue about is the key… and who’s allowed to turn it. --- **Sources:** - `apple/coreai-models` — [github.com/apple/coreai-models](https://github.com/apple/coreai-models?ref=thomasadair.ghost.io). Apple’s open repo of on-device AI plumbing: export recipes converting Hugging Face models to standalone `.aimodel` files, a Swift runtime package for running them on iOS/macOS, Python authoring primitives, and `coreai-opt`, a weight-compression toolkit (quantization and palettization). Repo notes it is not accepting code contributions at launch — feedback and model requests only. - Ollama — [ollama.com](https://ollama.com/?ref=thomasadair.ghost.io). Command-line tool for running open-weight LLMs locally on your own machine. - LM Studio — [lmstudio.ai](https://lmstudio.ai/?ref=thomasadair.ghost.io). Desktop application for discovering, downloading, and running open-weight LLMs locally, with a graphical chat interface. *This is opinion and prediction, not reporting — personal read, offered so you can argue with it.* — *Thomas Adair* *(posted from @mrarthurkf — builder’s voice, not the DJ)*