Home/ Products/ Bud GPU Foundry/ Product Brief
Bud GPU Foundry overview
Product Brief · Layer 02 · GPU Cloud

Bud GPU Foundry

The GPU-as-a-service control plane. Run the accelerators you already own — NVIDIA, AMD, Intel, Qualcomm and Huawei, across every cluster and site you register — as governed services, from bare metal to tokens, with one catalog, one permission model, one audit trail and one bill. Open source under Apache 2.0.

Product reference v2.1 October 2026 ~22 min read
01At a glance

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 and segment 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.

Service classes from one catalog5
Isolation grades, scoped to the unit sold5
Observed lifecycle phases7
Platform credentials issued to a tenant0
the five service classes are detailed in §03 · every number's basis in §06
What it is
The GPU-as-a-service control plane: everything between the accelerator and the invoice — the ways tenants reach the platform, the control plane, the data plane, the site fabric, and the revenue record that ties them together — delivered as one signed set you install in your own data centers
One pooled fleet of NVIDIA, AMD, Intel, Qualcomm and Huawei accelerators, mixed vendors and generations, sold through one catalog with one permission model, one audit trail and one bill
Built for two operators: enterprises giving departments governed self-service on a shared fleet, and service providers, neoclouds and resellers selling GPU-as-a-service to mutually untrusting customers — with AI services on top as a tenant of the same platform
What it is not
✕Not a scheduler bolted onto a cluster — tenancy, metering, isolation and billing are the product, and adding a service class never adds a second billing path or a second permission model
✕Not a single-vendor operating layer — the catalog binds units to what the hardware publishes about itself, so one fleet of mixed silicon is one catalog, and the control plane is open source under Apache 2.0
✕Not someone else's cloud — it installs into clusters you run; no component needs the public internet to serve a tenant, so an air-gapped site is an ordinary deployment

What became of Bud Pod. Bud GPU Foundry succeeds Bud Pod. Pod was the experimentation layer: researchers shared GPUs and went from notebook to production in one click. Bud GPU Foundry keeps that and becomes the GPU-as-a-service control plane for enterprises and service providers — five service classes from one catalog, isolation per tenant, metering that starts when what was bought answers, and AI consumption as a tenant of the same platform.

02Where it fits

Layer 02 — the governed fleet under the stack.

Bud GPU Foundry turns the raw capacity LayerZero exposes into a served, multi-tenant fleet. Every layer above trains, serves, grounds, governs and builds on capacity it sells — and Bud AI Foundry runs on it as a tenant, which is how token-billed customers inherit its guarantees.

You pool — accelerators across your data centers, sites and regions become one governed fleet. Register another cluster at runtime and quota, placement, addressing and billing extend to it.

They consume — departments or paying tenants get bare metal, guests, clusters, schedulers and containers from one catalog: quota'd, metered from healthy, and isolated down to the fabric.

The capacity is installed. The platform is what was missing. Accelerators arrive faster than the means to sell them well. 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. Serving each separately leaves several stacks, several bills and no honest answer to who used what. Bud GPU Foundry serves all of them from one fleet, one catalog and one invoice.

03Capabilities, in full

Six things one control plane has to get right.

The service classes, the shape resolution, the tenancy, the observed lifecycle, quota and placement, and the step from capacity into AI consumption — each expanded to the specifics an evaluator needs.

01Five service classes, one catalogBare metal · virtual machines · Kubernetes · SLURM · serverless containers — each an entry in the same catalog with one isolation mechanism and one metering basis, watched by the same lifecycle informer5 classes
02Shape resolution — one click, any use caseDescribe the shape; the platform filters to what you may buy, picks exactly one unit by a published rule, says which rule chose it, and places the work on one node or gang-scheduled across many1 unit · 1 rule
03Tenancy — grades, classes, resellersFive ranked isolation grades · two tenant classes · reseller organizations with sub-organizations, white-label and price books per segment · a usage feed for someone else's billing5 grades
04Observed lifecycle & meteringSeven phases read from the hardware, never assumed from intent · metering starts at healthy · failures are zero-cost records with a reason from one closed vocabulary · three records kept apart7 phases
05Quota, placement & scaleQuota granted per organization, per unit, per region, in whole instances · borrowing inside the organization · a published placement rule · gang scheduling all-or-nothing · queues with a position and a reason1 placement rule
06From capacity into AI consumptionModel catalogs, inference endpoints, serverless models and token metering delivered by Bud AI Foundry as a tenant · Bud GPU Foundry meters capacity, Bud AI Foundry meters tokens · sub-tenancy carries through2 meters · 1 truth

Five ways to consume the same fleet, governed by one control plane

A machine, a guest, a cluster, a scheduler or a container. Choose by what your work needs, not by which product your vendor sells. Adding a service class never adds a second billing path, a second permission model or a second audit trail.

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 on, off, reset, rescue and maintenance state are API calls attributed to a person or token; out-of-band console access never crosses your network.Sole occupancynobody else resident · returned only after verified erasure, 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. A stopped guest keeps its boot volume and addresses and stops being metered. Snapshots and private images; confidential execution where the silicon offers it, sold as its own unit.No shared kernelnever a shared kernel with another tenant · placed by topology, not by countallocation-seconds
KubernetesA conformant upstream cluster of your own — three most recent minor releases, highly available control planes with encrypted state — with accelerator node pools drawn from the same catalog, your storage classes and your network. Credentials issued just in time, expiring on their own.Dedicated control planeper-tenant node pools · no standing kubeconfig to leaknode-hours · per cluster
SLURMLogin nodes, named partitions, quality-of-service classes and fair share, with an accounting database and your own accelerators behind them. Keep your job scripts, module trees and workflows; containers run natively inside jobs; a POSIX filesystem with per-user quotas is mounted across every node.Per-tenant clusteraccounting reconciled to observed allocations · divergence goes to human reviewnode-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 stable published address. Creation returns a handle; replay is safe by construction; stop is previewed before it happens; leases, schedules and idle thresholds release what is not working.Per gradewhole node to hardware partitionallocation-seconds · GPU-seconds · VRAM-GB-hours

