Your Hardware Is the Datacenter: A Position Paper on Local-First AI
Abstract
The default trajectory of consumer AI is the cloud: your words travel to someone else's computer, get processed under someone else's terms, and come back as someone else's product. We argue for the opposite — that capable AI should run on the hardware people already own, answer to the person who owns it, and keep working when the network doesn't. This paper lays out the principles behind xvoidsx's open-model program: right-sized models for every class of machine, honest scoping of what each size can do, honest quantization, and validation on real hardware.
1. The problem with the cloud default
Every cloud AI interaction is a small surrender: of privacy (your words become training data or product analytics), of agency (the model changes, degrades, or disappears on someone else's schedule), and of resilience (no network, no intelligence). For most personal uses — a voice assistant, a writing helper, an agent that manages your machine — none of this surrender buys anything. The task doesn't need a frontier model. It needs a model that shows up, on your machine, every time.
None of this makes us anti-cloud. Cloud models have their place — frontier capabilities, burst compute, things you genuinely can't run locally. The conditions are just honesty: a provider you actually trust, zero data retention where it matters most, and no chain around your ankle. Never build on a single provider who can pull the rug, change inference pricing, or deprecate the model your workflow depends on. We're local-first, not cloud-never: your hardware is the default, and the cloud is a choice you make deliberately — not a surrender you didn't notice.
2. Right-size the model
Capability per parameter keeps climbing — a small model in 2026 does work that needed billions of parameters not long ago. But the important question was never "how big a model can we serve?" It's "how small a model does this job well?"
And "the job" is much wider than voice. A computer with local models gets smarter everywhere: searching your own files, triaging email, transcribing audio, drafting text, running agents that operate your machine. Voice is a big one — it's the most human interface — but it's one application among many. The principle covers all of them: the right size for the task, running locally, answering to you.
That's the ladder: koe for voice, alice for personality, lain for agentic work — one family per machine class, from Raspberry Pi to workstation and beyond.
3. What small models are actually good at
Honesty first: a 270M model is not going to be amazing at open-ended conversation. It won't reason through hard problems, hold long contexts, or write your code. Anyone telling you otherwise is selling something.
What small models are good at is narrow, well-scoped work:
- Intent classification and routing — understanding what you asked and where it should go
- Structured extraction — pulling clean JSON out of messy input
- Short-form generation — brief, consistent responses in a defined voice
- Voice personality layers — the consistent tone and character of an assistant, which is a narrow task wearing a human face
- Specialized pipelines — transcription, triage, and retrieval stages where the job is bounded
This is why koe starts at the voice layer: a voice assistant's personality is a narrow job. Consistent tone, short responses, mapping intent to action — that's exactly the shape small models fit. The failure mode of the industry is using a frontier model for a 270M job (and paying the privacy and resilience price for nothing). The opposite failure is expecting a 270M model to be a general intelligence. Both are avoidable once you scope honestly.
4. Bigger models have their place too
Small models cover the narrow layer — but an agent that plans, writes code, and holds long conversations needs more headroom. For higher-end machines, we're working toward lain: agentic-class models at 8B and up, tuned from strong open bases in the Qwen family. The exact ceiling is open — we haven't tested what the navi pro tier will ultimately handle, and we'd rather discover it on hardware than declare it in a paper.
The principle is the same at every scale: one family per machine class. The weakest machine gets koe; the strongest gets a full agentic mind; everything in between gets something sized for it. Nobody's hardware is "below" AI — there's a model shaped for the machine you have.
5. The perma-computing principle
If a model runs on a 2015 laptop, it runs anywhere. We validate every release on real old hardware — not as a stunt, but as the acceptance test. Old hardware is abundant, cheap, and already manufactured; every model that runs on it is a model that doesn't require new consumption. It also happens to be the hardest honest test: no hiding behind datacenter GPUs.
This inverts the usual quantization story. Most published quants are optimized for the high end — bigger cards, faster inference. Ours are optimized for the low end: the weakest machine we support is the benchmark that matters.
6. Methodology: how we validate
Every xvoidsx model release ships with:
1. The full recipe. Base model, training data description, hyperparameters, and tooling — documented in the model card, not hidden.
2. Quantized variants (GGUF and others) with measured sizes.
3. Hardware validation reports: which real machines it ran on, at what speed, with how much memory. Numbers from our bench, not estimates.
4. An honest status. In-development means in-development. We don't ship aspirations as releases.
5. An honest scope. Every release states what the model is for and what it isn't. A 270M voice model is not a conversationalist and we won't describe it as one.
7. What we're building toward
| Tier | Family | Size | Machine | Honest role |
|---|---|---|---|---|
| Voice | koe | 270M – 1B | Raspberry Pi, old laptops — the perma-computing floor | Intent, personality layer, short-form generation |
| Personality | alice | 1B – 3B | Everyday machines | Deeper local conversation |
| Agentic | lain | 8B+ | navi pro and up | Full agent workloads: planning, code, long conversation |
Plus perma-computing quants of useful open models, validated the hard way — and the papers themselves: this program, documented as we go.
We're also watching Ajax — the upcoming open model from PewDiePie's community-driven AI work — as a potential base for the agentic tier.
8. Related work
The open-weights ecosystem makes this possible: the Qwen, SmolLM, and Gemma families for bases; llama.cpp and ollama for the runtime; and publishers like 0xSero who showed that rigorous, well-documented releases — methodology, benchmarks, papers — are how a small collective earns trust. We aim to do for the low end what they do for the high end.
9. Conclusion
Your hardware is the datacenter. Models should answer to you, not to someone's cloud — and the way to get there isn't one giant model or a thousand tiny ones, it's the right model for each job, honestly built, honestly scoped, and honestly tested. That's the program. These papers are the receipts.