Google shipped local AI on the Mac this week. The weights are Apache 2.0. The experience is a walled garden. That's not a contradiction. That's the playbook.
Google put local AI on the Mac this week.
Five Gemma models you can run offline — no internet, no account, no API key.
The headline model does text, images, and audio in 16GB of RAM, which is a standard laptop.
The weights are released under Apache 2.0.
The code runs on llama.cpp, vLLM, and MLX.
By every definition the AI world has used for two years, this is what open looks like.
Then you read the fine print.
The AI Edge Gallery only runs Google's models, in Google's app, from Google's curated catalog.
You can technically extract the weights and run them somewhere else.
Nobody will.
The app is the experience, and the experience is curated.
The weights are open. The system is not.
I want to write about that gap.
Not because Google is uniquely cynical — they aren't.
They're running the standard playbook, the one every locked platform of the last twenty years started with: ship something genuinely open, then quietly own the default path. The default path is where ownership actually lives.
The illusion of open weights
For two years the AI community has treated "open weights" as the whole question.
Either a model's weights are released — in which case it's open, and on the right side — or they aren't.
That framing was always incomplete.
It conflates two different things: portability of the model file, and portability of the experience.
A model file you can extract from an app and run elsewhere is portable.
A user experience that routes through one company's curated runtime is not.
The first matters to researchers and developers.
The second matters to everyone else.
Most people will never extract weights.
Most people will never compile llama.cpp.
They'll use whatever the default app says, run whatever model the default gallery offers, and accept whatever the default channel pushes.
And the Apache 2.0 license on the model constrains none of that.
The license governs the file. It does not govern the experience wrapped around it.
When you ship the default path, you ship the system. The weights are decoration.
The default path test
There's a simple question you can ask any platform that calls itself open:
If I want to swap one of the core pieces — the runtime, the model, the hardware, the deployment target — how hard is it?
If the answer is "you'd have to leave the platform entirely and rebuild your flow," it isn't open. It's open-source code in a closed experience.
The AI Edge Gallery fails this test.
Extract the Gemma weights and move them to Ollama and you lose the dictation integration, the curated catalog, the update path, and whatever Google adds next.
The platform isn't stopping you from leaving. It's betting you won't.
That bet is almost always right.
This is the shape Android took.
Open AOSP at the bottom, Google Mobile Services on top, the Play Store as the default install path.
Technically you can run Android without any of it.
Technically anyone can fork AOSP and ship their own.
Nobody does at scale, because the default path is the whole game.
The fork exists. The fork doesn't matter.
Why this bites harder in AI
The default-path playbook isn't new.
Microsoft ran it with Internet Explorer.
Apple runs it with iOS.
Google ran it with Search, Chrome, and Android.
Every time, the open layer ships first and the curated experience locks the user in by being the default.
In AI it bites harder, and faster, and here's the part most people writing about this today are going to miss.
Browsers are stateless.
You can move from Chrome to Firefox in five minutes and lose nothing that matters.
Want the full playbook? I wrote a free 350+ page book on building without VC.
Read the free book·Online, free
Phones are stickier, but the lock-in is mostly social — your contacts, your apps, your subscriptions. You can leave with effort.
Models don't work like that. Once an organization fine-tunes a model on its data, runs its evaluations against that model, and builds its workflows around how that model behaves, the switching cost stops being measured in clicks.
It's measured in months and budget.
Once a person gets used to one model's voice and one app's rhythm, leaving feels worse than the actual difference between the models would justify.
So the lock-in isn't a software relationship.
It's a model relationship. Deeper, slower to form, far more expensive to break.
The curated runtime exists to capture that relationship before any competitor can — and in AI, by the time you feel captured, you've already paid the switching cost in advance.
"Open weights, closed runtime" matters more than "open Android, closed Play Store" ever did.
The investment is deeper. The exit is more expensive. The lock-in compounds.
I made the opposite bet
I should be honest that I have skin in this.
I ship a small model called flash-1-mini — open weights, Apache 2.0, on Hugging Face.
And I made the opposite bet from Google on purpose.
We control the model. We don't control the experience.
There's no flash-1-mini app, no flash-1-mini gallery, no default channel that routes anyone back to us.
You run it on whatever stack you already have.
And the day a better 4B model ships — from Mistral, from a lab that doesn't exist yet — you swap us out without rebuilding anything around it.
That is a worse business than Google's. Much worse.
The entire value of the default path is that it captures the user, and we are choosing not to build the thing that captures the user.
I'm saying that plainly because it's the honest version of this essay:
Open at every layer is the harder business, and most companies pick the easier one for exactly that reason.
The only lock-in we get is the model being good enough that you keep it.
That's the only one we want.
The real question
Open weights are the floor, not the ceiling.
The portable file is the prerequisite, not the proof.
Real openness is portability of the whole experience.
The model you can swap.
The runtime you can replace.
The hardware you can change.
The deployment you can pick.
The fine-tunes you can layer.
The data you keep.
When all of those are yours, the system is open.
When any of them belongs to the vendor, the system is closed at that layer — whatever the license says.
If you can't swap the model, it's not really open.
If you can't swap the runtime, it's not really portable.
If you can't swap the hardware, it's not really yours.
So the question to ask about every "open" AI announcement from here on isn't "what's the license." That's table stakes now.
The question is: who controls the default path?
Right now, on the Mac, the default path runs through Google.
That's not openness winning. That's the playbook running again.