Any use case, any environment, one click

Describe the shape your work needs. The platform filters to what your organization may buy, picks exactly 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. 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.

01You ask for a shape4 cards · 80 GB per card · high-bandwidth interconnect — or name a unit outright.
02Filtered to what you may buyYour tenant class, your isolation ceiling, your project's region. Units you may not buy stay hidden.
03Chosen by a published ruleSmallest memory per card that satisfies the request; ties go to the stronger grade. One sentence names the rule.
04Exactly one unitWhole node · 4 × 80 GB · dedicated fabric path · metered in allocation-seconds, fixed for the workload's life.
05Placed by topologySingle node, or gang-scheduled all-or-nothing across a cluster, with the fabric in mind.

When nothing fits, you are told exactly why

What happenedReasonWhat you are told
No offered unit fits the shapeno_offered_skuThe nearest offered units and what each one lacks: memory, card count, interconnect, grade or model
The combination is not in the catalogoff_catalogueThe combination and the catalog version, and nothing else
Not sold to your tenant classprofile_refusedThe constraint that refused it, without naming units you may not buy
The unit exists but is not on salenot_offeredThe grade and the written reason. Never a waitlist for something that is not a capacity problem
The grade exceeds your organization's ceilingabove_ceilingThe ceiling. Alternatives the ceiling refuses are never offered as substitutes
Your organization's terms permit nothingterms_exclude_allA different audience: no edit to the request will help, and the operator must act
No quota right nowqueuedA queued request with its position in line and a machine-readable reason

Templates hold a reusable declaration and are copied into the resource at launch, so editing one never changes anything already running. A curated starter library can declare a memory floor, so a request that could never have loaded is refused at declaration rather than at runtime. Every template and image carries a trust tier — official, verified or community.

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 not billed until healthy, one was released, one stopped, and one failed because it did not become healthy within the start deadline, never billed.
Fig. 1Customer 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. The waiting instance is marked not billed until healthy; the failed one reads £0.00.

Many tenants and customer segments on one infrastructure, with nothing else shared

Every sellable unit names exactly one service class, one isolation mechanism, one metering basis and the tenant classes it may be sold to. Isolation is a claim about the unit sold, not about the platform in general — and every unit carries one isolation grade, ranked strongest first. An operator states once that an organization may buy nothing weaker than a given grade, and every request in every project is measured against it.

GradeWhat the tenant getsRankSold to
Bare-metal hostThe machine itself, your OS, nobody else residentrank 0both tenant classes
Whole nodeEvery accelerator on a node, yours for the durationrank 0both tenant classes
Dedicated GPU in a guestA whole device passed through to your own kernelrank 1both tenant classes
Hardware partitionDedicated memory and compute pathsrank 2both tenant classes
Memory-capped sliceA share with a hard memory ceilingrank 3enterprise only
Enterprise tenant classService-provider tenant class
Who the tenants areYour own business units, departments or subsidiaries, sharing one fleetIndependent customers who are mutually untrusting and may compete with each other
Isolation postureEvery grade is available, including the memory-capped slice, because a hostile neighbor is not the threatOnly grades enforced in hardware or by the fabric. Shared-kernel grades are withheld by the platform, not by guidance
BillingChargeback by project and cost center, against internal budgetsPrepaid balance by default; contract billing in arrears after an identity and credit assessment
EnforcementQuota ceilings and notifications; the eviction ladder exists but is rarely armedThe full ladder for prepaid tenants; contract tenants are never suspended automatically for balance reasons
What does not changeThe API, the console, the command line, the service classes, the lifecycle, the permission model, the audit trail and the guarantees. A tenant class is a property of the organization and of the unit being sold, not a separate product and not a separate deployment.

Resellers and white-label. A reseller organization holds sub-organizations it creates, administers and is billed for. It is granted quota and divides it among its customers in whole instances; consumption aggregates back up the same tree. A reseller administrator has no route to a customer's workloads, sessions or logs — the audit trail records the boundary holding. Brand, logo, color, custom domain and language are properties of an organization, applied to the console, documentation links, invitations and notifications. Rate cards are drafted, compared and published with an effective date, and a published rate never applies retroactively.

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, and what was billed. The screen a tenant reads and the invoice they receive come from the same log, so they cannot disagree.

Fig. 2Each 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, a scheduler node online, a bare-metal host reachable on your own operating system. A unit with no declared readiness source cannot be published at all.
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. 3Customer 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.
ReasonWhat it meansCharged
start deadline exceededIt did not reach healthy within the deadline for its start path. Terminated.nothing
image pull failedThe image could not be retrieved: wrong reference, missing credential, or a registry that did not answer.nothing
device never attachedIt was scheduled and the accelerator never attached by the mechanism its grade requires.nothing
provisioning failedA machine, guest, cluster or scheduler did not complete provisioning; the underlying system's own words are carried alongside.nothing
released before healthyThe allocation disappeared before it was ever usable. Recorded as a failure.nothing
backfilledReconstructed after the fact from observed timestamps, for capacity that ran without going through the platform's own path.nothing · counted
stoppedEnded because somebody asked it to stop.up to the stop
failedThe workload itself failed, with the cluster's own words carried alongside.up to the failure

The log is append-only and keyed on allocation and phase, so a replay is a no-op rather than a second row. A metering event's identity is a pure function of the allocation and its window bounds, so a replay after a broker failure cannot double-charge. Completeness is verified by an independent nightly recomputation rather than asserted.

Scales with demand: quota you can sell, placement you can predict

Quota is the instrument an operator sells with. A grant is an organization's allowance for one unit in one region, in whole instances. Projects draw on it through named shares, idle headroom is borrowable inside the organization — never across organizations — and every placement follows the same published rule.

01The project's regionAnd only that region. Residency is a placement record, not a preference.
02Clusters that can place it nowThose that could actually place this grade and shape — not those with a matching free-device count.
03The most headroomCapacity is spread, never packed into the first cluster that fits. Draining and cordoned clusters are never chosen.
04The right silicon by topologyCards that share a link and a socket, at the bandwidth sold. Re-run for queued work as headroom changes.
Gang scheduling starts all-or-nothing Whole instances, never fractions Queue position and a reason, never silence Preemption never shorter than the declared checkpoint interval

