Every thread about self-hosted AI turns into a privacy argument within three comments. Almost nobody posts the boring part: the invoice.
I have been running a personal AI assistant on my own VPS since early 2026 — a Telegram-facing agent with persistent memory, cron jobs, and a handful of integrations. Here is the actual cost breakdown, the things that broke, and the honest cases where you should not do this at all.
The bill
| Item | Monthly |
|---|---|
| VPS (2 vCPU / 4 GB / 60 GB NVMe) | $6 |
| Domain (amortized) | ~$1 |
| Model access (Claude subscription, not per-token API) | $20–$100 depending on tier |
| Backups (object storage, ~2 GB) | ~$0.10 |
| Total | ~$27–$107 |
The VPS is the part everyone fixates on and it is the cheapest line item by an order of magnitude. The model access dominates, and that is the first thing worth internalizing: self-hosting an AI assistant does not mean self-hosting a frontier model. You are self-hosting the agent — the memory, the orchestration, the integrations, the data. The weights can still live somewhere else.
That distinction is where most cost estimates on the internet go wrong. People price out an A100 and conclude self-hosting is for millionaires. You do not need one unless you specifically want local inference.
The line item that will actually bite you
Here is the mistake that costs real money, and it is not the VPS.
If you wire your agent to a per-token API key instead of a flat subscription, an agent with tool-use in a loop will happily burn through a month of budget in an afternoon. An agent is not a chatbot: one user message can fan out into dozens of model calls — reading files, calling tools, retrying, summarizing. I have watched a single misconfigured background job produce a three-figure bill in under a day.
The difference is structural, not a matter of being careful:
- Chat UI: one message, one response, cost proportional to your typing.
- Agent: one message, N tool-calls, cost proportional to task complexity — which you do not control at write time.
So the first architectural decision is billing mode, before you touch a line of code. Flat subscription with an agent harness on top is predictable. Per-token API with an autonomous loop is a metered faucet pointed at your wallet, and you find out at the end of the month.
The second one: put a hard concurrency cap and a timeout on every scheduled task. Not "be careful" — an actual enforced limit in code. Background crons are where runaway loops hide, because nobody is watching the chat window when they fire at 3 AM.
What you actually get for the money
After six months the things I would not give up:
Memory that persists across sessions. Not a rolling context window — an actual database of facts, decisions, and corrections that survives restarts. When I correct the assistant on something, it stays corrected next month. Cloud assistants have gotten better here, but you are still renting the memory, and you cannot inspect or repair it.
It runs when I am asleep. Cron jobs, monitoring, scheduled reports. A hosted chatbot is request/response by construction; an agent on your own box has a clock.
The data never leaves. Conversation history, files, credentials — all on disk I control, backed up where I choose. This is the part people argue about, so I will just say the practical version: it is less about paranoia and more about not having your working context deleted by someone else's policy change.
Debuggability. When it does something dumb, I can read the transcript, the tool calls, and the database rows. That is genuinely different from filing feedback into a black box.
When you should not do this
I would rather say this plainly than sell you something:
- You want it to just work and never think about it again. A VPS is a machine you now own. Patches, disk space, backups, uptime. Budget an hour a month, sometimes more.
- You need frontier-model quality with zero setup. The hosted products are genuinely excellent, and their onboarding is fifteen seconds.
- Your use case is a single chat window. If you are not using memory, scheduling, or integrations, you are paying complexity tax for features you will not touch.
Self-hosting wins when your assistant needs continuity — memory, schedule, and access to your own systems. It loses when you just want a smart text box.
The short version
The $6 VPS is a rounding error. The real costs are your billing model and your attention. Pick a flat subscription, cap your background jobs, and the economics are boring in the best way — which is exactly what you want from infrastructure.
I wrote a longer breakdown of the tradeoffs, including the cases where the math does not work out, here: is self-hosting AI worth it. There is also a side-by-side of self-hosted AI vs cloud AI if you want the comparison table rather than the essay.
The assistant I run is avelina.ai — happy to answer setup questions in the comments if anyone is going down this road.
Top comments (0)