Home/Products/Bud GPU Foundry
Bud GPU Foundry · Layer 02 · GPU Cloud

Turn deployed GPU capacity into a platform that scales with demand.

Bud GPU Foundry is the GPU-as-a-service control plane. It runs the accelerators you already own as governed services — from bare metal to tokens — with one catalog, one permission model, one audit trail and one bill. Silicon to outcomes, fully integrated. Open source under Apache 2.0.

Overview

Silicon to outcomes, as one integrated stack.

Bud GPU Foundry runs the accelerators you already own, across every cluster and site you register, and sells them as governed services — bare metal, virtual machines, Kubernetes, SLURM and serverless containers — to every tenant you serve, from a single node to a whole cluster, in one click. Then it keeps going, into inference, model services and token-based AI consumption on the same stack.

5 service classes from one catalog 0 platform credentials ever issued to a tenant 30 guarantees, each closed by a check Apache 2.0 · on-prem · sovereign · air-gapped
  • Bud GPU Foundry is Layer 02 of the Bud Novaria AI OS stack — the GPU cloud layer. The capacity is installed; the platform was what was missing. A training team wants nodes and a scheduler, a platform team wants Kubernetes, an ISV wants a machine it can image, a research group wants a container and a notebook, a product team wants an endpoint and a token price. Bud GPU Foundry serves all of them from one fleet across five silicon vendors — NVIDIA, AMD, Intel, Qualcomm, Huawei — with one catalog, one permission model, one audit trail and one invoice.
  • One click, any shape: a tenant asks for a shape (cards, memory per card, interconnect); the platform filters to what that organization may buy, picks exactly one unit by a published rule and says which rule chose it, places the work by topology — the project's region, then clusters with placeable headroom, then the right silicon — and metering starts when the unit is healthy. Nothing before healthy is ever charged.
  • Five service classes from one catalog — bare metal (sole occupancy, metered in node-hours), virtual machines (no shared kernel, allocation-seconds), Kubernetes (a conformant cluster of your own, access brokered just in time), SLURM (partitions, QoS and fair share, accounting reconciled to the platform's record) and serverless containers (scale to zero, wake on demand, stop previewed before it happens) — plus the tenancy model: five isolation grades, strongest first, with service providers offered only hardware- or fabric-enforced grades, and resellers, sub-organizations and white-label on the same tree.
  • Operator controls make the fleet a business: isolation graded per unit, quota you can sell, metering and invoices read from the same phase log the console shows, resellers and white-label, an audit trail and evidence — for enterprises running chargeback by project and department, and for service providers and neoclouds serving mutually untrusting tenants on prepaid or contract billing.
  • The payoff: your silicon, your service, your invoice. Silicon to outcomes, fully integrated. Open source under Apache 2.0.

Installs into your own clusters — on-premise, in colocation, in sovereign and air-gapped environments. No component needs the public internet to serve a tenant.

Value proposition

Idle accelerators become a governed service.

Everything between the accelerator and the invoice is one product: the ways tenants reach the platform, the control plane, the data plane, the site fabric, and the revenue record that ties them together. Adding a new way to consume the fleet never adds a second billing path or a second permission model. That is what keeps the platform governable as it grows from one rack to many sites — and what lets AI services run on top as a tenant, inheriting every guarantee.

Service classes from one catalog5
Isolation grades, each scoped to the unit sold5
Observed lifecycle phases · metering starts at one7
Platform credentials ever issued to a tenant0
architectural properties, not benchmarks · each number's basis in the product brief
Who runs it

A cloud your customers trust, and your finance team can defend.

Most GPU platforms are assembled from schedulers, provisioning scripts and billing add-ons that were never designed to agree. The result is capacity on a dashboard that cannot be placed, charges for starts that never came up, and machines passed to the next customer with no proof they were wiped. Bud GPU Foundry owns the whole lifecycle instead, for three kinds of operator.

01

GPU cloud and service providers

Sell to independent, mutually untrusting customers with isolation enforced in hardware or the fabric, prepaid and contract billing, spend caps and a full enforcement ladder.

02

Enterprises and sovereign operators

Share one fleet across business units with chargeback by project and cost center, residency enforced at placement, and air-gapped deployment as a supported configuration.

03

Resellers and channel partners

Nest customer organizations, divide quota in whole units, apply your own brand and domain, and rate a replayable usage feed in your own billing system.

Fig. 1One control plane owns every step. It discovers what your hardware can run, puts on sale only what you choose to sell, programs each tenant's network and storage as part of provisioning, starts the meter only when what was sold is verifiably usable, and takes every machine back with evidence before anyone else is offered it.
One click, any use case

Describe the shape your work needs. Receive exactly one unit.

The platform filters the catalog to what your organization may buy, picks one unit by a published rule, tells you which rule chose it, and places the work — on one node, or gang-scheduled across many with the fabric in mind.

Fig. 2A shape resolves to one offered unit by a published rule, and the rule is returned in a sentence. Resolution is also a read-only call, so a cost model or a procurement script can ask what a shape would buy without launching anything.
  • Filtered before it is displayed

    What a project's organization may actually buy is decided by its tenant class and isolation ceiling before anything is shown. Units weaker than the ceiling are never offered — not even as alternatives.

  • Placed by topology, not by count

    The project's region, then only clusters that could place this grade and shape right now, then the one with the most headroom, then cards that share a link and a socket at the bandwidth sold. Gang-scheduled work starts all-or-nothing.

  • Everything the console does, from a script or an agent

    The API is the product. Console, command line, Python and TypeScript SDKs and an infrastructure-as-code provider are generated from one specification, and a tool server lets an autonomous agent use the same operations under the same audit trail.

The Bud GPU Foundry customer console's Instances page: seven instances across two projects. Three are healthy and billing, one is waiting in line for an H100 and marked not billed until healthy, one was released, one stopped, and one failed because it did not become healthy within the start deadline, shown at £0.00, never billed.
Fig. 3Customer consoleInstances across an organization's projects: running and billing, waiting in line with its reason, released, stopped, and failed at the start deadline, and never billed.
Metering

Metering starts when what you bought answers. Not a second before.

State is observed from the hardware, never assumed from intent. Three records exist for everything the platform has ever accepted, kept apart on purpose — what was asked for, what was observed, what was billed — and the screen a tenant reads and the invoice they receive come from the same log.

Fig. 4The seven observed phases of every allocation. Each service class declares its own readiness — a container answering, a guest's agent responding, a cluster's control plane serving with its first node joined — and a unit with no declared readiness source cannot be published at all.
  • A failure is a record, not a gap

    Everything that reached admission produces an allocation record, including what failed. An absent record and a zero record are different facts, and the platform keeps the difference. Reasons come from one closed vocabulary: start deadline exceeded, image pull failed, device never attached — each charged nothing.

  • Published start deadlines

    One deadline for a start whose image was already resident, a longer one for a start that had to fetch it. Missing it terminates the allocation, reports a machine-readable reason and charges nothing.

  • Replay cannot double-charge

    A metering event's identity is a pure function of the allocation and its window bounds, so a replay after a broker failure is a no-op rather than a second row. Completeness is verified by an independent nightly recomputation rather than asserted.

One instance's detail page in the customer console. Its phases are listed with the time each was observed after submission (admitted, scheduled, image ready, device attached, healthy), with a marker reading 'billing starts here' on the healthy phase, beside the rule that resolved its unit and the cost so far.
Fig. 5Customer consoleOne instance's start-up, phase by phase, each at the time the platform observed it, with the rule that resolved its unit, and billing starting at healthy, not before.
Key features

What makes the fleet a business.

Schedulers share a cluster; a control plane sells one. These six are the difference between hardware your teams queue for and a service every tenant consumes — and every one of them is a property of the platform, not a process running alongside it.

01

Any silicon, every site

Operationalise NVIDIA, AMD, Intel, Qualcomm and Huawei accelerators, mixed vendors and generations, as a single governed pool. Register another cluster at runtime and quota, placement, addressing and billing extend to it without a second deployment.

5 silicon vendorsone catalog · one fleet · any mix of generations
02

Metering starts at healthy

Seven lifecycle phases are recorded; the charge starts at exactly one — healthy — and a failure is a zero-cost record with a reason from one closed vocabulary. Time spent provisioning, pulling images or failing to start is never charged, on any unit, under any circumstance.

7 observed phasesmetering starts at phase 5 · failed = never billed
03

Many tenants, nothing else shared

Every sellable unit names one isolation grade, ranked strongest first. An operator states once that an organization may buy nothing weaker than a given grade, and every request is measured against it. For service providers whose customers may be rivals, shared-kernel grades are withheld by the platform, not by guidance.

5 isolation gradesbare-metal host → memory-capped slice · per unit sold
04

Serverless that scales to zero

Models and workloads appear when called, release when idle, and chain into compound AI systems. Leases, schedules and idle thresholds release capacity that is not working — each previewed like a manual stop, so nothing is lost that was not stated first.

0 idle costwake on demand · release when idle · stop previewed
05

From capacity into AI consumption

Model catalogs, inference endpoints, serverless models and token metering are delivered by Bud AI Foundry, which runs on Bud GPU Foundry as a tenant like any other — no private interface, no exemption. Bud GPU Foundry meters capacity; Bud AI Foundry meters tokens. Two meters, one truth.

2 meters, one truthallocation-seconds beneath · tokens above · one tree
06

Open source, sovereign by design

Apache 2.0, so the stack that governs your fleet can be audited rather than trusted. Delivered as signed images and versioned charts into clusters you run; an air-gapped site is an ordinary deployment. Regions are declared by the operator, so data residency is a placement record, not a setting someone asserts.

Apache 2.0on-prem · colocation · sovereign · air-gapped
Operations

Every rack sold a tray at a time. Every machine returned with evidence.

Rack-scale systems are not hosts: their trays share one interconnect domain, switch trays, power shelves and liquid cooling. Bud GPU Foundry enrolls the rack as the one unit it is, sells it as bare metal in the units a tenant can hold — a tray, several trays or the whole rack — and takes the rack's shared state into account everywhere it matters.

The Bud GPU Foundry digital twin: a three-dimensional view of a data hall with eleven racks, one rack's compute trays listed on the left, and one compute tray's health, power, coolant temperature and firmware on the right, with a fault-injection panel previewing what a fault would do before it is injected.
Fig. 6Digital twinThe hall floor in three dimensions, one rack's trays and shelves, and one tray's health, power, coolant and firmware. A fault can be rehearsed on any device, with its effects previewed before it is injected.
The provider console's site page for a data hall: 294 machines, 237 in use, 51 available, 2 quarantined and 1,688 kilowatts of power, with sixteen racks drawn by row showing who holds each tray and four racks flagged as needing attention.
Fig. 7Provider consoleSixteen racks by row, who holds each tray, and the racks that need attention.
A quarantined compute tray in the provider console: its GPU firmware reads a version that matches no recorded baseline, it is marked not sellable and offered to nobody, and the acceptance-evidence tab lists what a person must name to release it.
Fig. 8Provider consoleA quarantined tray: its firmware matches no recorded baseline, it is offered to nobody, and the evidence a person must name to release it is on the page.
  • The tray is the unit of sale

    Trays are leased whole, as machines, or built into a tenant's cluster, with the same hand-over, reclaim and host-hour billing as any other machine. A unit of several trays is placed inside one interconnect domain, and a rack whose cooling, power or interconnect is degraded offers nothing that depends on it.

  • Reclaim: every step, every return

    Firmware is read back out of band against its generation's baseline, every disk is sanitized, accelerator memory is cleared and acceptance is re-run. A machine that fails any step is quarantined, never resold, and the evidence is kept for the deletion period.

  • Nothing a tenant holds is touched unannounced

    Firmware installs only from packages whose vendor signature verifies at import, air-gapped sites included. Rollouts run in waves, and held machines go last, inside a maintenance window the tenant can accept or move.

Tenancy

Many tenants on one infrastructure, with nothing else shared.

Your own departments, a service provider's mutually untrusting customers, a reseller's sub-organizations and a sovereign customer can all run on the same fleet at once. What differs between them is recorded as a property of the organization, never as a separate deployment.

Fig. 9One fleet, run by one operator, sold by several businesses. A customer of a reseller sees the reseller: brand, domain, price book and language are properties of the organization. The ladder on the right is what the catalog generator enforces — for service-provider tenants it refuses shared-kernel grades outright, so the choice is never left to a sales conversation.
  • Isolation is a claim about the unit sold

    Each sellable unit names exactly one service class, one isolation mechanism, one metering basis and the tenant classes it may be sold to. A unit binds to machines by what the hardware publishes about itself, so one catalog serves a fleet of mixed generations without a unit landing on the wrong silicon.

  • Two tenant classes, one platform

    Enterprise tenants get every grade, chargeback against internal budgets and a quota ceiling. Service-provider tenants get only grades enforced in hardware or by the fabric, prepaid balance by default, and the full enforcement ladder. The API, the console, the lifecycle and the guarantees never change.

  • A usage feed for someone else's billing

    Metered usage is a continuous, replayable feed keyed on the same windows the platform's own invoices read, so a reseller can rate it in their own system. What they charge is theirs; what was consumed is one number.

Built to monetize

Price it, cap it and invoice it from the same log.

Price books per segment, cost floors and margin per unit, commitments, interruptible capacity, spend caps, nested resellers and white-label are native to the platform, not bolted on. The usage on a screen, the figure on an invoice and the number an enforcement decision is made on are the same number.

The provider console's catalog: seven instance types discovered from the clusters, each with its hardware, how many can be placed now, the price in force per allocation-second, its cost floor and margin, and a switch that puts it on sale.
Fig. 10Provider consoleThe catalog. Every product here was discovered from the clusters, and each shows what can be placed now, the price in force, its cost floor and margin, and the switch that puts it on sale.
An organization's billing overview in the customer console: spend so far this month, the forecast against its spend cap with an explanation of how the forecast is worked out, the rate it is burning now, and a breakdown of where the money went by project.
Fig. 11Customer consoleThe organization's month: spend so far, the forecast against its cap and how it is worked out, the burn rate, and where the money went.
The spend caps page in the customer console: caps on the whole organization, one project, one person and one cost center, each showing what has been spent, what is set aside against it, and its state.
Fig. 12Customer consoleSpend caps on the organization, a project, one person and a cost center, each with what has been spent and what is set aside.
  • Nothing published below its floor

    Every unit's price derives from a cost model covering capacity, power, network, storage and support. Achieved margin is reported per unit at least monthly, and a price below the computed floor needs a recorded decision.

  • Commitments and interruptible capacity

    Term commitments at a discount, backed by a reservation ledger that guarantees the capacity exists. Interruptible capacity at a published discount, with notice never shorter than the tenant's declared checkpoint interval.

  • Credits without a claim

    An availability commitment with a credit schedule, computed from platform telemetry and offered without the tenant having to detect the breach. Contract tenants are billed in arrears, with purchase-order references, and never suspended automatically.

Featured components

Five ways to consume the same fleet.

A machine, a guest, a cluster, a scheduler or a container. Each is an entry in the same catalog, carries one isolation mechanism and one metering basis, and is watched by the same lifecycle informer. Choose by what your work needs, not by which product your vendor sells.

Service classWhat you receiveIsolationMetered on
Bare metalA physical accelerator host provisioned to an operating system you choose, on your own network and storage, reclaimed with verified erasure. Power and break-fix are API calls. Rack-scale systems are sold here too: a tray, several trays or the whole rack.Sole occupancynobody else resident · returned with evidencenode-hours
Virtual machineA hardware-virtualized guest with its own kernel, accelerators passed through at the hardware level, a boot volume, a console and a power-state lifecycle. Snapshots and private images.No shared kernelnever a shared kernel with another tenantallocation-seconds
KubernetesA conformant control plane of your own, with accelerator node pools from the same catalog, your storage classes and your network, reached without a standing credential.Dedicated control planeper-tenant node pools · brokered accessnode-hours · per cluster
SLURMAn HPC cluster with login nodes, partitions, quality-of-service classes and fair share, whose accounting reconciles to the platform's own record. Keep your job scripts and module trees.Per-tenant clusterlogin nodes through the same gatewaynode-hours
Serverless containerA workload declared as an image, a command and a shape, placed on the grade the catalog resolved, reachable by shell, terminal or a published address. Scale to zero, wake on demand.Per gradewhole node to hardware partitionallocation-seconds · GPU-seconds · VRAM-GB-hours
Fig. 13The five service classes. Adding one never adds a second billing path, a second permission model or a second audit trail — which is what keeps the platform governable as it grows from one rack to many sites.
Positioning · as of Q4 2026

NVIDIA's tools run the rack. Bud GPU Foundry runs the business on it.

Bud GPU Foundry is often mistaken for NVIDIA's software or compared with Rafay. NVIDIA's reference software for GPU clouds provisions, schedules and monitors, but none of it meters or invoices a tenant. Rafay sells capacity on a closed platform built around NVIDIA. Bud GPU Foundry is the open layer that turns any vendor's fleet into a governed, metered, invoiced service.

Fig. 14Where Bud GPU Foundry sits. NVIDIA documents its fabric managers as not multi-tenant aware and leaves the tenant portal to an independent software vendor, so per-tenant partitions, metering and invoices come from the layer above. That layer is Bud GPU Foundry, on NVIDIA or any other silicon.
The incumbent

Rafay — a closed GPU-cloud platform, NVIDIA-led

  • Proprietary, priced per node; NVIDIA AI Cloud-Ready validated, with Cisco and Dell among its partners
  • Certified with NVIDIA Run:ai and deploys it as a one-click catalog item, alongside its own GPU sharing (passthrough, MIG, time-slicing)
  • Bare metal, VMs, Kubernetes, SLURM, notebooks and inference, with white-label portals and SKU management
  • Token Factory since April 2026; usage is metered, with rating and invoicing handed to billing partners
  • Calls itself hardware-agnostic; its marketing and named references are NVIDIA-only

On features, Rafay is the closest match in this lane. The difference is license, silicon, how the bill is produced, and how much of the hardware's lifecycle the platform owns.

Bud GPU Foundry

Parity on the service, further on the business

  • Open source under Apache 2.0 — the stack that governs your fleet can be audited, forked and kept
  • NVIDIA, AMD, Intel, Qualcomm and Huawei in one catalog, mixed vendors and generations in one fleet
  • Rating, invoices, chargeback, prepaid and contract billing native — from the same log as the meter, which starts at healthy
  • Nested resellers with quota in whole units and a replayable usage feed, and no route into a customer's work
  • Firmware baselines, reclaim with evidence and racks sold a tray at a time, backed by thirty tested guarantees

Above tokens, the rest of Bud Novaria AI OS — training, grounding, guardrails and agents — runs on the same fleet under the same tenancy and audit trail.

Where Rafay wins

If your fleet is NVIDIA end to end and you want a commercially supported Run:ai deployment, NVIDIA validation, or a SaaS-hosted controller you do not run yourself, Rafay is the shorter path today. It has the longer list of named neocloud and telco customers and a wider partner channel.

Where the comparison gets specific

Platform risk. Ask what happens to an NVIDIA-certified control plane when the next rack is not NVIDIA. Bud GPU Foundry answers with an open stack and 600+ supported accelerator SKUs across five vendors.

Where you are starting from. Greenfield fleets run on Bud GPU Foundry today. A migration path for Rafay-managed fleets is on the roadmap.

Current as of Q4 2026 · Rafay facts from its own published materials, checked 30 Oct 2026 · Full capability matrix in the product brief · Talk to a solutions architect

Thirty guarantees

Refusals as specified as its features.

Bud GPU Foundry is held to thirty guarantees, stated in the negative. Each is closed by an automated check that attempts the forbidden behavior and fails if it succeeds. Most describe something that happens routinely elsewhere in this market. Six of them:

  1. 01Never bill for capacity that never became healthyMetering derives from the phase log and starts at one phase, and no other.
  2. 02Never display capacity it cannot placeAvailability is derived from placeability per cluster, with a freshness stamp on every figure.
  3. 13Never expose a tenant to another tenant's residual accelerator memoryMemory clearing is verified per hardware generation before a device is re-offered.
  4. 18Never let a reseller see inside its customers' workA reseller reaches quota, consumption and spend; never a workload, a session or a log line.
  5. 23Never offer a machine again after a tenant changed its firmwareReclaim reads every component back out of band; a mismatch quarantines.
  6. 29Never smooth, clamp, interpolate or discard a metered quantity before it is ratedThe quantity rated is the quantity metered.

All thirty, with what holds each one, are in the product brief.

Go deeper

The full story, in depth.

The five service classes in full, the isolation grades and tenant classes, the seven lifecycle phases and the reason vocabulary, quota and placement, rack-scale operations and reclaim, billing, the thirty things Bud GPU Foundry will never do — and every headline number with its basis.

Bud GPU Foundry is released under Apache 2.0. The public repository link will appear here at the open-source release.

Get started with Bud

Put your fleet on it.

The fastest way to see what a GPU-as-a-service control plane does for the accelerators you already own is a proof-of-concept on your infrastructure, with your tenants.

01 Register one cluster — any vendor, any generation — and publish a catalog.
02 Onboard two tenants with different isolation ceilings and watch the catalog differ.
03 Read the first invoice against the phase log. They cannot disagree.