your metal. your apps. no one in between.
Partical turns the hardware you've already paid for — the workstation, the laptop, the always-on box in the corner — into a sovereign backend for the software you build and run every day. Storage, compute, and a warm tier behind a single contract; no operator between you and your data.
app: name: hello runtime: node run: command: node server.js web: expose: tailnet # loopback | tailnet | public state: true # gets its own directory, nobody else's # git push partical main → built, health-checked, live
The cloud was an era-defining bargain: surrender the machine, gain the scale. Two decades on, the bill for that surrender has compounded — every request to a rented GPU pays the chip vendor, the hyperscaler, the reseller, and the API layer before it pays for a single unit of compute. On a machine you own, the marginal cost of keeping a model warm is electricity. That's the entire moat — not a scheduler feature, not a spin-up benchmark, but the unit economics of pinning something resident on metal that's already yours.
The second half of the thesis is stranger, and it's the one the industry keeps missing: most personal and small-group software sits idle most of the day, which means felt latency is the wake-from-idle penalty — cold start is the hot path. Partical is built around that inversion. Warm-pinned where latency is the product, cold-provisionable where it isn't, on the same substrate.
Self-host mode and hosted mode run the same platform; nothing in the hosted layer depends on a component that can't run on a single node in your closet. That parity is a law, not a roadmap item.
The industry just settled the vocabulary for us. Stripe is acquiring OpenRouter — the gateway routing ten-plus trillion tokens a day across four hundred models — and the stated reason is that tokens are the central currency of companies building with AI. Read it plainly: the meter is becoming the toll booth, and the toll booth is becoming payments infrastructure. This is the cloud playbook running again, one layer up.
Three words get blurred in that sentence, and the distinction is worth carving precisely. Consumption is what your agents actually burn. Usage is what a gateway meters on the way through. Ownership is whether the thing generating the token is yours. Rented, every token is all three at once — priced per million, settled by someone else. Owned, consumption is still real, usage becomes optional, and the price of a token collapses to the wall socket.
Partical's position isn't anti-gateway; route to the frontier when the task demands it. But the default path for daily software — and the agents that run it — should be the model resident on your own node, where a token costs what the electricity costs and nobody keeps a ledger. Every token generated on your metal is a token never billed. That's the economics of the next decade, and the meter shouldn't be the default.
Consume freely. Meter deliberately. Own the generator.
Agent harnesses made building personal software nearly free — prompt it, push it, iterate — and in doing so exposed the half of the stack nobody solved. The app needs a backend, and every path leads to the same destination: permanent tenancy on someone else's platform, metered per request, with your data as the deposit.
Partical is the control plane for a small fleet — a workstation, a laptop, an always-on mini PC — that makes them act like one backend.
Thin-provisioned volumes per tenant, snapshots, versioned object buckets, nightly mirrors. Drive-like file hosting for the artifacts your apps produce.
A Ray cluster across your nodes, GPUs included. Jobs land where the silicon is. Arrow-native serving off the tenant volume, zero-copy.
Models pinned resident on the always-on node. No eviction, no reload tax. The platform watches residency every five minutes and tells you when it slips.
The contract is partical.yaml. The intake is git push. The control surface is an MCP server your agent harness already knows how to talk to. No per-harness SDK, ever.
Two doors in, one contract, three planes, your machines underneath. Expose nothing by default.
Partical exists so that a single person with a few machines can run the applications and agents they depend on — at daily-driver latency, on hardware they control — without asking anyone's permission or renting anyone's trust. The cloud asked builders to trade ownership for capability, and that trade made sense when capability was scarce. It isn't anymore. Self-hostable first. Hosted only on the same terms.
Software is approaching an inflection point of its own making. Applications are about to stop being products and start being instances — not one app for a million users, but a million small apps, each generated for one person, one team, one purpose, by an agent, in an afternoon.
Every one of them needs a place to run. The clouds were architected for the old shape — few apps, many users, metered tenancy — and they were the right answer to that era's question. The new shape is many apps, few users, always on, and it belongs on metal already sitting idle in the room.
The question of the next decade isn't whether AI will write your software; it will. The question is who owns the box it runs on, and whether anyone stands between you and your own data. The industry's answer has been the same for twenty years: someone else, always.
Our answer is nobody.
Solo builders and small teams with hardware of their own. Linux first. If you already run an always-on node, you're who this is for.