What ships, what's next, and what's planned.

Self-hosted installer

One public command. Verifies the release artifact before installing anything.

nodeau install

Checks the machine, shows a plan and every privileged command, then sets up the local infrastructure, adopting what is already there rather than replacing it.

nodeau doctor

Read-only diagnosis of the host, GPU, driver, container stack and storage.

nodeau quickstart

Model consent, download, verification, admission, deployment and a local endpoint in one command.

Remote fleet console

See the machines you own from any browser, with their GPUs, what is running and why, and their health. Home Pro adds operating them: run and stop a model, set scheduling policy, drain a machine for maintenance, read bounded logs, and recover a workload stranded on a machine that has gone. Your machines call out, and nothing ever calls in.

VRAM-aware admission

Decides whether a workload fits before scheduling it, and explains the arithmetic either way.

Reservation accounting

Tracks what Nodeau has already committed on a GPU, so a second workload is judged against reality.

GPU hardware observation

A node agent reports the GPU's real addressable memory and current usage.

Several GPUs inside one machine

Per-card observation, per-card reservations, and placement within a machine as well as between machines. Nodeau names the physical card, Kubernetes allocates that card, and the telemetry shows which one ran the work. Included in Home Pro, up to two cards in any one machine.

One model across several GPUs

When a model is too large for any single card, Nodeau can split one workload across several GPUs in the same Linux machine. It picks the exact cards and reserves them as one unit, all of them or none, then checks that each card can hold its own share, because GPU memory is not pooled. Qualified on one heterogeneous pair, an RTX 3080 and an RTX 5060 Ti, serving a model whose weights fit on neither card alone. This buys capacity, not speed: on that pair a model that did fit on one card ran about 21% slower split across two than on the faster card by itself. Linux and NVIDIA only, since a Mac uses its one integrated GPU. Included in Home Pro, up to two cards in any one machine.

nodeau run <model> --gpus 2

Independent batch workers across several GPUs

A batch job can run several workers at once, each a complete model instance on a card of its own, taking records from the same input. They share nothing but the input and the result file: a worker claims the next unprocessed record when it is free, so a faster card naturally does more and nobody waits on a fixed share. This is the opposite trade from splitting one model across cards. Splitting buys capacity for a model that fits nowhere else, and independent workers buy throughput for work that was already independent.

A worker count is a request rather than a guarantee. Each worker reserves a card of its own, so asking for more workers than there are free cards runs the ones that fit and leaves the rest waiting. The job still completes, because the workers that did start take the records the others would have. nodeau batch status reports how many are running and how many are waiting.

Qualified on the same heterogeneous pair as everything else here, an RTX 3080 and an RTX 5060 Ti, with both cards observed running a model server at the same time. On a twenty-four-record job two workers finished in 47 seconds against 61 for one. That is a floor rather than a rate, because a short job is dominated by loading the model and both workers pay it. Linux and NVIDIA only. A job still does not span machines, and its workers are not restarted or moved if a card is lost.

nodeau batch submit records.jsonl --model <model> --workers 2 --gpus 1

Model profiles that carry their source

Where a configuration has been measured on real hardware, Nodeau uses the measurement. Where it hasn't, it derives a conservative estimate from the model's own architecture, adds a further margin, and labels the decision as estimated. An estimate is never shown as a measurement.

Model artifact verification

Downloaded from the publisher, checked against a known SHA-256, quarantined on mismatch.

Local OpenAI-compatible API

Bound to 127.0.0.1 with a locally generated key. Streaming supported.

Support bundles

One redacted archive for diagnosis. Nothing is uploaded.

Install ownership ledger

Records what Nodeau installed as distinct from what it found, and prints an uninstall plan before making any change. It does not remove things that were on the machine before it.

Reproducible release artifacts

Pinned versions and checksums, verified end to end before publication.

Nodeau account and sign-in

Sign in at app.nodeau.ai to see your organisation, the installations linked to it and the plan in force.

Batch inference

Submit a file of requests, get results correlated exactly to your inputs. Jobs queue for a whole GPU, survive a control-plane restart, and release the card once the process is genuinely gone. Part of Home Pro and Business. See pricing.

Local dashboard

A read-only view of models, workloads, GPU state and decisions, served by Nodeau itself on your own machine. Authenticated, bound to the loopback interface, and holding no cluster credentials in the browser.

Curated model catalogue

A small, opinionated set chosen to span the card sizes people actually own, from 8 GB to 24 GB and multi-GPU, each pinned to an exact published file from its original publisher, and each carrying the size of card it is for. Every measurement records what it measured, so a figure taken one way can never be silently compared against one taken another.

The everyday commands