Network isolation, durable storage, and several ways in through one authorizer

Network. A tenant's network is programmed as part of provisioning them, and it is the same private routed scope whichever service class they bought. Multi-node units receive a dedicated fabric partition; a fabric the platform cannot confirm offers no capacity at all. Platform control surfaces default-deny from every tenant, and the orchestration substrate is not a network a tenant workload can see, let alone authenticate to. Egress is metered per tenant whether or not it is billed.

The provider console's network tab for a site, listing five network planes: compute fabric, accelerator interconnect, north-south, storage and out-of-band management. Each row names the technology and its controller, the isolation mechanism per organization, ports up, health and when isolation was last verified.
Fig. 4Provider consoleThe network planes at a site: what each one carries, what controls it, how one organization is kept from another on it, and when that was last verified. Here the compute fabric is isolated by a partition key per organization, the accelerator interconnect by a partition per organization, and north-south traffic by a VRF and VNI enforced on the DPU.

Storage. The platform drives the storage systems you already own — network volumes, a shared POSIX filesystem, boot volumes, S3-compatible object storage, versioned images and declared-ephemeral scratch disk. Each tenant receives its own namespace, access zone and object policy in the backing system; the enforced quota is the number billed; checkpoint writes are acknowledged only once durably stored; and a tenant with a contractual requirement supplies and controls the key protecting its data.

The provider console's storage tab for a site: 7.03 PiB of capacity across two storage systems, 2.61 PiB promised in quotas to five organizations, one quota nearly full, and the monthly amount billed on quotas, with each storage system listed with what it serves and the API the platform drives it through.
Fig. 5Provider consoleStorage at a site: the systems the platform drives but does not run, what is promised to organizations in quotas, and what those quotas bill. Each machine's own disks belong to whoever holds the tray, are never shared, and are cryptographically erased before the tray is sold again.

Access. SSH on your own key material or a short-lived certificate, a browser terminal and console on a single-use ticket, managed notebooks, brokered kubectl with credentials issued just in time, and SLURM login over the same gateway. Every session has a beginning, an end, an actor and, where recording is enabled, a replayable transcript. Revocation reaches live connections. Operator staff hold no standing access and cannot attach to a running tenant workload — the break-glass path is cordon and evacuate, refused and audited otherwise.

The members tab of an organization in the customer console, listing four people with their roles (owner, billing, admin, member), when they joined and how access was granted, with an Invite someone button and no outstanding invitations.
Fig. 6Customer consoleAn organization's members and their roles. Invitations are one-shot and bound to the address they were issued to.

Billing an enterprise buyer recognizes, and spend caps that act

An allocation window with a provisioning phase priced at zero exists on the first record ever written. Metering, rating, invoices, chargeback, budgets and enforcement all read that one log, which is what makes a disputed charge answerable: a tenant receives a per-window explanation of what was billed and why, including the provisioning windows charged at zero.

rung 1NotifyThe tenant is told they are approaching the limit, with time to act. Nothing changes about what is running.
rung 2HoldNew work stops being admitted. Work already admitted keeps running. A hold never drains, because draining a training run to enforce a budget destroys more value than it protects.
rung 3Revoke accessInteractive access is withdrawn while the work continues, so nobody can start new work by hand around the hold.
rung 4EvictThe last rung, and only for tenant classes where it applies. A contract-billed tenant never reaches it automatically; suspension needs a recorded human decision.
Prepaid balance drawn down, forecast visible Contract in arrears, purchase-order references, cost-center breakdown Commitments backed by a reservation ledger Nightly reconciliation across balance, scheduler and invoice
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 it is worked out, the current burn rate, and a breakdown by project.
Fig. 7Customer consoleThe organization's month: spend so far, the forecast against its cap and how it is worked out, the rate it is burning now, 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 with what has been spent, what is set aside and its state.
Fig. 8Customer consoleSpend caps on the whole organization, a project, one person and a cost center, each with what has been spent and what is set aside against it.

Commercial terms. 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 nothing is published below its computed floor without a recorded decision. Term commitments are discounted and backed by a reservation ledger that guarantees the capacity exists, and a future-dated reservation returns a confirmed grant or an honest refusal with an alternative date. Interruptible capacity is offered at a published discount, only to work that has declared itself resumable, with notice never shorter than its checkpoint interval. An availability commitment carries a defined measurement, a credit schedule by breach band and published exclusions, with credits computed from platform telemetry and offered without a claim — and the published figure is bounded by the recovery time actually demonstrated in a timed restore drill. Member and cost-center caps refuse new work at submission and never stop work already running.

From capacity to AI consumption: inference, model services and tokens on the same stack

Model catalogs, inference endpoints, serverless models, token metering and agent services are delivered by Bud AI Foundry, which runs on Bud GPU Foundry as a tenant like any other. It receives no private interface and no exemption, so a token-billed customer inherits the isolation, quota and audit trail of the capacity beneath them. The capacity plane does not need to know what a token is; the model plane does not re-implement quota, isolation or metering. What connects them is specified, not assumed.

Bud GPU Foundry meters capacity

allocation-seconds · node-hours · capacity-hours — from the phase log, from healthy on. Margin per endpoint is a measurement, not an inference at the end of a quarter.

Bud AI Foundry meters tokens

tokens served — per endpoint, per customer, per model, per agent service — recorded apart from the capacity. Bud AI Foundry's own customers appear as sub-organizations, so a token-billed customer's consumption rolls up through the same tree as everything else.

Where several tenants are served by one model process, no tenant code executes and the isolation claim is made at the request boundary — stated as its own unit in the catalog rather than borrowing a compute grade's claim.

04How it works

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 all together. AI services sit on top as a tenant of the same platform, which is how they inherit its guarantees.

Fig. 9The planes of Bud GPU Foundry. The revenue plane reads the same log the console shows, so a screen and an invoice cannot disagree.
Three state domains, kept apart

Identity, revenue and platform state live in separate domains that are never joined and never reference each other. A failure in one cannot take the others with it.

