Most arguments about whether local AI is cheaper than cloud never get to a number. They stay at the level of “it depends,” which is true and useless. The reason it stays vague is that almost nobody has actually added up their own subscription stack and held it against the real cost of running the same work on a machine. So that is what this piece is: not a verdict with invented totals, but a method you can run on your own numbers tonight.
We will not tell you a dollar figure, because your figure is the only one that matters. We will tell you exactly which numbers to gather and how to compare them honestly, including where the cloud side genuinely wins.
Step one: count the rented stack, properly
Open your statements and list every AI subscription you pay for. Not the ones you remember, the ones you pay for. They are not the same list. Look for:
- The chat assistant.
- The coding assistant or agent.
- The image or design generator.
- The transcription or meeting-notes service.
- Any per-seat plan billed across a team.
- The API spend that shows up as usage, not a flat fee.
- The one someone added last quarter that nobody owns.
For each line, write the monthly cost. Then do the one calculation people skip: multiply each by 12 to get the annual cost, and add them into a single yearly number. Subscriptions hide inside “it is only a few dollars a month.” The annual total is where the real size shows up. If a plan is per-seat, multiply by seats too, because that is what you actually send.
Write that yearly total down. Call it your rented cost. That is the number the rest of this compares against.
Step two: cost the local side, the whole of it
The local side has two parts, and being honest means counting both.
The machine. This is a one-time cost, not a recurring one, and for many people it is partly or fully sunk already. The Atlas note on Ollama lists 16GB of RAM as recommended and 8GB as a minimum for small models. If the laptop you are reading this on meets that, your hardware cost for everyday local work may be zero, because you are not buying anything new. If you need more capability, the cost is whatever a suitable machine costs you, once. To compare fairly against a yearly subscription total, spread that one-time price across the years you expect to keep the machine. A machine you keep for several years divides into a much smaller per-year number than its sticker.
The electricity. Running a model draws power. To estimate it honestly: find your machine’s draw under load in watts (laptops are modest; a desktop with a discrete GPU is more), estimate the hours per day you actually run inference, and multiply by your local electricity rate per kilowatt-hour, which is on your utility bill. Watts times hours gives you energy; energy times your rate gives you cost. Do that per day, multiply out to a year. For most laptop-based work this number is small. Run the calculation rather than guessing, because guessing is how both sides of this debate stay dishonest.
Add the per-year slice of the machine to the per-year electricity. That is your local cost.
Step three: put the two numbers side by side
Now you have two annual figures: rented cost and local cost. The gap between them is the entire argument, and it is finally made of your numbers instead of someone’s marketing.
For a lot of individual creators and small studios, the rented stack is larger than people expect once it is annualized and summed, and the local side is smaller than people expect once the machine is treated as a one-time cost spread over its life. But we are not going to claim a result for you, because the honest answer depends on details only you have: how many subscriptions, how many seats, what machine, what power rate.
Run it. The arithmetic is not hard. The reason it feels hard is that nobody set it up as a single comparison before.
Where cloud still earns its bill
This is the part the “cancel everything” crowd skips, and skipping it makes the whole argument untrustworthy. Cloud is not always the worse deal. It still wins on real terms in a few places:
- The hardest problems. On the top of the quality curve, a frontier cloud model is still ahead of what you run locally. If your daily work lives there, that subscription is buying you something local cannot match yet, and cancelling it would cost you more than it saves.
- Capability you would otherwise have to buy hardware for. If running the local equivalent means a much more expensive machine you do not already own, the cloud subscription may be the cheaper path until that changes.
- Bursty, occasional use. If you need a heavy capability rarely, paying per use can beat owning the hardware to do it yourself.
- Zero maintenance. The subscription includes someone else keeping it running and updated. Your time has a cost too.
So the honest framing is not local good, cloud bad. It is: most people rent every capability by default, never having compared, and a chunk of that stack would be cheaper to own. Keep the one or two cloud tools that earn their bill on work a local model genuinely cannot do, and run the cost comparison on the rest.
What we run, and how we decided
In the studio, the default is local: Ollama on every machine, with cloud reached for only when a task is genuinely beyond what the local model handles. We did not arrive there by faith. We arrived by doing exactly the arithmetic above, on our own subscriptions and our own machines, and finding that the everyday work did not justify the recurring bill once it was annualized.
We are not handing you our total, because it would not be yours. We are handing you the method. List each subscription, multiply by twelve, sum it. Cost the machine as a one-time price spread over its life, add honest electricity. Put the two numbers next to each other. Then keep whatever cloud tool wins on the hardest work, and stop renting the rest by default.
Do the math once. Then decide on your own numbers, not anyone’s claim. Curious about these things. You should be too.
Harness your curiosity.
— Stridenote · № 005