run, ps, logs, stop: start a model, see what's running, read its output, free the GPU. Every command speaks --json, exit codes distinguish a refusal from a fault, and every refusal carries a reason code and a remedy.

Installation diagnosis

nodeau doctor now checks Nodeau's own control plane and endpoints, as well as the host and the GPU, including whether the local endpoint really reaches the model rather than merely holding a port open.

Linking a machine to your account

nodeau login approves an installation from your browser and stores a signed entitlement locally. It is checked offline, so a machine with no internet keeps exactly the plan it was granted.

More than chat

Embeddings, reranking, structured output, tool calling and image understanding all run from the same catalogue and the same engine as chat. Measured on Linux with NVIDIA.

Scheduling you can steer

Efficiency, Balanced and Performance, set for a whole fleet or one machine. Balanced is the default and picks the candidate that gives up least of either speed or energy.

Power limits and budgets

Cap what a card is allowed to draw, and set a budget a workload has to fit inside. Nodeau reads the range from the card itself and stays within it.

A hardware ladder in the catalogue

Every curated model says which size of card it is for, from 8 GB up to 24 GB and multi-GPU. The label is guidance and the arithmetic still decides, so a model can fit a smaller card than its label suggests.

Accepting a fit risk yourself

When the only thing between you and running a model is the margin Nodeau adds for hardware nobody has measured, you can accept that risk with --accept-estimate-risk. Nodeau still charges the full figure against anything else that wants the card.

Home Pro, purchasable

Home Pro is on sale at $9.99 a month. Checkout, invoices and self-service plan changes all work, and your installation carries a signed entitlement it checks locally.

One command to add a machine

nodeau fleet invite on the machine you have, nodeau join on the new one. A second machine joined an existing fleet this way on real hardware, and the control plane set up its cache and reporting without help.

Fleet inventory and health

Every machine, every card and every workload in one place, with the health of each. Your machines report to Nodeau Cloud and nothing ever connects back into your network.

Maintenance and drain workflows

Drain a machine when you want to work on it. New work stops arriving, anything already running carries on serving, and the machine comes back when you undrain it.

Performance-aware placement

Choose Efficiency, Balanced or Performance and Nodeau picks the machine and the card to match, from what your hardware has actually shown it can do. It will tell you why it chose what it chose.

macOS support

Apple Silicon runs models on the integrated GPU through Metal. A Mac runs standalone, which suits a laptop, and the fit checks understand that memory is shared with everything else on the machine.

Upgrading in place

Running the installer again moves a machine to a newer release without reinstalling from scratch, and puts back a component an older release left out.

Bring your own model

Give Nodeau a GGUF file of your own. It reads the file's header to work out what the model needs, hashes the bytes so the file is its own identity, and then measures and probes it on a real card before saying what it can do. Importing is not qualifying: a model stays usable for exactly the capabilities it proved. GGUF only, one file per model, and the weights stay on your own machines. Linux with NVIDIA.

nodeau model import ./my-model.gguf --alias my-model

Machine health and alerts

See how each machine is doing, with processor, memory, storage and network alongside the GPU readings. Nodeau keeps a day of it and tells you when something needs attention, in nodeau health and the local dashboard. Every reading is taken by the machine it describes and stays on your hardware. Nothing is sent to you by email or webhook. Storage is reported as how full it is, not as drive health. Linux.

Your own limits on what a fleet runs

Your organisation can set its own limits on what its fleet may run, inside what your plan already allows: how many workloads at once, how many graphics cards, how many batch workers, which models, which cards and which machines. Set them with nodeau governance on a machine, or from your account on the web with Home Pro or Business. A workload refused by a limit is told it was a limit. Lowering a limit never stops anything that is already running. Linux fleets.

Usage, in accelerator-hours

Which workloads held which accelerators, and for how long, added up across the machines you own. The figure comes from the scheduler's own record of what was reserved, not from sampling the cards. If you tell Nodeau what an accelerator-hour is worth to you, it multiplies. Until you do, it shows no cost at all. It is not a bill.

A record of what changed

Your organisation can see what changed and who changed it, including what was refused, kept for a year. It records who, what and when, and never a key, a prompt or a reply.

Release channels you choose

Tell Nodeau which build your fleet should be on, and see which build it is on. A channel only ever moves forward. Nodeau installs nothing for you: you upgrade a machine by running the installer on it.

Maintenance windows

Say when Nodeau may act on your machines on its own, in your own time zone. Work you ask for is never held back by a window, and nothing running is touched when one opens or closes. It is not a scheduler for your work.

Entitlements without a network

A machine that cannot reach the internet can be given its entitlement by hand. It goes through the same checks as one fetched over the network, so an entitlement carried on a stick is never less verified.