Exactly one writer per seam

The API writes what was asked for. The operator writes the substrate. The lifecycle informer alone writes the phase log that metering reads. Nothing else can.

Delivered as one signed set

Signed images and versioned charts in a declarative deployment tree, pinned and upgraded together through a staging canary. Which version runs where is reviewable configuration.

Regions are declared, not discovered

Each cluster's region is stated by the operator who onboards it, and every tenant placement happens inside the project's region. Residency is evidence, not a preference.

Handlers and reconcilers, separated

Work that must have exactly one writer runs under a lease. Work that must scale with demand runs behind a load balancer. Neither is allowed to become the other.

Your hardware, your data centers

The platform installs into clusters you run. No component needs the public internet to serve a tenant, so an air-gapped site is an ordinary deployment.

Six places in the console, and what each one is for

PlaceWhat it holdsWho
OperateFleet inventory, clusters, hosts and individual accelerators, with health and the reason anything is not sellable. Networks, address pools, storage systems.operator
SellThe sellable unit set with its reasons, quota granted per organization per region, rate cards, cost floors and margin.operator
BuildTemplates, images and the starter library; launch with resolve-before-submit for every service class; queues with a position and a reason.tenant
WatchDetail for a machine, guest, cluster or workload: phases with the metering marker, live logs, utilization, sessions, the embedded terminal and the stop preview.both
GovernOrganizations, sub-organizations, projects, people, roles, invitations, domains, tokens, keys and the audit trail.both
SpendUsage, chargeback by cost center, invoices, budgets and caps, showing the same numbers the invoice will carry.tenant

The API is the product; the console, the command line and the SDKs are clients of it, generated from the same published specification. Every operation has a command-line command, the console may call only published endpoints, and no decision lives in a place the command line cannot reach.

Two consoles, one specification

The provider console is where an operator runs sites, clusters, machines, firmware, images, the catalog, quota and organizations. The customer console is where a tenant launches and watches instances, Kubernetes clusters and leases, and reads usage, spend caps, chargeback and invoices. Both are clients of the same published API, and neither can do anything the command line cannot.

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 console · SellThe 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.
A whole-rack lease in the customer console: 18 machines with 72 GPUs in one interconnect domain, a scheduled maintenance notice for a firmware update with buttons to accept the window or choose another time, a notice that its image is deprecated with its retirement date, and the machines with power and firmware read from outside.
Fig. 11Customer console · WatchA whole-rack lease as its organization sees it: a notified firmware window it can accept or move, its image's retirement notice, and its machines, each read from outside.
A tenant's Kubernetes cluster in the customer console: 16 nodes with 64 GPUs, a stacked control plane, its interconnect partition and firmware version, and each node listed with state, GPUs, partition and firmware, with observability marked unobservable because the platform does not read inside it.
Fig. 12Customer console · WatchA tenant's cluster on whole machines: every node's state, its interconnect partition and its firmware, all read from outside, and nothing inside the cluster observed.
05Operations: rack-scale, reclaim, firmware

Every rack sold a tray at a time, every machine returned with evidence, and nothing a tenant holds touched unannounced.

Accelerated infrastructure is only as trustworthy as its least-verified firmware and only as current as its oldest image. This is the half of a GPU cloud most platforms leave unspecified: how a rack is enrolled and sold, how a machine comes back, and how the fleet below the tenant is kept current.

Rack-scale systems, sold as bare metal a tray at a time

Some accelerated systems are not hosts. A rack-scale system is a set of compute trays sharing one accelerator interconnect domain, its switch trays, its power shelves and its liquid cooling — delivered, powered, cooled, partitioned and updated together. Bud GPU Foundry enrolls and operates the rack as the one unit it is, and sells it through the bare-metal service class in the units a tenant can hold: a tray, several trays, or the whole rack. Nothing about a tray's lease, reclaim or bill changes because it sits in a rack; what changes is that the rack's shared state is taken into account everywhere it matters.

The rack is the unit ofWhat that means
DeliveryEnrolled whole — compute trays, switch trays, power shelves and cooling inventoried together — and accepted tray by tray, each passing its own acceptance before it can be sold.
Power and coolingDraw, caps and profiles, inlet and return temperatures, coolant flow and leak sensors are recorded against the rack rather than whichever tray reported them.
PartitionA tenant's share of the interconnect domain is a partition that excludes every other tenant, made at hand-over and removed at return. A unit of several trays is placed inside one domain, so its trays talk at the bandwidth sold.
FirmwareTray, switch-tray and power-shelf firmware belong to one baseline for the rack's generation, and a rollout is ordered by who holds each tray.
MaintenanceWork on a shared component is scheduled against every tray it affects and every tenant holding one, through notified windows.
FaultsA coolant leak or power fault takes every machine it affects off sale until resolved. A rack whose cooling, power or interconnect is degraded offers nothing that depends on it, and says which. Every health event is acknowledged and resolved by a named person; a hardware return is tracked as a case against the tray and part.
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. 13Digital 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. 14Provider consoleThe same hall as the site page draws it: sixteen racks by row, who holds each tray, and the racks that need attention.
One rack in the provider console: a red notice that a compute tray's cold-plate leak sensor read wet and the tray was powered off and quarantined, an amber notice that the interconnect domain is degraded while a switch tray updates, and the rack's elevation of power shelves and compute trays.
Fig. 15Provider consoleOne rack: a coolant leak on one tray contained and quarantined, the interconnect domain degraded while a switch tray updates, and the rack's elevation of trays and power shelves.

Reclaim: every step, on every return

A machine reaches the sellable pool only after its firmware baseline is verified against the recorded standard for its hardware generation and its burn-in suite passes. While a tenant holds it, in-band access to its management controller is disabled, isolation is enforced at the fabric against a tenant with root, and the platform reads it only from outside — power, temperatures, fans, power supplies and the event log — shown to the tenant for the window they held it. When it comes back, reclaim runs every step, every time:

