You own the GPUs. Nodeau makes them usable AI infrastructure.

A GPU is not infrastructure

A modern graphics card is an extraordinary amount of compute sitting in a desktop case. Actually using it to run an AI model is a completely different problem from owning it. In between sit drivers, runtime libraries, model file formats, quantisation, container plumbing, a model server, an API, authentication, and something to keep the whole lot running.

None of that is why anyone wanted to run a model. It is the tax.

Models are not interchangeable

Two models with the same name can need very different amounts of memory depending on how they were compressed, how much context you give them, and how many requests you want to handle at once. The honest way to know what a configuration costs is to measure it.

So Nodeau prefers a measurement, and when it hasn’t got one it says so. On hardware it has measured, it uses the measurement. On hardware it hasn’t, it works out a deliberately pessimistic figure from the model’s own shape, keeps extra room back, and marks the decision as an estimate.

That second path matters more than it sounds. Refusing everything it has not measured would leave you with a product that works on exactly one graphics card, which helps nobody. The honest position isn’t “we never estimate”. It’s you can always see which one you got.

The number on the box is not the number you get

A card advertised with 10 GB does not hand 10 GB to a workload. Some of it sits outside what the compute API can reach. Your desktop is already using some of it, for every window and every browser tab with a video in it. And a model that fits exactly with nothing to spare will fail the moment anything else asks for memory.

On a typical 10 GB card the gap between the number on the box and what a workload can actually plan against runs to several hundred megabytes, before your desktop is even counted. That gap is the difference between a model that runs and one that dies part-way through loading.

So Nodeau understands both sides

It watches the machine: which GPU, how much memory that GPU can really address, what is already in use, what Nodeau has promised elsewhere. And it knows the model: what this exact configuration needs, measured or carefully estimated, plus a margin on top.

Then it decides. If the workload fits, Nodeau sets everything up and starts it. If it does not, Nodeau says no before scheduling anything and shows you the numbers, which is considerably more useful than a crash several seconds into loading.

That is the whole idea, and it is what makes this more than a wrapper around existing tools. The decision comes first, and you can always see how it was reached.

One GPU needs admission. Several need placement.

For an individual, all of that turns one PC into a private AI endpoint: a local, OpenAI-compatible API on a machine you already own, reachable only from that machine by default. The only question is does this fit here.

Add a second machine and a new question turns up: which of these should run it, and why not the other one? The tempting shortcut is to answer with a count. Most infrastructure knows only that a machine has a GPU, which is enough to start something somewhere and nowhere near enough to know it will survive.

“GPU: 1” is not enough information. Two machines can both report one GPU and be nothing alike: different usable memory, different amounts already taken by whatever is on screen, a different copy of the model on disk that may or may not be the file it claims to be. Treat them as interchangeable and sooner or later something lands where it cannot run.

So Nodeau doesn’t invent a looser second rule for picking a machine. It runs the same check once for each one, keeps the reason every machine won or lost, and prefers the snuggest safe fit, so a big card is not swallowed by work a small one could have handled. And anything already running happily stays put. A better score elsewhere is not a good reason to restart something that is working.

That runs on mixed NVIDIA hardware, and the interesting cases are the ones that go wrong: a card that is already busy, a model file that has quietly gone bad, a machine that reboots underneath a running workload. The roadmap says where every part of it stands.

Why owned hardware

Running on hardware you control gives you locality, capacity you can predict, and a use for machines that already exist and mostly sit idle. Your data stays on the machine unless something you plug in decides to send it elsewhere.

It is not automatically cheaper. A GPU that runs a few hours a week is usually dearer than paying per request, and anyone telling you otherwise is selling something. The case for owning the hardware is control and predictability. Quite often it is also that you bought the card for something else entirely.

What we will not pretend

Nodeau decides where a workload runs and then leaves it there. It does not move a running workload between machines and it does not fail over on its own. That is a deliberate position rather than a gap we forgot about: moving something you cannot currently vouch for is how a small problem becomes an outage, so Nodeau holds instead. Recovering a workload when a machine dies is a real capability, it is on the roadmap, and it is not there yet.

It also assumes the people with access to a machine are trusted. It is not built to keep hostile users on the same box away from each other, and we would rather say that plainly than let someone find out.

Everything else on this site is something you can check. Where a number was measured, Nodeau says so. Where it was estimated, Nodeau says that too. That habit is the product, not the marketing.

Measured, on one machine

Numbers from our own development machine, an RTX 3080. They describe that machine and nothing else, and yours will differ.

The last figure is the point of keeping the control plane out of the inference path: restarting Nodeau’s own components did not interrupt a single request.