Several GPU machines, one control plane

Each machine publishes its own hardware state and is reasoned about separately. Two physical machines have run as one cluster, each with its own GPU, its own cache and its own credentials.

Per-machine hardware observation

Addressable memory, current usage and attached-display state, reported by each machine about itself. On the two-machine cluster every value differed between them, as it should.

Per-machine model verification

Each machine computes a SHA-256 over its own copy of the model and publishes the digest. A machine whose copy is missing, unverified or wrong is not a placement candidate at all. This found genuine silent corruption on a second machine that had been serving answers and reporting healthy.

Explainable placement across candidates

The fit calculation runs once per candidate machine, and every candidate keeps a reason, including the ones that lost. There is deliberately no second, looser rule for choosing a machine.

Heterogeneous GPU reasoning

An RTX 3080 and an RTX 2080 in the same cluster, each scored on what it can actually give the workload rather than treated as one interchangeable “GPU”. A model that fits the first and not the second is admitted on one and refused on the other, by arithmetic.

Exclusive GPU reservations

A card committed to one workload is not offered to another, across services and batch jobs alike. A job that finds every GPU busy waits in a queue and starts by itself when one frees.

Placement stickiness, and holding rather than moving

A healthy workload stays where it is even when another machine scores better, observed doing exactly that with the other machine genuinely winning on score. And when a machine stops reporting, anything already running on it is held rather than re-placed. Moving it would be a decision Nodeau cannot currently justify, so it doesn't make one.

Node-scoped isolation

Each machine's agent can write only its own state, and can read no credentials at all. Verified in both directions on two machines.

Broader hardware validation

Nodeau has run on three Linux machines with four different NVIDIA cards, and on an Apple Silicon Mac. That is a handful of data points rather than a compatibility list, and widening it is the current gate. If you have a card we haven't met, we would like to hear from you.

More measured GPUs

Additional cards measured rather than estimated. Nodeau runs on an unmeasured card by estimating conservatively and saying so, but a measurement is the better answer and belongs in the catalogue.

More model profiles

More models and quantisations, with measured memory and throughput on cards people actually own.

Installer edge cases

More failure modes handled cleanly, better recovery, clearer diagnostics.

More Linux and macOS coverage

Beyond the single measured Ubuntu 24.04 baseline.

Several people in one organisation

Members, each with a role that says what they may do, groups from your identity provider, and credentials for scripts that can only ever do less than the account they belong to. Business. Not in the published build.

Single sign-on

Your organisation's identity provider, for signing in to your account. Business. Not in the published build.

Windows via WSL

The GPU path through WSL is genuinely different and is currently refused rather than half-supported. Native Windows is not planned.

Home experience

Easier model browsing, simpler configuration, and more in the dashboard than it shows today.

Model replication across machines

Each machine already verifies its own copy of a model. Getting a copy there on purpose, rather than downloading it per machine, is the missing half.

Scheduled and recurring batch

Batch jobs that run overnight, or on a schedule, without you being there to submit them.

Model locality as a preference

Nodeau already knows and verifies which machines hold a good copy of a model, and refuses to place a workload on one that doesn't. Preferring a machine that already holds it, so a cold start doesn't pay for a download, is a scoring change that hasn't been made.

Multi-machine capacity planning

Answering “what could this cluster hold?” rather than only “where does this one workload go?”.

Priority queues

Batch jobs queue oldest-first today. Letting an organisation say which work matters more is a Business capability and is not built.

Model inventory and rollout

Which models are where, and moving between versions deliberately.

Upgrading a fleet from one place

Nodeau already knows which build a fleet should be on. Installing it on every machine for you is not built.

Alerts that reach you

Alerts are shown on the machine and in its dashboard today. Sending them to email, a webhook or a pager is not built.

Machine history in your account

A machine keeps a day of its own readings. Seeing that history from your account on the web is not built.

Health-aware rescheduling and failover

Recovering a workload elsewhere when a machine fails. Nodeau does not do this. Placement deliberately keeps a healthy workload where it is, and holds rather than moves one it can't currently vouch for. Noticing that a machine has died, and safely acting on it, is a separate capability that has not been built or tested.

Cloud overflow

Owned hardware first, cloud when policy or capacity requires it. Hybrid scheduling across both.

AMD GPU support

A different runtime and memory story, not a configuration flag.

Broader runtimes

vLLM and others alongside llama.cpp.

Automatic quantisation

Fitting a model to a card rather than refusing it.

Scale to zero

Release the GPU when idle, reload on demand.

Git-to-deploy

A repository as the unit of deployment.

Air-gapped installs and private registries

For organisations that cannot pull from the public internet. An entitlement can already travel without a network; the software itself still comes from public registries.