01Firmware read backOut of band, against the generation's baseline. Firmware the controller cannot read back is a stated limit, never a pass.
02Every disk sanitizedMedia that held tenant data is erased, with evidence retained for the deletion period and issued on request.
03Accelerator memory clearedVerified per hardware generation before the device is offered to anyone else.
04Acceptance re-runOnly a machine that passes every step re-enters the pool. One that fails is quarantined, with the failing step in front of the operator.
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. 16Provider 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. A release runs reclaim again from its first step.

Firmware and images: one baseline per generation, rolled out by who holds what

Each hardware generation has one current baseline naming the package for every component it covers, and every machine is read back against it out of band, per component — so a fleet's firmware is a record rather than a spreadsheet. A package is imported from the vendor's mirror, by upload, or carried by hand into an air-gapped site, and its vendor signature (and measurement manifest, where published) is verified at import; a tampered package is refused at import, not discovered at flash. Each device class has exactly one writer. Devices the platform does not update — fabric switches, storage systems, facility controllers — are read for the record, with who updates them, and never written.

Wave 1CanaryOne machine nobody holds takes the baseline first, is read back and passes acceptance before anything else moves.
Wave 2The unheld poolBatches of a stated size, each read back and re-accepted before it is offered for sale again.
Wave 3Provider cellsOne machine at a time, drained and returned, so the cell keeps selling while it is updated.
Wave 4Held machinesOnly inside a window notified to the holder, who can accept it or move it within a published limit.
A component, read back against its baselineWhat it means
matchAt the level its generation's current baseline names.
behindAt a level an older baseline names. Due in the next rollout, and never shown in the same color as drift.
driftAt a level no baseline names. The machine is quarantined until it is brought back and re-accepted.
unreadableThe management controller cannot read the component back. A stated limit, and never a pass.
A firmware rollout for a rack-scale generation in the provider console: 8 of 263 devices updated, 4 updating now, 90 queued, 161 deferred to their holders' windows and 0 failed, with each device's current step and who runs it, and the rollout policy.
Fig. 17Provider consoleA firmware rollout in flight: what is updated, what is updating now and who runs each step, what is deferred to its holder's window, and the policy that stops it.
The firmware page for a site in the provider console: device classes grouped by who updates them — the platform, the operator, the network team and facilities — each with device count, baseline, standing against the baseline and who applies updates.
Fig. 18Provider consoleEvery device class at a site that carries firmware: the classes the platform writes, with each one's standing against its baseline, and the classes it only reads for the record, with who updates them.
The images page in the provider console: seven machine images, each with its state (current, candidate or deprecated with a retirement date), operating system and kernel, accelerator driver, CUDA version, how many trays run it and when it was built.
Fig. 19Provider consoleMachine images and the software each one carries, with its state from candidate to current to deprecated, and its retirement date. A tray boots only an image whose signature the site has verified; a deprecated image keeps running where it is until it retires.

Every image states the accelerator software it carries and each component's version, and is signed and published by digest. Advisories against an image a tenant's cluster runs are shown on that cluster, never applied for them. Outside a window, the platform acts on a held machine only to contain a fault — a leak, a power fault, a failing accelerator — and the tenant is told what was done, when and why.

06Deployment & compatibility

Runs where you are: installed into your data centers, pinned as one set, upgraded through a canary.

Fonts and assets are self-hosted, images are mirrored into your own registry, and no component needs the public internet to serve a tenant. Register another cluster at runtime and the API, the console and quota span it; withdrawal cordons first and refuses a cluster still holding tenant capacity.

Silicon, environments and delivery

Silicon

NVIDIAAMDIntelQualcommHuawei

Mixed vendors and generations in one fleet. 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. 600+ accelerator SKUs supported across the Bud Novaria AI OS.

Environments

On-premiseColocationSovereignAir-gappedMulti-site

An air-gapped deployment is a supported configuration rather than a special case. Each cluster's region is declared by the operator who onboards it, and work is placed inside its project's region, so data residency is a record you can show rather than a setting you assert.

Delivery & operations

Signed imagesVersioned chartsStaging canaryDrilled restoreApache 2.0

Every pin records how mature that component is, so upgrade cadence is planned against real risk. The control plane is restored from backup within a published recovery time, verified by timed drill. Faulty accelerators drain without data loss and are quarantined individually. Every externally visible commitment is validated by a repeatable drill before it is published.

A tenant's life, both halves specified

Onboarding is usually designed carefully and exit usually is not. The exit half is what an enterprise procurement review asks about first, because it decides whether choosing the platform is reversible.

01SignupSignup to running capacity without human intervention, subject to the identity-verification tier.
02OnboardingFederated identity, directory provisioning, network scope, storage and contract terms configured before the first workload.
03OperatingProjects, people, quota, budgets, machines and services, all self-served, with an audit trail the tenant reads for its own scope.
04ClosureA final reconciled invoice to the moment of closure, not to the end of a billing period.
05ExitData exported within a published window at full rate, then deleted — backups included — and evidenced on request.

Directory deactivation revokes platform access, active sessions and issued keys within a published time bound. A tenant can move between organizations, resellers, plans or billing models without interruption to what is running and without published addresses changing.

07Proof & methodology

Every headline number, with its basis.

The figures on this page are architectural properties and published commitments, not benchmark results. Each is paired with where it comes from — and the thirty guarantees below are stated in the negative so they can be held to.

5
Service classes from one catalog
BasisThe machine-readable catalog. Every sellable unit is bound to exactly one service class — bare metal, virtual machine, Kubernetes, SLURM or serverless container — one isolation mechanism, one metering basis and one set of permitted tenant classes. Any combination not in the matrix is refused before capacity is reserved.
5
Isolation grades, ranked
BasisBare-metal host and whole node at rank 0, dedicated GPU in a guest at rank 1, hardware partition at rank 2, memory-capped slice at rank 3 (enterprise only). The claim is attached to the row being sold, never to the platform in general, and an organization's ceiling is compared by rank on every request.
7
Observed lifecycle phases
BasisAdmitted, scheduled, image ready, device attached, healthy, released, failed — each read from the capacity actually running the work. Metering starts at healthy, phase 5, and at no other phase. Phases 1–4 are never metered; failed is a zero-cost record with a reason.
0
Platform credentials issued to a tenant
BasisGuarantee 16, asserted against the API and against the access gateway's certificate issuer. Your Kubernetes cluster is yours; the platform's own orchestration control plane is never reachable from a tenant, in any form. Certificates, tickets and cluster credentials are minted on demand and expire on their own.
30
Guarantees, each closed by a check
BasisCapabilities stated in the negative, not statements of intent. 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.

