Here's a thing I'm not doing: betting llumos on a single model. Not Claude. Not GPT. Not Gemini. Not whichever open-source release everyone's favorite this week.
The whole point of llumos isn't the model. It's everything around the model.
The agent is the engine, not the product
llumos is a suite of things arranged around a single swappable engine. The agent sits at the center as that engine — the thing doing the actual work of generating code and reasoning about your data. Around it: the runtime that compiles those generations into a real native app on your machine, the local data layer your apps share, the way they communicate with each other, the marketplace where people swap and remix what they've built, the lifecycle of building, iterating, retiring. That whole ring is llumos.
Concretely: swap Claude Opus for GPT, or GPT for a 4B Llama running on your GPU. None of your apps notice. They still launch with Cmd+Space. They still read from the same local data layer. They still publish events to the same comms bus. They still surface in your marketplace under the same handle. They still persist across reboots. The model wrote the code. The suite is everything that has to exist for that code to become a real, persistent, shareable part of your computer — and the suite doesn't move when the engine does. A bare agent on its own gives you a folder of generated files. llumos is the rest.
Two roles, probably two agents
There are at least two places an agent shows up in llumos:
The builder. Takes your description and constructs a native desktop app from it. Generates code, manages dependencies, iterates on what you actually meant. Benefits from raw capability — bigger model, more thinking budget, the best code-trained thing you can get your hands on.
The brain. Lives inside the app you built and keeps it useful. Handles natural-language input, summarizes across your data, decides what to surface from your shared local store. Benefits from latency and privacy — small, fast, on-device, never leaves the machine.
These can be the same model. They probably won't be, for most people. The right choice for one is rarely the right choice for the other. llumos doesn't make that choice for you.
What this means for you
Pick the model. Pick models. You decide what runs on your machine.
If you want Claude Opus building your apps because it's currently the best at code, and a small Llama running locally as the brain because you don't want every keystroke leaving your laptop — fine. If you want everything local because it's your data and you don't trust any API — also fine. If you want SOTA everywhere because cost isn't a constraint — also fine. If a new open-weight model drops next month and you want to swap it in without touching anything else — that should be a config change, not a migration.
Your preferences. Your taste. Your trade-offs. Software that lives on your machine should be configured by the person whose machine it is.
What this means for llumos
Every model release is a tailwind. Every one.
When Anthropic ships a better Claude, llumos users get it for free. When OpenAI ships a new GPT, llumos users get it for free. When Mistral or Meta or DeepSeek drops new weights, llumos users get it for free. When some research lab posts a small fine-tuned model that's specifically great at generating Electron apps — llumos users get it for free.
The platform compounds with the entire field of AI. Not a single vendor. Not a single capability curve. The whole thing.
What this prevents
The version of the future where llumos gets crushed by a model release.
A lot of AI products are built on a specific assumption about what models can and can't do today. When models cross the line of doing the whole job themselves, those products evaporate. That's not a failure of vision — it's a failure of architecture. They bet on the model being the constraint. When the constraint moves, so does the product.
llumos can't be crushed that way, because llumos isn't trying to do what the model does. The model writes the code. llumos turns that code into something that actually runs on your machine, persists when you close the lid, integrates with your other software, and accumulates value over time. A better model doesn't replace any of that. It makes all of it work better.
What llumos actually is
A suite of things arranged around a single swappable engine slot.
The runtime. The shared data layer. The inter-app communication bus. The marketplace. The agent harness that any model can drop into. The persistence guarantees. The local-first guarantees. The "your data never leaves your machine unless you tell it to" guarantees. The apps themselves.
All of that is llumos. The engine in the middle — whichever model you've picked — does the generation and the reasoning. The suite around it does everything that has to be true for those generations to become real, useful, durable software, and the brain across everything you've ever built.
Models come and go. Frameworks don't. The model is your call — the harness will make sure whatever you pick can drive the whole thing.