AI in the Enterprise

Your AI or theirs: the calculation nobody makes

Mr AndersonNovember 19, 2026Read time: 5 min
Your AI or theirs: the calculation nobody makes

Self-hosting a language model is not automatically cheaper than an API. The decision is made task by task, on two criteria: volume repetition, which pushes towards a small local model, and data sensitivity, which forces it or forbids it. Everything else goes to the API, paid per use, document by document.

A twelve-person company in Bayonne put the question to me like this: "we're told we should stop using ChatGPT and install a model on our own machines. Is that true?" The question is framed as a choice of camp. It isn't one. It's a calculation with two columns: what the task costs, and what the data is worth. Almost nobody runs it, which is why so many in-house AI projects go off the rails — either the company pays for an infrastructure it does not need, or it sends sensitive documents to an American supplier without asking the question once.

Let me be blunt: the right answer, in most of the companies I see, is neither "everything in-house" nor "everything with them". It's both, with a written routing rule. And that rule fits in one sentence.

The debate is ideological; the decision is accounting

Two arguments are colliding right now, and both of them cost you money.

The first says: keep control, install a local model, your data never leaves. True in principle. False in economics — a badly sized local model costs more than an API, answers less well, and needs someone to maintain it. In a twelve-person company, that someone is the owner on a Sunday evening, or nobody.

The second says: the cloud has already won, self-hosting is a developer's hobby. Also false. Some tasks are both cheaper and cleaner locally: repetitive, high-volume processing on data you are not allowed to let out.

The guide n8n published on self-hosting an LLM says the same thing in technical language: self-hosting is not automatically cheaper, and the right reflex is to route. In business language: you are not choosing a technology, you are choosing where each file travels.

The VRAM table, or why local isn't free

The point everyone discovers too late is graphics memory. A language model fits in the card's memory or it doesn't. There is no degraded version that works well.

Orders of magnitude, with the models available today: a small 3.8-billion-parameter model such as Phi-4-mini runs in roughly 8 GB of VRAM — a consumer card, a few hundred euros. A clearly more capable model such as Llama 4 Scout, with 17 billion active parameters, needs 55 to 80 GB. That is no longer a card: that is a server, with the power supply, the cooling and the electricity bill that come with it.

Orders of magnitude: a consumer graphics card is enough for a small model, a higher-class model demands a dedicated server

In between, a whole gradient. And that is exactly where the decision lives: the question is not "local or API" but "what share of my work actually needs a large model".

For an ordinary company the answer is embarrassingly simple: about 80% of the volume handed to a model is repetitive and does not need a leading-edge model. Sorting email, extracting a quote number from a PDF, classifying an incoming request, summarising a short set of minutes, rewriting three paragraphs. A small model does that correctly, at a marginal cost close to zero once the hardware is paid off.

The remaining 20% — careful writing, reasoning over a complex file, answering an unhappy customer, reading a thirty-page contract — needs a model you will not install in-house. Those you pay for per use.

What really decides: the nature of the task

Take a construction company in Anglet. Forty quote requests a week arrive by email and through a form. Someone has to read, qualify, extract the surface area, the type of job, the town, then reply that the request was received and that a call will follow within 48 hours. That chain runs 200 times a month, on data that is not secret in the industrial sense but is commercial.

The question to ask: do I need the best model in the world to extract "85 m², bathroom renovation, Bidart" from an email? No. Does the per-token cost of that extraction, times 200 a month, justify a €6,000 server? No either. A small local model is enough — or even a low-cost API depending on volume. Those are the two reasonable options, and the choice between them depends on volume, not on fashion.

Now the same company wants to write a response to a town hall tender. Twice a quarter, high stakes, a text that must be flawless. There, a small local model produces flat, generic prose and you rewrite the whole thing. The calculation flips: paying for the API per token, even at a high rate, costs less than two hours of your own time per document.

The rule emerges: volume and repetition push towards local; requirement and rarity push towards the API. A company that only ever uses one of the two configurations is overpaying somewhere.

What also decides: the nature of the data

Second column, and the one most often forgotten. It is legal, not technical.

If the processing involves personal data — customers, employees, patients — you are the data controller. Sending that data to a supplier is a transfer to a processor, with the obligations that follow: contract, duration, place of processing, onward sub-processors, and — for a supplier outside the European Union — a transfer framework. It is not forbidden. It is governed, and it has to be documented.

If the processing involves trade secrets — a recipe, a purchase price, a method, a customer file built over twenty years — the analysis is no longer only regulatory, it is strategic. An API supplier does not read your prompts in order to steal your recipe. But you only know that because you trust them, and that trust is a contract, not an obvious fact.