Thirty things Bud GPU Foundry will never do

  1. Bill for capacity that never became healthyMetering derives from the phase log, and starts at one phase and no other.
  2. Display capacity it cannot placeAvailability is derived from placeability per cluster, with a freshness stamp on every figure.
  3. Reclaim interruptible capacity on less notice than the tenant's declared checkpoint intervalThe notice period is a property of the unit and is delivered before reclamation begins.
  4. Discard logs when a workload crashesLines are read from the tenant log store, never from the thing that wrote them.
  5. Publish a best-case latency figure as a typical oneEvery published figure is a measured percentile with its measurement method stated.
  6. Require a tenant to detect a platform failure in order to be credited for itCredits are computed from platform telemetry and offered without a claim.
  7. Charge a stopped resource more than a running one without saying so at the point of stoppingThe stop preview and the unit's metering basis are both shown before the action.
  8. Withhold compliance documentation or security features behind a spend thresholdA published commercial policy, not a matter of sales discretion.
  9. Hold the only copy of a key protecting tenant data where the tenant has contracted otherwiseTenant-supplied keys, whose revocation renders the data unrecoverable.
  10. Suspend a contract-billed tenant automatically for balance reasonsFor that class, enforcement is a quota ceiling and a notification; suspension needs a recorded human decision.
  11. Present utilization telemetry as a charge basis on any unit where it cannot observe the tenantBlind classes are declared in the catalog in advance and render as a stated absence.
  12. Offer a fractional tier to mutually untrusting tenants unless the isolation is enforced in hardwareTenant classes are a property of the catalog row, and the generator refuses the combination outright.
  13. Expose a tenant to another tenant's residual accelerator memoryVerified memory clearing per hardware generation before a device is re-offered.
  14. Return a machine to the pool without verified erasure of the media that held tenant dataSanitization is part of the reclaim workflow, with evidence retained for the deletion period.
  15. Sell a dedicated fabric path that is in fact shared with another tenantFabric partitions are per tenant, and a fabric the platform cannot confirm offers no capacity at all.
  16. Issue a tenant credentials of any kind to the platform's own orchestration control planeAsserted against the API and against the access gateway's certificate issuer. Your cluster is yours; ours is never reachable.
  17. Require a tenant to hold a long-lived credential to reach what they boughtCertificates, tickets and cluster credentials are minted on demand and expire on their own.
  18. Let a reseller see inside its customers' workA reseller relation reaches quota, consumption and spend; there is no relation from it to a workload, a session or a log line.
  19. Allow a capacity request to bypass quota accounting by any pathAdmission policy checks that work is routed by the scheduler, and anything that slips past is counted.
  20. Promise live migration of accelerator-attached guestsStated as impossible rather than deferred, so no plan ever quietly assumes it.
  21. Market an isolation grade it does not enforce on the specific unit being soldRuntime pinning by provenance, and grade constraints checked against what the hardware publishes.
  22. Give operator personnel an interactive session into a running tenant workloadThe break-glass path is cordon and evacuate; the attempt is refused and audited.
  23. Offer a machine again after a tenant changed its firmwareIn-band management access is disabled for the allocation, and reclaim reads every component back out of band; a mismatch quarantines.
  24. Run its own agents or controllers with standing write access on a machine handed to a tenantThe one credential kept to a tenant's cluster stays at the site, is used only for operations the tenant asks for, and is declared.
  25. Interrupt a machine a tenant holds outside a window they were told of, except to contain a faultEvery operator action on a held machine is named and recorded, and fault containment is notified when it happens.
  26. Install firmware whose vendor signature has not verifiedPackages are verified at import, air-gapped sites included, and a baseline can name only a package that verified.
  27. Stop work that is already running because a member's spend cap was reachedA member cap refuses new work at submission; only the organization's own ladder can reach running work.
  28. Reveal one member's usage to another member who may not read the organization's usageA member reads their own attribution; the breakdown by member needs the relation that reads the organization's usage.
  29. Smooth, clamp, interpolate or discard a metered quantity before it is ratedThe quantity rated is the quantity metered, and a late correction is spent the moment it lands.
  30. Show a tenant any signal derived from another tenant's cached or in-flight stateCache scope on a shared serving engine is set by the platform, never taken from the request.

How these claims are framed. Counts on this page — service classes, grades, phases, guarantees, capability groups — are properties of the catalog and the lifecycle, not benchmark results. Deployment-specific numbers (utilization gains, start times on your hardware, metering accuracy against your own accounting) are established in a proof-of-concept on your infrastructure. Independent assessment is completed before the first external tenant and repeated at least annually; the platform is validated against the accelerator vendor's own requirements for AI clouds — service delivery by API, hard and soft multi-tenancy, telemetry, metering accuracy and lifecycle operations.

08Positioning · as of Q4 2026

Not NVIDIA's platform, not Rafay's: the open control plane between them and your customers.

Bud GPU Foundry is compared with two things it is not. NVIDIA's own software runs the hardware and the jobs on it, but does not sell it. Rafay sells it, on a closed platform built around NVIDIA. Bud GPU Foundry is the layer that turns any vendor's fleet into a governed, metered, invoiced service, and it is open source under Apache 2.0.

Where Bud GPU Foundry sits relative to NVIDIA's software

NVIDIA's reference software for GPU-cloud providers — Infra Controller, Base Command Manager, Mission Control, UFM for InfiniBand and NMX for NVLink — provisions, schedules, recovers and monitors. None of it meters, rates or invoices a tenant, and NVIDIA's own documentation leaves the tenant portal to an independent software vendor. That is the layer Bud GPU Foundry occupies. On NVIDIA systems it reads and drives the vendor's own managers — the network planes it reports are controlled by UFM and NMX-C, and rack firmware is applied through NVIDIA's rack management service — rather than replacing them.

