Hosting Your Own AI Models or Renting? The Honest Math

Host your own AI models or rent?

If you want the best possible answer quality, a subscription (Claude Max, $100 to $200 per month) is cheaper, better, and faster than your own hardware. A local machine for the strongest open models realistically costs around 10,000 euros, takes four years to break even, and falls technically behind during that time. For agent workflows with parallel sessions, that goes double. Your own hardware pays off when data may not leave the building. Not as a cost-cutting measure.

Since mid-June 2026, something has become possible that a year ago still sounded like a data center: running the strongest open AI model in the world on a single machine that fits under a desk. GLM-5.2 from Z.ai has 744 billion parameters, Kimi K2.7 from Moonshot around a trillion. Both are freely available, both run locally.

That brings back a question for the Mittelstand that used to belong to large corporations: should we host our AI ourselves? Our own models, our own hardware, our own data. Independent of a US vendor and its prices.

The answer is uncomfortable, but clear. And it has little to do with the number on the price tag.

Why This Works at All: Small Active Models

Both models are Mixture-of-Experts. That means they are huge, but only a small share of the weights fires per token. Of its 744 billion parameters, GLM-5.2 activates only around 40 billion per token; Kimi K2.7 uses similarly little of its trillion.

This one fact shifts everything. Speed does not hinge on raw compute, but on memory bandwidth. Feasibility hinges on memory capacity. So you do not need a cabinet full of data-center GPUs, but a machine with a lot of working memory. A Mac with Unified Memory is enough in principle.

The catch: the weights have to fit entirely in memory, plus room for the running context. To make the weights fit at all, the models are shrunk to 4 bit per parameter for local use. That costs a piece of quality. GLM-5.2 at 4 bit needs around 370 to 400 GB this way. That fits in a 512 GB machine. Kimi K2.7 wants more like 640 GB and up. So we are not talking about a gaming PC.

What the Hardware Costs

Four ways to get a local machine, from top to bottom:

• Data-center server (8x H200 and similar): $150k to $400k. The only path that really feels like the hosted API, with hundreds of tokens per second. For individuals and most mid-sized companies, out of the question.
• Apple Silicon with lots of Unified Memory: the realistic single-machine path, around $6k to $10k. Until recently the 512 GB Mac Studio was the sweet spot. Apple pulled the 512 GB option in March 2026 because memory prices have exploded (more on that shortly). Speed: a 4-bit model of this size runs at about 15 to 18 tokens per second. Usable as a personal coding assistant, sluggish for long agent runs.
• Mac cluster (4x M3 Ultra): around $40k, pooling 1.5 TB of memory, about 28 to 32 tokens per second. Comfortably holds Kimi K2.7 too.
• AMD EPYC server with lots of DDR5: $6k to $15k. RAM is cheapest here, but the low bandwidth drags the speed down to the low single digits to about 10 tokens per second.

One bit of context on all the prices: since early 2026 we have been stuck in a DRAM and HBM shortage. Memory makers have shifted production to the expensive AI memory for data centers. TrendForce revised DRAM contract prices for the first quarter of 2026 to plus 90 to 95 percent quarter over quarter. Apple not only pulled the 512 GB option but also raised the surcharge for 256 GB from $1,600 to $2,000, with lead times of four to five months. In May the 256 GB option disappeared as well. The exact hardware you need for local models is right now the most expensive and the worst to get.

The Real Math: Rent Versus Buy

Let’s put the realistic local machine against the subscription.

• Local machine: around 10,000 euros, one time (before the shortage inflation).
• Claude Max: $100 per month (5x) or $200 per month (20x).

Against the $200 subscription: around 50 months to break even. Over four years. Against the $100 subscription: around 100 months.

And this math still flatters the hardware, because it pretends the local model is as good as the one in the subscription. It is not. Locally you run a model that is already a tier below the frontier model, plus slower, without batching, and a notch weaker again due to the necessary 4-bit quantization.

Here is the point that flips the whole decision, and it is on no price tag: the bought hardware is a depreciating asset chasing a moving target.

Today’s models want 400 to 500 GB of memory. The next generation of open weights will want more: bigger experts, longer context, fatter cache. The machine that barely holds the current model today will not hold the one after next. It does not just age. It ages out of the race. Whoever wants to stay near the front buys new, memory-heavy steel every 18 to 24 months, just to stay barely behind the frontier.

The subscription does the opposite. The $200 subscriber gets every new frontier model automatically, at the same price. They never check whether the weights still fit in their memory.