Hence the rule that works in practice: what is confidential and repetitive stays in-house. What is ordinary and occasional may leave. What is confidential and complex is the only genuinely hard case — and it is rare, which means you can handle it by hand, file by file, instead of building an architecture for it.

The sorting happens on two axes: volume repetition and data sensitivity

The router, concretely

A router is not an exotic piece of software. It is a rule, written down, that decides where each request goes before it goes. Three questions, in this order:

  1. May the data leave? If not, local. The question is closed; it is not renegotiated case by case depending on mood.
  2. Is the task repetitive and mechanical? If so, local, or the cheapest model that does the job. You measure once, then you stop arguing.
  3. Does the task require finesse? If so, the best available model, per use, on that single document.

This rule has a side effect worth the exercise on its own: it makes your dependency reversible. The day a supplier raises its prices by 40%, changes its terms, or closes an access — as happens regularly — you do not unplug your business. You move the third category elsewhere, keep the first two in-house, and nobody on the customer side notices. A company that put everything with a single supplier has no plan B: it has a supplier, and a constraint.

The calculation nobody makes: the hidden cost

The cost of an API is visible: a line on the invoice, per token, every month. The cost of local is not, which is why it so often looks cheaper than it is.

What you have to count, honestly: the hardware — and its replacement, because a server bought in 2026 will not run the models of 2029; electricity and cooling, real as soon as a machine runs continuously; model updates, which are not one click; monitoring, because a service that falls over on a Saturday morning has to be restarted by someone; and the time of the person who knows how to do all of it. That last item is the largest, and it is the one set to zero in comparison tables.

Symmetrically, on the API side: the cost rises with volume, you depend on the supplier's terms, and there is a small but non-zero risk that an access is suspended overnight. Two companies I work with saw their account blocked for a morning over a billing check. It doesn't matter when nothing depends on the tool. It does when everything does.

The accounting conclusion fits in one line: local pays off when volume is high and the task is stable; the API pays off when volume is irregular and the task is demanding. Any company with only one of those two profiles is overpaying somewhere, and often without knowing it.

What it changes for a company in the Basque Country

There is a local angle here that is not decoration: companies are small, owners are reachable, decisions are quick. That is a considerable advantage for this kind of arbitration. A twelve-person company in Bidart can settle in one meeting what a group takes six months to arbitrate.

But size has a cost too: nobody has the time to maintain infrastructure. Which is why, in practice, I see three configurations that work:

  • The company that stays on API, cleanly. Low volume, varied tasks, no highly sensitive data. The work is not installing anything; it is writing the usage rules, training the two people who use it, and checking what leaves. Low cost, immediate gain.
  • The company that puts a small local model on the background task. One regular, mechanical, high-volume flow — email handling, extraction, classification. The rest goes to the API. This is the most frequent configuration among my clients, and the most profitable.
  • The company with a hard constraint. Health practice, notary firm, minors' data, industrial secrecy. There, local goes on everything touching sensitive data, and you accept paying more in order to sleep at night. The calculation is different, and that is normal.

What does not work, in all three cases: improvising. A model installed on a PC under the desk, no backup, no updates, nobody to restart it, lasts three months. And after three months the company concludes that "local AI doesn't work" — when what failed was deciding.

Where to start, with no budget

The first step costs nothing and delivers more than installing a server: make a list. Take one week of real work and write down what was handed to a model: which task, which document, what volume, what sensitivity. That list, in the companies I have seen, reveals three things. A repetitive volume whose complexity is overestimated. A handful of demanding tasks that are underestimated. And two or three uses that should never have gone through a model at all.

Second step: pick a single task, the most repetitive, the least sensitive, and run it locally for three weeks. Measure the real error rate, not the advertised one. If it holds, extend. If it doesn't, you spent three weeks and a graphics card, not six months and a budget.

Third step, and the one missing everywhere: write the routing rule. One page. Who decides, on what criteria, where each piece of data goes. Without that page, every request reopens the discussion, and the discussion always ends with "we'll do as usual".

The "yours or theirs" debate has no general answer. It has an answer per task, and that answer moves with volume and with sensitivity. The work is not picking a side: it is writing the table. Once it is written, the decision takes ten minutes, and it can be revised.

If you want to do this for your company, we can start with the list — the list of tasks, not of tools. It takes an hour, and it changes everything that follows.

FAQ

Frequently Asked Questions

Not as a matter of principle. Local installation is justified when two conditions coincide: a high volume of repetitive tasks, and data you are not allowed to let out. If your use is occasional and varied, a properly governed API costs less and requires far less upkeep. The question is not where you put the AI, but where each of your files travels.

Let's launch your project

WHAT IS
YOUR
PROJECT?

We prefer real conversations over boring forms. Click on a service to tell us about your ideas, our process, or your AI production needs.