Fig. 20NVIDIA's tools run the rack; Bud GPU Foundry runs the business on it. Base Command Manager's free license, for example, excludes services resold to third parties, and NVIDIA documents its fabric managers as not multi-tenant aware — so per-tenant partitions, metering and invoices have to come from the layer above.

Rafay: parity where it is due, and where Bud GPU Foundry goes further

Rafay is the name most sovereign operators, neoclouds and telcos meet first in this lane, and it is the closest competitor on scope: bare metal, VMs, Kubernetes, SLURM, notebooks, inference and, since April 2026, Token Factory, sold with white-label portals and SKU management. It is NVIDIA AI Cloud-Ready validated, certified with NVIDIA Run:ai and deploys it as a one-click catalog item. The difference is not the feature list's length. It is license, silicon, how a bill is produced, and how much of the hardware's lifecycle the platform owns.

CapabilityRafayBud GPU Foundry
Parity — both platforms do this
Service classesBare metal, GPU and CPU VMs, Kubernetes, SLURM-as-a-Service, notebooks (Jupyter, Ray, Kubeflow), inference and serverless inferenceBare metal (incl. rack-scale trays) · VMs · Kubernetes · SLURM · serverless containers, from one catalog
Self-service catalogSelf-service catalog with SKU designer (PaaS Studio) and marketplaceCatalog discovered from the hardware, filtered by tenant class and isolation ceiling before display
GPU sharingFull passthrough, MIG and time-slicing, chosen per SKUFive ranked isolation grades, from bare-metal host to memory-capped slice, claimed per unit sold
Network isolationPer-tenant VRF, VLAN and EVPN; InfiniBand partition keys via UFMRouting domains north-south, fabric partitions east-west, verified by probing from inside the tenant's segment
White-labelLogo, colors, domain, product name, locale and currency per partnerBrand, domain, price book and language as properties of an organization
Access & identityEnterprise SSO, RBAC, zero-trust kubectl proxy, audit logsOne authorizer for SSH, browser terminal, notebooks, kubectl and SLURM login; every session a record
API & automationREST, Terraform/OpenTofu, CLI, GitOps, SDKsOne published specification; console, CLI, Python and TypeScript SDKs, IaC provider and an agent tool server generated from it
DeploymentSaaS, self-hosted or Rafay-managed controller; air-gapped packageInstalled in your data centers; air-gapped as an ordinary deployment
TokensToken Factory: token-metered model APIs with pricing, quotas and plansBud AI Foundry as a tenant — capacity and token meters on one tree
Where Bud GPU Foundry goes further
LicenseProprietary, priced per nodeApache 2.0 — the control plane can be audited, forked and kept
SiliconNVIDIA in all marketing and references; AMD Instinct and Intel Gaudi 3 in a docs support matrixNVIDIA · AMD · Intel · Qualcomm · Huawei in one catalog, mixed vendors and generations in one fleet
InvoicingMeters usage and exports it; rating and invoices handled by partnersRating, invoices with purchase-order references, chargeback, prepaid balances and contract billing native, from the same log as the meter
When the meter startsNot specified in published materialsAt healthy, and nowhere earlier; failed starts are zero-cost records with a reason
Resellers & sub-tenantsNot found in published materialsNested organizations, quota divided in whole units, a replayable usage feed, no route into a customer's work
Reclaim evidenceHosts "attested and securely wiped"; method not publishedFirmware read-back, disk sanitization, memory clearing and acceptance on every return, evidence kept
Firmware managementNot found in published materialsOne baseline per generation, signed packages, staged rollouts by who holds what, drift quarantines
Rack-scale operationsGB200/GB300 NVL72 supported and certifiedRacks enrolled whole and sold a tray at a time; leaks and faults take affected machines off sale; digital twin for rehearsing faults
Published guaranteesSLAs set per engagement; no figures publishedThirty guarantees, each closed by an automated check; credits computed from telemetry without a claim
Above tokensStops at tokensTraining, grounding, guardrails and agents on the same fleet — the rest of Bud Novaria AI OS
Where Rafay wins

If your fleet is NVIDIA end to end and you want a commercially supported Run:ai deployment, NVIDIA validation and a managed-service option, Rafay is the shorter path today. It has the longer list of named neocloud and telco customers, resale and solution partnerships with Cisco and Dell among others, a SaaS controller if you do not want to run one, notebook and Ray environments as catalog items, and an AI-assisted observability product.

Where a Rafay customer runs Run:ai, they are running NVIDIA's orchestration through Rafay's layer, not an alternative to it — and since NVIDIA open-sourced Run:ai in October 2026 as the KAI Scheduler, that orchestration is available beside any control plane, Bud GPU Foundry's included.

Where the comparison gets specific

Platform risk. Rafay describes itself as hardware-agnostic, but its story and references are NVIDIA-only. The question to put to an NVIDIA-certified credential is what happens to the control plane when the next rack is not NVIDIA. Bud GPU Foundry runs a mixed fleet as one catalog, on an open stack you can audit, with 600+ supported accelerator SKUs across five vendors.

The bill. Rafay meters and hands rating and invoicing to billing partners. In Bud GPU Foundry the meter, the invoice and the enforcement decision read one log, so a screen and an invoice cannot disagree and a disputed charge is answerable per window.

What sits above. Rafay stops at tokens. Bud GPU Foundry is Layer 02 of Bud Novaria AI OS, so training, grounding, guardrails and agents run under the same tenancy and audit trail.

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

Apache 2.0, auditable Silicon-neutral across five vendors Meter, invoice and enforcement from one log Every machine returned with evidence Air-gapped as an ordinary deployment

Comparison current as of Q4 2026 · Rafay facts from rafay.co and docs.rafay.co, checked 30 Oct 2026 · NVIDIA facts from nvidia.com and docs.nvidia.com · "not found" means not stated in published materials

09Who it's for Optional

Two kinds of operator. Every kind of tenant.

Bud GPU Foundry is for every organization with accelerators in racks and demand in queues — whether the tenants are internal departments, paying customers, or AI services of its own.

