Turn the GPUs you already own into private AI infrastructure.
You have a graphics card. Between that and a working AI endpoint sit drivers, containers, quantisation and a great deal of VRAM arithmetic. Nodeau handles all of that and hands you an OpenAI-compatible API on your own machine.
There is more here than chat. Embeddings, reranking, structured output, tool calling and image understanding all run from the same catalog, on the same engine, with the same two commands.
And the catalog is not the limit. Give Nodeau a GGUF file of your own and it reads the header, works out what the model needs, and tests it on your card before saying it works.
Runs on Linux with an NVIDIA card, and on Apple Silicon through Metal. A Mac runs standalone and is a fine way to work with chat models. Fleets, batch work and the other workloads run on Linux with NVIDIA, where they are measured.
Three commands. No Kubernetes to learn.
$ nodeau quickstart
==> model Qwen3.5-4B verified
==> gpu RTX 3080 · 7,005 MiB available
==> admission Admit · needs 4,406 MiB · 2,599 MiB spare
==> endpoint http://127.0.0.1:8080/v1
Nodeau is ready.Nodeau Home
Put the GPU you already have to work.
The card in your desktop is probably idle right now. It can run a capable model locally, and the only thing standing in the way is setup.
Anyone who has tried knows how that goes. You want to ask a model a question and you end up reading about container runtimes at midnight. Nodeau takes that on: it checks your machine, works out what will fit, fetches the weights, and starts something you can actually send a request to.
It checks the machine first
Operating system, GPU, driver, disk, and whether Nodeau's own pieces are healthy. If something is missing it says what, and stops before changing anything.
It works out whether the model fits
Nodeau compares what your GPU can really give a workload against what the model needs. If it will fit you are told how much room is left. If it will not, you get the numbers and a plain explanation before anything starts loading.
It fetches and verifies the model
Straight from the publisher over HTTPS, pinned to an exact file, checked against a known SHA-256 before anything runs it. Cached locally, so you download it once.
It gives you an ordinary API
OpenAI-compatible, on 127.0.0.1, with a key generated on your machine. Existing SDKs work by changing base_url.
And it keeps track of what it changed
Nodeau remembers what it installed and what was already there, and shows you the plan before it undoes anything. Your driver, your models and everything that predates Nodeau are left alone.
Getting there
From a spare GPU to a local endpoint.
Three commands and a request. The long part is downloading the model.
Full install guideInstall the CLI
curl -fsSL https://get.nodeau.ai/install.sh | bashPrepare the machine
nodeau installStart a model
nodeau quickstartUse it
Nodeau prints a working curl command with your local
key. Or point any OpenAI client at
http://127.0.0.1:8080/v1.
Day to day
The commands you'd expect, and nothing you wouldn't.
Once it's running, the vocabulary is the one you already use for anything else on a machine. Start something, see what's running, read the logs, stop it, get the GPU back.
nodeau run qwen3.5-4b-q4km
nodeau ps
nodeau logs qwen3.5-4b-q4km
nodeau batch submit requests.jsonl --model qwen3.5-4b-q4km
nodeau dashboard
nodeau stop qwen3.5-4b-q4km --workloadYour own models, not just ours
nodeau model import takes a GGUF file
you already have. Nodeau reads its header to work out the architecture,
quantisation and memory it will need, hashes the bytes so the file is
its own identity, and registers it. Nothing in your file is executed —
a GGUF is data, and it runs on Nodeau's own pinned engine.
nodeau model qualify is the
half that matters. It starts your model on a real card, measures what
it actually took, and tries each capability with a probe built to fail
if the model can't do it — a tool call whose arguments have to parse,
JSON checked against the schema it was asked for. If chat works and
tool calling doesn't, you get chat, and Nodeau doesn't claim the rest.
A local dashboard
One command opens a read-only view of your models, workloads, GPU and decisions in a browser. It's served by Nodeau itself on your own machine, needs no extra install, and never holds cluster credentials.
Batch work that runs while you sleep
Hand Nodeau a file of prompts and it queues the job, waits for a GPU to be free, runs it, and writes the answers back correlated to your inputs. Cancel it and the card is released as soon as the process is really gone.
Diagnosis that names the problem
nodeau doctor checks the installation, not just the hardware, and every refusal carries a reason code and a remedy in plain words. Scripts get --json and honest exit codes, so you always know where you stand.
Nodeau Business
Different machines, different cards, one set of decisions.
Your organisation already owns GPU compute. The hard part is turning unlike machines into infrastructure that can decide, safely, where a workload should run.
Most organisations acquire GPUs faster than they acquire any way of using them. Two workstations, a lab server, whatever was in the budget in 2023. Owning all that tells you nothing about which box could safely run the thing you want to run on Thursday.
Nodeau asks every machine what it actually has, checks that its copy of the model is the right one down to the hash, and then chooses. It shows you why it picked that machine over the others.
We run it on two machines here, deliberately mismatched, because matched pairs hide everything. The useful cases are the ugly ones: a card that is already busy, a model file that has quietly rotted, a machine that reboots while it is holding a workload. Those are the ones we test.
- fit checked on each machine
- tightest safe fit wins, unless you choose otherwise
- every candidate keeps a reason
Hardware, understood
- Each machine reports its own GPU and what's really free on it
- Cards from different generations are judged on their own merits
- Each machine verifies its own copy of a model, by hash
- Every machine has to vouch for itself before it is offered work
Decisions, explained
- The same fit check runs once per machine, with no looser second rule
- Every candidate keeps the reason it won or lost
- A GPU already committed to one workload is not offered to another
- Something running happily stays where it is
Where we're heading
- Several people in one organisation, with roles and single sign-on
- Getting model weights to the machine that needs them
- Batch jobs that run on a schedule
- Upgrading a whole fleet from one place
- Health-aware rescheduling
The roadmap has the detail and the order.
How it decides
A scheduler should know more than “GPU: 1”.
Most schedulers know one thing about your GPU: that it exists. Enough to start something. Not enough to know it will survive.
A 16 GB card gives a model rather less than 16 GB. Some of it sits outside what the compute API can reach, your desktop is holding a chunk, and a model that fits with nothing spare dies the moment anything else asks for memory. Nodeau does that subtraction before it starts anything, and if the answer is negative it tells you by how much instead of letting you find out sixty seconds into loading.
It also tells you where its number came from. If the configuration has been measured on hardware like yours, Nodeau uses that measurement. If it hasn't, it works out a deliberately cautious estimate from the model's own shape, keeps extra room back, and says so on the decision. You never get an estimate dressed up as a measurement.
Add more machines and the same sums simply run once for each one. There's no looser second rule for choosing between them.
One more thing worth knowing: Nodeau stays out of the way of your requests. It decides and manages, but the traffic goes straight to the model. Restarting Nodeau leaves your traffic untouched.
How this worksYour account
Optional, and deliberately small.
You don't need one. Nodeau installs and runs with no sign-in at all, and we intend to keep it that way.
What an account gives you is a list of your machines and the plan
each is on, visible from a laptop with no GPU in it. Run
nodeau login, approve it in the browser, done. Your
prompts and results never come near it. If this site goes down, your
models carry on serving.
- Your organisation and the machines linked to it
- Approve a new installation from the browser
- See which plan each installation is running under
- Works offline: entitlements are signed, checked locally, and cached
- No account needed to run Nodeau at all
Pricing
Priced for infrastructure, not for tokens.
Your hardware does the work. What you pay for is Nodeau managing it, so nothing here is metered per prompt, per token or per request.
Home Pro
Make all my GPUs work together.
Several machines you own, and batch inference across them.
Get Home ProBusiness
Private AI infrastructure for an organisation.
For an organisation. Priced per organisation, with business support.
Talk to usGo and use that graphics card.
It takes about ten minutes, most of which is downloading the model. If your team has hardware sitting idle instead, we'd like to hear about it.