The usual comparison is renting versus buying, like an apartment. The image lies there. With an apartment, the buyer wins in the long run because the asset stays and gains value. Here the buyer loses twice: the bought asset loses value, and the rented one keeps getting better without the rent going up.

The Second Calculation: Agents Work in Parallel

Up to here, the math pretends there is one person in front of the machine, asking a question and waiting for the answer. That is not what serious AI work looks like in 2026 anymore. Working with agents means several sessions running at once, and each of them spawns sub-agents: one researches, one writes code, one reviews the result. One user quickly turns into five to fifteen parallel requests hitting the model.

The 15 to 18 tokens per second from above, though, is the speed of a single stream. Under parallel load it divides, and worse than you would hope. Three reasons:

• The MoE advantage shrinks in a batch. A single request activates only around 40 of the 744 billion parameters. Parallel requests activate different experts, and together they approach the full model. The very effect that makes the model feasible locally fades the moment several requests run at once.
• Agents are mostly context ingestion. Every sub-agent starts by receiving its full working context, often 50,000 to 100,000 tokens. Reading it in (the prefill) needs compute, not memory bandwidth. And compute is precisely the weakness of the memory-optimized machines. Minutes can pass before the first answer token, on every single spawn.
• The memory headroom fills up fast. Besides the weights, every running session needs its own working buffer for the context, the KV cache. With around 400 GB of weights in a 512 GB machine, about 100 GB remain for all sessions combined. A handful of long agent contexts, and the space is gone.

The subscription does not have this problem, because the provider spreads parallel requests across a batched data-center fleet. Ten sub-agents feel like one there. To get the same feeling locally, you would not need the 10,000-euro machine, but the $40k cluster or the data-center class right away. That pushes the break-even out of reach for exactly the usage profile that is becoming the norm.

The honest math also includes the reverse direction: on a real GPU server, the argument partly flips. There, batching improves the cost per token the fuller the machine runs. That strengthens the volume case in the next section, but at the $150k tier, not at $10k.

Where Your Own Hardware Is Still Right

None of this means “never self-host”. It means: not for cost reasons and not to catch the frontier. Your own hardware is right when something other than the price per token rules.

• Data that may not leave the building. Regulated healthcare, legal, or defense settings, air-gapped networks. Here the subscription is no option at any price. This is the strongest argument, and for many mid-sized companies the only one that counts.
• Very high, predictable continuous volume. When even the generous subscription limits do not suffice and per-token billing would otherwise run into the thousands per month, the math can tip.
• Full control and no limit. Your own machine, no throttling at peak times, no weekly cap. Fine-tuning, your own quantization, research on the weights themselves. That is real value, but learning and sovereignty value, not savings.

The framing is decisive: your own hardware is a capability (data protection, sovereignty, control), not a savings lever against the frontier. Selling it as cost optimization is a way to calculate yourself into a mistake.

What You Can Now Place

You can now explain why the obvious answer (“own server equals independence and cheaper in the long run”) is, in most cases, the expensive one, and how to recognize the exception. The one sentence to take away: rent the frontier, buy local only for sovereignty, never to save money.

The next question that almost always follows is the one about the running cost of renting itself: how do you keep the token bill of a subscription or an API under control as usage grows? That is a separate calculation, and one you should set up earlier than most people think.

Frequently Asked Questions

Can you run a trillion-parameter AI model locally? Yes. Models like Kimi K2.7 (around 1 trillion parameters) and GLM-5.2 (744 billion) are Mixture-of-Experts: only a small part is active per token. What matters is enough working memory, not raw compute. Realistically that means 512 GB and up.

Is your own AI server cheaper than a subscription? As a rule, no. A local machine costing around 10,000 euros takes four years to break even against a $200 subscription, and the local model is weaker and slower in the meantime. Your own hardware pays off for data-protection or volume reasons, not for saving money.

When does your own AI hardware pay off? When data may not leave the building (regulated or air-gapped settings), with very high predictable continuous volume, or when full control and no rate limit are what tip the scales. As pure cost optimization against the frontier models, it does not pay off.

Is a Mac Studio enough for AI agent workflows? For a single session yes, with patience. For parallel sessions with sub-agents no: the 15 to 18 tokens per second apply to one stream, ingesting long contexts takes minutes, and the memory left next to the model weights only holds a few concurrent contexts. Parallel agent work needs the cluster or data-center class, or the subscription.

Related: When Your Own Software Pays Off and What Does an AI Project Cost in the Mittelstand.