Enterprise

Enterprise platform teams

Give every department governed self-service on a shared fleet — quota by department, chargeback by project and cost center, every isolation grade available, idle headroom borrowed inside the organization.

Provider

Service providers & neoclouds

Sell GPU-as-a-service to mutually untrusting customers on your own hardware — hardware- and fabric-enforced isolation only, prepaid or contract billing, spend caps that act, and a usage feed for your own rating.

Sovereign

Sovereign & regulated operators

Run a full GPU cloud in disconnected, air-gapped and regulated environments — regions declared not discovered, export-control screening and evidence as platform features, tenant-held keys.

Channel

Systems integrators & resellers

A reseller organization with its own brand, domain, price book and sub-organizations — quota divided in whole instances, consumption rolled up the same tree, no route into a customer's work.

Research

Research & HPC groups

SLURM delivered as a governed tenancy — login nodes, partitions, QoS, fair share, a shared POSIX filesystem, topology-aware job placement — with accounting that reconciles to the platform's record.

Product

Teams shipping inference

Serverless containers that scale to zero and wake on demand, and Bud AI Foundry's endpoints, model catalog and token metering running on the same fleet as a tenant.

10Questions

What evaluators ask first.

What is Bud GPU Foundry?

Bud GPU Foundry is an open-source (Apache 2.0) GPU-as-a-service control plane from Bud Ecosystem. It turns the accelerators an organization already owns into a governed, multi-tenant cloud inside its own data centers: bare metal (including rack-scale systems sold a tray at a time), virtual machines, Kubernetes, SLURM and serverless containers from one catalog, isolated per tenant, metered from the hardware and billed on one invoice. It is Layer 02 of the Bud Novaria AI OS.

Is Bud GPU Foundry an NVIDIA product?

No. Bud GPU Foundry is built by Bud Ecosystem and is silicon-neutral: NVIDIA, AMD, Intel, Qualcomm and Huawei accelerators run in one catalog, and mixed vendors and generations run in one fleet. On NVIDIA systems it works with NVIDIA's own hardware managers (such as UFM and NMX for fabric and NVIDIA's rack management service for firmware) rather than replacing them.

Does Bud GPU Foundry replace NVIDIA Run:ai, Mission Control or Base Command Manager?

They do different jobs. NVIDIA's software provisions hardware, schedules jobs, manages fabrics and recovers failures; none of it meters, rates or invoices tenants. Bud GPU Foundry is the business layer above: the catalog, tenancy, isolation per unit, metering from healthy, billing, resellers and reclaim with evidence. Schedulers such as Run:ai (open source since October 2026 as the KAI Scheduler) run on capacity Bud GPU Foundry sells.

How is Bud GPU Foundry different from Rafay?

Both sell GPU capacity as bare metal, VMs, Kubernetes and SLURM with self-service and white-label. Bud GPU Foundry differs in five ways: it is open source under Apache 2.0 where Rafay is proprietary; it runs a mixed-vendor fleet where Rafay's marketing and references are NVIDIA-only; it rates and invoices natively from the same log as the meter, where Rafay hands invoicing to billing partners; it supports nested resellers; and it owns the hardware lifecycle — firmware baselines, reclaim with evidence and rack-scale operations — backed by thirty published, tested guarantees.

Rafay is the shorter path for an all-NVIDIA fleet that wants a commercially supported Run:ai deployment, NVIDIA validation or a SaaS-hosted controller.

What are the five service classes?

Bare metal (sole occupancy, metered in node-hours; rack-scale systems are sold here a tray, several trays or a whole rack at a time), virtual machines (no shared kernel, allocation-seconds), Kubernetes (a conformant cluster of the tenant's 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). Each is an entry in the same catalog with one isolation mechanism and one metering basis.

When does billing start?

At healthy, and nowhere earlier. Every allocation passes seven observed phases — admitted, scheduled, image ready, device attached, healthy, released, failed — and metering starts at phase 5, healthy. Provisioning, image pulls and failed starts are never charged; a failure is a zero-cost record with a reason from one closed vocabulary.

How does Bud GPU Foundry keep tenants isolated?

Every sellable unit carries one of five ranked isolation grades: bare-metal host and whole node (rank 0), dedicated GPU in a guest (rank 1), hardware partition (rank 2) and memory-capped slice (rank 3, enterprise only). Service-provider tenants, whose customers may be rivals, are offered only grades enforced in hardware or by the fabric. Network separation is enforced by routing domains and fabric partitions, accelerator memory is verifiably cleared between tenants, and operator staff hold no standing access to tenant work.

What happens to a machine when a tenant gives it back?

Reclaim runs every step on every return: firmware is read back out of band against the hardware generation's baseline, every disk is sanitized, accelerator memory is cleared and acceptance is re-run. A machine that fails any step is quarantined and never resold, and the evidence is retained for the deletion period.

Can Bud GPU Foundry run air-gapped or in a sovereign environment?

Yes. It installs into clusters the operator runs, and no component needs the public internet to serve a tenant, so an air-gapped site is an ordinary deployment. Firmware packages carried into an air-gapped site are signature-verified at import. Each cluster's region is declared by the operator, so data residency is a placement record. Accounts are screened against sanctions and restricted-jurisdiction lists at creation and recurrently.

What are the thirty guarantees?

Thirty capabilities stated in the negative — for example, never bill for capacity that never became healthy, never display capacity it cannot place, never return a machine to the pool without verified erasure, never let a reseller see inside its customers' work. Each is closed by an automated check that attempts the forbidden behavior and fails if it succeeds. The full list is in section 07 of this brief.

Which accelerators are supported?

NVIDIA, AMD, Intel, Qualcomm and Huawei, across 600+ accelerator SKUs supported by the Bud Novaria AI OS. A unit binds to machines by what the hardware publishes about itself, so one catalog serves a fleet of mixed vendors and generations without a unit landing on the wrong silicon.

11Go deeper & next steps

The platform around the fleet.

This brief is the reference for Bud GPU Foundry. For the platform-level argument — why compute, training, serving, grounding and governance belong on one plane — read the whitepaper, or return to the product overview.

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.