Run an AI app builder on your own machine
· updated
Adrian can build working apps with a model running on your own hardware — no API key, no per-token bill, and nothing sent to a model provider, because there is no provider in the loop. Almost every AI coding tool is a client for someone else's servers. This one does not have to be.
That is the headline. The rest of this is what it actually takes, and what you give up.
What running locally actually means
Adrian runs open models on your own hardware through Ollama. The prompt, the generated code, and every repair pass in between stay on the machine. There is no API key to create and no account to sign up for — you can install the app and build something without ever identifying yourself.
This is not a degraded mode bolted on for demos. The same crew of agents runs either way: the plan, the design pass, the code generation, the checks on the result. What changes is where the model weights live. A local build goes through the same compile gate and the same review pass as one running on a frontier model — the pipeline does not know or care which it is talking to.
What you need to run it
- Windows 10 or 11, 64-bit. This is the honest constraint: the desktop build is Windows-only today, and macOS and Linux have not shipped.
- 8GB of RAM to run at all, 16GB to run comfortably. Adrian reads your RAM, VRAM and free disk on first run and recommends models that will actually fit, rather than letting you download something your machine cannot load.
- About 2GB of disk for the app, plus room for the models. A capable coding model is several gigabytes; you can keep more than one and switch between them.
- No account, no key, no card. Local builds cost nothing per run because nothing is metered.
The RAM figure is the one that decides what your experience is like, and it deserves more than a line — which model fits your machine works through what each tier actually supports.
Getting to a first build
The local path has one dependency Adrian does not bundle: Ollama, which is what actually loads and serves the weights. Install that, install Adrian, and the app handles the rest — it inspects the machine, recommends models that fit, and pulls the ones you pick.
The slowest part of the first run is the download, not the build. A capable coding model is several gigabytes over your connection, once. After that the weights are on disk and every subsequent build is local in the fullest sense: no network round trip, no rate limit, no outage on someone else's status page.
The honest trade-off
Local models are slower than frontier hosted ones, and a build that a large hosted model finishes in a couple of minutes can take several on consumer hardware. That is the real cost, and it is worth knowing before you start rather than after.
They are also less capable, and it would be dishonest to pretend the structure erases that. A local 7B model inside a build system with planning, tool use and a compile gate produces markedly better results than the same model in a chat box — but it is not quietly equal to a frontier model, and anyone telling you otherwise is selling something.
What you get for it is a build that costs nothing to run, works without a network, and keeps your work on your own disk. For a lot of side projects, internal tools and anything you would rather not paste into someone else's service, that is the better trade.
The right model for each job
Coding and visual design are different skills, and the models that are good at them are different models. Adrian assigns each role by capability rather than by whatever happens to be installed first, so a small general-purpose model does not end up making your design decisions. You can see the assignment and change it.
In practice this means budgeting memory for a pair rather than a single model, and it opens a useful middle path: there is nothing stopping you running the designer locally and pointing the coder at an API key, or the reverse. The roles are independent.
What local does not mean
Worth being precise, because "runs locally" gets used loosely. On local models nothing about your build goes to a model provider. The app itself is still ordinary software: it checks for updates, and if you later choose a hosted plan or paste an API key, that path obviously involves a network. Local is a mode you stay in, not a claim about every packet the application will ever send.
The privacy policy is the authoritative version of that, and where your code goes walks through it in plain terms.
When you do want the cloud
- Bring your own key from a provider you already pay. Adrian never takes a cut of that bill.
- Or use Adrian Agents, the hosted crew with credit included — the paid tier.
- Either way the switch is per role, and local stays available alongside it.
The switch is not a migration. Projects you built locally are the same projects, and the cost comparison covers when paying for a model is the better call.
The Windows desktop build is available now. The current build is unsigned, so Windows will show a SmartScreen warning on first run — the download page explains how to verify the checksum before you run it.