Bud Ecosystem White paper
October 2026
Bud Novaria AI OS · GPU-as-a-service control plane

Bud GPU Foundry
The GPU-as-a-Service Control Plane

Sell accelerated infrastructure as governed services, from your own data centers.

The Bud GPU Foundry digital twin: a three-dimensional hall floor with racks, power and cooling paths, and one tray's health, power, coolant and firmware readings
Bare metalRack-scale systemsVirtual machinesKubernetesSLURMContainers
5
Service classes, one catalog, one invoice
5
Isolation grades, each scoped to the unit sold
30
Testable guarantees, each closed by a check
0
Platform credentials ever issued to a tenant
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Contents

What this paper covers.

  • SummaryExecutive Summary
  • —The challenge, the answer, and who this paper is for02
  • Ch. 01Platform Foundations
  • 1What the platform covers06
  • 2The catalog: what may be sold08
  • 3Architecture12
  • Ch. 02Service Classes
  • 4Bare metal as a service15
  • 5Rack-scale systems18
  • 6Virtual machines as a service21
  • 7Kubernetes as a service23
  • 8SLURM as a service26
  • 9Containers and the workload surface27
  • Ch. 03Operational Integrity
  • 10Lifecycle and metering integrity30
  • 11Quota, scheduling and placement33
  • 12The tenant network fabric35
  • 13Storage services38
  • Ch. 04Access and Developer Experience
  • 14Reach: shells, terminals and notebooks42
  • 15The developer surface44
  • 16Logs, telemetry and audit46
  • Ch. 05Tenancy and Commercial Model
  • 17Organizations, projects and people49
  • 18Channel, segments and white-label53
  • 19The commercial model54
  • Ch. 06Trust and Operations
  • 20Security and compliance60
  • 21Tenant lifecycle63
  • 22API, console and command line65
  • 23Deployment and operating model67
  • 24Firmware, images and maintenance71
  • Ch. 07Beyond Capacity
  • 25AI services on top: Bud AI Foundry as a tenant76
  • Ch. 08Reference
  • 26Capability index78
  • 27Thirty guarantees: what the platform will never do91
  • —In summary, and next steps94
Bud Ecosystem01
Bud GPU Foundry · Executive SummaryBud
Executive Summary

Run your accelerators as a cloud your customers trust, and your finance team can defend.

Accelerated capacity is among the most valuable infrastructure an organization will ever own, and among the hardest to sell well. Bud GPU Foundry is the control plane that turns it into a governed, multi-tenant cloud inside your own data centers: bare metal, rack-scale systems, virtual machines, Kubernetes, SLURM and containers, offered from one catalog, isolated per tenant, metered from the hardware and billed on one invoice.

The challenge

Most GPU platforms are assembled from schedulers, provisioning scripts and billing add-ons that were never designed to agree with one another. The symptoms are familiar: capacity on a dashboard that cannot be placed, charges for workloads that never started, isolation promised in a sales deck rather than enforced in the fabric, and machines passed to the next customer with no proof they were wiped.

The Bud GPU Foundry answer

One control plane owns the entire lifecycle. 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.

Built 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 fully supported air-gapped deployment.

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.

Bud Ecosystem02
Bud GPU Foundry · Executive SummaryBud

Six reasons operators build their GPU cloud on Bud GPU Foundry

01

Five ways to consume, one platform

Bare metal, rack-scale systems, virtual machines, Kubernetes, SLURM and containers from one catalog, one API and one invoice. New hardware appears in the catalog the day its cluster is registered, with no release required.

02

Billing that stands up to scrutiny

The meter starts at healthy and nowhere earlier. Provisioning, image pulls and failed starts are never charged, and every invoice line traces back to events observed on the hardware itself.

03

Isolation you can prove

Every isolation claim is attached to the specific unit being sold, enforced in hardware or by the network fabric, and verified by probing from inside the tenant's own segment, not asserted from configuration.

04

Every machine returned with evidence

Firmware read back out of band, every disk sanitized, accelerator memory cleared and acceptance re-run on every return. A machine that fails any step is quarantined, never resold.

05

Sovereign by design

Runs in your own data centers across as many sites and clusters as you register, fully air-gapped where required. Data residency is a placement record you can show, not a setting you assert.

06

Built to monetize

Price books per segment, cost floors and margin per unit, commitments, interruptible capacity, spend caps, nested resellers and white-label: native to the platform, not bolted on.

One governed lifecycle, end to end

Discover

Hardware classes and the units each cluster can run

Sell

You choose what goes on sale, at a price in force

Provision

Machine, network and storage in one workflow

Observe

Seven phases read from the hardware

Meter

From healthy to release, and never before

Reclaim

Wiped, verified and re-accepted, with evidence

Bud Ecosystem03
Bud GPU Foundry · Executive SummaryBud

From silicon to AI services, one integrated stack

Bud GPU Foundry is the GPU cloud layer of the Bud Novaria AI OS. It sits between the hardware you already own and the model, inference and agent services that Bud AI Foundry delivers on top of it, as a tenant like any other.

Bud AI Foundry

Model catalogs · inference endpoints · token metering · agent services. Running on Bud GPU Foundry as a tenant like any other.

Bud GPU Foundry

Catalog · tenancy and access · isolation · placement · observed lifecycle · metering, billing and enforcement · reclaim.

Your infrastructure

Multi-vendor accelerators · rack-scale systems · fabric and storage you already own · as many sites and clusters as you register.

Figure A. One integrated stack. The capacity plane does not know what a token is, and the model plane never re-implements quota, isolation or metering. What connects them is specified rather than assumed.

Who this whitepaper is for

This paper is written for the people who have to make a GPU cloud work commercially and defend it technically: the product leader who sets the catalog and price book, the platform engineer who operates the fleet, the security function that signs off on isolation and evidence, and the finance team that reconciles the invoice.

How to read this paper

Chapter 01 covers what the platform sells and how it is built; Chapter 02 the five service classes; Chapters 03 to 06 the operational, access, commercial and trust disciplines that apply to all of them; Chapter 07 how Bud AI Foundry delivers AI services on the same foundation; Chapter 08 the reference: 16 capability groups and the 30 guarantees the platform is held to.

Bud Ecosystem04
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 01

Platform Foundations

What the platform covers, the catalog of what may be sold, and the architecture that keeps one fleet governable as it grows.

Part I · Platform FoundationsBud
Section 01

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

A buyer of accelerated capacity does not want one product. A training team wants nodes and a scheduler; a platform team wants Kubernetes; an ISV wants a VM it can image itself; a researcher wants a container and a notebook. Bud GPU Foundry delivers all five from one fleet, one catalog and one bill, with the same tenancy, authorization model, audit trail and metering discipline for each.

Service classWhat the tenant receivesIsolationMetered on
Bare metalA whole physical accelerator server handed over with root on its operating system and its own kernel, booted from an approved image or the tenant's own, attached to their own network and storage, and reclaimed by verified erasure before anyone else is offered it.Sole occupancy of the machine, isolated at the fabricHost-hours, from hand-over to return
Virtual machineA hardware-virtualized guest running its own kernel with accelerators passed through at the hardware level, a boot volume, a console and a power-state lifecycle.No shared kernelAllocation-seconds
KubernetesA conformant Kubernetes cluster of the tenant's own, built on whole machines handed over to them, administered by the tenant, with accelerator support installed and reached without a standing credential.Dedicated machines and control planeHost-hours per node, from its join
SLURMAn HPC cluster with login nodes, partitions, quality-of-service classes and fair share, whose accounting reconciles to the platform's own record.Per-tenant clusterNode-hours
ContainerA workload declared as an image, a command and a shape, placed on the grade the catalog resolved, reachable by shell, terminal or published address.Per grade, from whole node to hardware partitionAllocation-seconds, GPU-seconds or VRAM-GB-hours
Bud Ecosystem06
Part I · Platform FoundationsBud

The rule that holds them together

Every service class is an entry in the same catalog, carries one isolation mechanism and one metering basis, and is observed by the same lifecycle informer. Adding a service class does not add a second billing path, a second authorization model or a second audit trail, which is what keeps the fleet governable as it grows.

Your hardware, your data centers

The platform installs into your own data centers: one center manages every site, and each site runs a hardware layer of its own. Assets are self-hosted and the component set is version-pinned, so an air-gapped site is a supported deployment rather than an exception.

Regions are declared, not discovered

Each cluster's region is stated by the operator who onboards it, and placement happens inside the project's region, so residency is a record you can show rather than a setting you assert.

The two tenant classes

A tenant class is a property of the organization and of the unit being sold. It is not a separate product and not a separate deployment.

EnterpriseService provider
Who the tenants areAn operator's own business units, departments or subsidiaries, sharing one fleetIndependent customers who are mutually untrusting, and may be commercial rivals
Isolation postureEvery grade is available, including the memory-capped slice, because a hostile neighbor is not the threat modelOnly grades whose isolation is enforced in hardware or by the fabric. Shared-kernel grades are withheld by the platform, not by policy 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 is available but 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 client, the service classes, the lifecycle, the authorization model, the audit trail and the guarantees
Bud Ecosystem07
Part I · Platform FoundationsBud
Section 02

An enumerated set, discovered from the hardware, chosen by the provider, enforced at admission.

Capacity is sold as an enumerated set of units. Each one names exactly one service class, one isolation mechanism, one metering basis and one set of permitted tenant classes. Anything outside that set is refused before capacity is reserved.

The set is not typed in by hand: the platform discovers what each cluster's hardware can actually run and proposes the units, and the provider decides which of them go on sale. A unit binds to machines by what the hardware publishes about itself rather than by a product name, so one enumerated set serves a fleet of mixed generations without a unit quietly landing on the wrong silicon.

The Bud GPU Foundry provider console catalog page, listing discovered instance types with hardware, placeable count, price, cost floor and margin, and an on-sale switch
Figure 1 · Provider console. The 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.
Bud Ecosystem08
Part I · Platform FoundationsBud

The five isolation grades

Grades are ranked, strongest first. Each names what the tenant gets, where the platform observes the attachment that starts the meter, and which tenant classes may buy it.

GradeRankWhat the tenant getsAttachment observed fromSold to
Bare metal host0The whole machine, with root on its own operating system and kernel and no other tenant resident on itThe site's report of hand-over: image written, network attached, machine reachableBoth classes
Whole node0Every accelerator on a node dedicated to one tenant for the durationThe node's full device setBoth classes
Dedicated GPU in a guest1A whole device passed through to a hardware-virtualized guest running its own kernelThe host-side device bindBoth classes
Hardware partition2A hardware-partitioned fraction of a device with dedicated memory and compute pathsA started containerBoth classes
Memory-capped slice3A share of a device with a hard memory ceiling enforced by the sharing runtimeA started containerEnterprise

The ceiling is an organization's policy

An organization carries an isolation ceiling. An operator says once that an organization may buy nothing weaker than a dedicated guest, and every request in every project is measured against it. A unit the ceiling refuses is never offered as an alternative, because listing it would advertise an isolation grade that is not enforced for that tenant.

Ask for a shape, receive one unit

A tenant asks for cards, memory per card, and interconnect where it matters. The platform filters to what the organization may buy, chooses by a published rule (the smallest memory per card that satisfies the request, breaking ties toward the stronger grade) and returns the chosen unit with one sentence naming what was asked, what was chosen and which rule chose it. The resolution is then fixed for that workload's life.

The same question, without buying anything

Resolution is available as a read-only call, so a cost model or a procurement script can ask what a shape would buy without launching it. A project can also list its organization's offerings: the units it may request and could launch in its region now, with grade, card count, memory and metering basis. The list says which units, never how many are free.

Bud Ecosystem09
Part I · Platform FoundationsBud

Discovered from the hardware, sold by decision

Discovered from the clusters

Hardware is discovered per class (family, card memory, partitioning and sharing capability, cards per machine) from what each machine publishes. For each class and each grade a cluster supports, the platform proposes the units: whole-card counts up to what one machine holds, the whole machine, memory-capped slices, and each hardware partition the card reports. New hardware appears the day its cluster is registered, without a release.

A grade only where it can run

A grade is offered on a cluster only when some machine there meets its device requirement and the runtime it needs exists on that cluster. A grade the fleet cannot place is never listed, so the catalog cannot advertise an isolation mechanism a cluster has no means to enforce.

The provider decides what is sold

Everything discovered starts not for sale. Putting a unit on sale is the provider's decision, and it is refused unless a price is in force for that unit now. A price approved to start later is not enough, because everything launched before it would be unrated. The provider can also add a shape the proposed set does not cover.

The rules stay reviewed

The grades, what each requires of a device and a runtime, their ranks, the metering bases and the tenant-class guards are the platform's rules, reviewed with the platform rather than edited per deployment. Every proposed unit is validated against them before it can be sold, and the same rules generate the API's accepted values and the cluster admission policy's allowed set. A unit whose isolation claim waits on a verification that has not yet passed is shown locked, with the reason.

The fabric is stated

Every multi-card and multi-node unit names its interconnect, and whether high-bandwidth interconnect is preserved between cards. A unit sold with a dedicated fabric path receives one; a unit that is not is not described as though it were.

Blind classes are declared

Where a grade prevents the platform from observing a tenant (a device passed into a guest it does not enter, a whole machine it does not read inside) telemetry says so in advance rather than reporting a zero. A declared absence is a disclosure; a zero would be a charge basis.

Bud Ecosystem10
Part I · Platform FoundationsBud

When a request cannot be met

A refusal is a specified response, not an error page. Each case names exactly what the tenant is told, and nothing more.

When a request cannot be metWhat the tenant is told
No offered unit fits the shapeThe nearest offered units and what each one lacks: memory, card count, interconnect, grade or model. A unit that fits but cannot launch in the region now is named as not available there right now, rather than queued for ever
The combination is not in the catalogThe combination and the catalog version, and nothing else
The unit is not sold to this tenant classThe constraint that refused it, without naming units the tenant may not buy
The unit exists and is not on saleThe grade and the written reason. Never a waitlist for something that is not a capacity problem
The grade exceeds the organization's ceilingThe ceiling. Alternatives the ceiling refuses are never offered as substitutes
The organization's own terms permit nothingA different failure with a different audience: no edit to the request will help, and the operator must act
A spend cap would be passedWhich cap refused (the organization's, a project's, a cost center's or the requester's own), what has been spent against it, and when that figure was computed. Nothing already running is stopped
The prepaid balance is spentThe balance, what was spent against it and when. Recording a payment releases the hold without anyone acting
A cap could not be evaluatedA refusal, never an admission at zero: a limit the platform cannot read lets nothing through
No quota right nowA queued request with its position in line and a machine-readable reason. A queue is not an error
Bud Ecosystem11
Part I · Platform FoundationsBud
Section 03

One control plane, a hardware layer at every site, one writer per seam.

Bud GPU Foundry installs into your own data centers and presents one surface to tenants: the console is compiled into the platform itself, so no separate web runtime ships. One center manages every site; each site runs a hardware layer of its own, at the site, and the center speaks to it only through a contract of its own.

Relational state is split into three domains by blast radius (identity, revenue and platform) which are never joined and never given references across the line, so a failure in one cannot take the others with it. Every seam has exactly one writer: the API writes product state, the operator writes substrate objects, and the lifecycle informer alone writes the phase log that metering reads.

Consumption

Console · command-line client · REST API · SSH and terminal · a tenant cluster's own kubectl through the gateway · SLURM login · generated clients for your own automation. Every one of them is a client of the same specified API.

Control plane

API and console · tenancy and lifecycle reconcilers · the allocator that chooses every machine · service-class provisioners for guests and schedulers · fabric and address management · storage service · access gateway · metering and enforcement.

Data plane

Admission and quota with cohorts and fair share · a policy engine that fails closed · container and hardware-virtualized runtimes · bare-metal provisioning · device modes from whole card to hardware partition · gang and topology-aware scheduling.

Revenue plane

The append-only phase log · the window log, zero-cost windows included · a deduplicated metering store · a ledger of every cap, hold and balance, which is the authority admission decides on · rating, invoices and chargeback, never an enforcement source · a replayable event broker.

Site · per data center

One provider per capability at each site: machine lifecycle (power, boot, image and erase), network isolation, acceptance, out-of-band health, events and Kubernetes. A second claim on any capability is refused at start. A site holds write access to its own machines and nothing central, so no one process can power-cycle every site's machines.

Figure 2. The reference architecture. The center chooses, the site observes; the revenue plane reads the phase log and is never an enforcement source.
Bud Ecosystem12
Part I · Platform FoundationsBud
Resource types

Organization · project · workload · machine lease · tenant cluster · provider cell · site · rack · volume · network · image · capacity class · quota grant · host acceptance. The operator is their sole writer; the API never reaches into substrate fields, and the substrate never writes product state.

Reconcilers and request handlers are separated

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

The center chooses, the site observes

The center's allocator decides which machine serves which tenant; the site's providers carry that out and never choose a machine themselves. What happened is reported back with the site's own timestamps, and those are what billing reads, so a slow link between the two delays a record, never changes it.

Signed, pinned and upgraded as one set

Signed images and versioned charts with a declarative deployment tree, so which version runs where, and with what values, is reviewable configuration. The whole component set moves together through a staging canary, with a single recorded exception path for isolation-affecting fixes.

Three records, kept apart on purpose

Three records exist for everything the platform has ever accepted. Intent is what was asked for, written by the API only. Observation is the phase log, written by the lifecycle informer only. Billing is a set of allocation windows derived over that log, never written twice. The screen a tenant reads and the invoice they are sent come from the same log, so they cannot disagree and arrive as a dispute.

Intent
What was asked for. Written by the API only
Observation
The phase log. Written by the lifecycle informer only
Billing
Allocation windows derived over the log, never written twice
Why this matters

Most GPU platforms let the scheduler, the provisioner and the billing system each keep their own opinion of what happened. Bud GPU Foundry allows exactly one writer per seam and derives everything else, which is why a tenant's screen, the operator's occupancy report and the invoice always describe the same events.

Bud Ecosystem13
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 02

Service Classes

Bare metal, rack-scale systems, virtual machines, Kubernetes, SLURM and containers: five ways to consume one fleet, each with the same lifecycle, metering and audit discipline.

Part II · Service ClassesBud
Section 04

A machine handed over whole, and taken back with evidence.

A bare-metal unit is a whole physical accelerator server given to one tenant: root on its operating system, their kernel, their drivers, their fabric and their storage. It is the strongest isolation the fleet can sell and the hardest thing to operate honestly, because the platform has to give a machine to someone holding root and get it back in a state it can prove.

Provisioning and reclamation are therefore one governed workflow rather than two tickets, and reclamation assumes the machine ran hostile code, whatever image it booted.

A machine's life, as the site observes itWhat happensMetering
allocatedThe allocator has named an accepted machine from the site's pool for this lease. A record exists before anything at the site movesNot metered
provisioningPowered on, the image written from the site's own verified copy, the tenant's key placed, the network port moved onto the organization's segmentNot metered
handed overThe image is written, the network attached and the machine reachable, each observed at the site, with the site's timeMetering starts
returnedThe tenant gives it back, or the lease ends. Access is cut first: the port leaves the tenant's segment and the machine powers offMetering stops at the access cut
reclaimingFirmware read out of band against its generation's baseline, every disk sanitized, accelerator memory cleared, acceptance re-run. Every step, every timeNot metered
available · quarantinedBack in the pool only if every step passed. Otherwise quarantined, with the evidence of every step kept and shown—
Bud Ecosystem15
Part II · Service ClassesBud
The Bud GPU Foundry customer console showing a whole-rack lease: a notified firmware window, an image retirement notice, and each machine's out-of-band readings
Figure 3 · Customer console. A 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.

Provisioned in one workflow

The allocator matches an accepted machine against the requested unit; the site powers it on, writes the image, places the tenant's key, attaches its fabric and storage and hands it over. Progress is a pollable operation carrying the phases the site observed, each with its time, and the bill starts at hand-over, not at power-on.

Only a host the platform may sell

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. Acceptance records what was measured and the threshold it was judged against, so revising a threshold re-decides existing records without putting a host back on the bench.

An approved image, or the tenant's own

Boot an image from the platform's approved list (signed, versioned, checksummed, with its publisher recorded) or one of the tenant's own. A tenant image is used only for that tenant's own allocations and is recorded against each one by digest; the platform makes no claim about its contents, says what choosing one gives up, and the catalog states which units accept one.

Root on the tenant's own key

The tenant's registered public key goes in at provisioning, and the platform never holds the private half. The machine is reached through the platform's SSH front door by a readable address (machine, project and organization), forwarded and never terminated, and re-authorized for as long as the connection stays open.

Bud Ecosystem16
Part II · Service ClassesBud

Held against root, returned with evidence

Isolated at the fabric, against root

The machine joins its organization's segment as part of provisioning, and isolation is enforced by the network rather than by the machine's own configuration. It holds against a tenant with root: no route to another tenant's machines, to the provisioning network, to the management network or to any management controller. While the machine is handed over, in-band access to its own management controller is disabled.

Power and break-fix are API operations

Power on, power off, reset, reboot into a rescue path, and query maintenance state, all through the published API, with every action attributable to a principal in the audit trail. Power operations on one machine are serialized, and none runs on a machine holding tenant data while a persistent network-boot override is set on it.

Nothing read from inside

The platform reads a held machine only from outside (power draw, temperatures, fans, power supplies and the event log through its management controller), labelled as such, and shown to the tenant for the window they held it and no earlier. Utilization reads unobservable, never zero, unless the tenant opts in to report it themselves; their report is shown as theirs and is never a charge basis.

Returned with evidence

Reclaim runs every step on every return. Only a machine that passes all of them re-enters the pool; one that fails any step is quarantined, with the failing step and what it read in front of the operator. Firmware the management controller cannot read back is a stated limit, never a pass. Evidence is retained for the period tenant-data deletion requires and issued on request.

Granted and counted as machines

Quota for bare metal is granted in whole machines, CPU-only servers included, and a leased machine is listed and counted beside the tenant's other instances, tagged as a machine. It is billed in host-hours from hand-over to return; provisioning and reclaim are never charged.

Bud Ecosystem17
Part II · Service ClassesBud
Section 05

A rack delivered and partitioned as one, and sold a tray at a time.

Some accelerated systems are not hosts. A rack-scale system is a set of compute trays that share one accelerator interconnect domain, its switch trays, its power shelves and its liquid cooling: delivered, powered, cooled, partitioned and updated together.

The platform enrolls and operates it as the one unit it is, and sells it in the units a tenant can actually 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
DeliveryA rack is enrolled whole (compute trays, switch trays, power shelves and cooling inventoried together) and accepted tray by tray, each tray 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 against whichever tray reported them.
PartitionA tenant's share of the rack's interconnect domain is a partition that excludes every other tenant, made at hand-over and removed at return.
FirmwareTray, switch-tray and power-shelf firmware belong to one baseline for the rack's generation, and a rack's rollout is ordered by who holds each of its trays.
MaintenanceWork on a shared component is scheduled against every tray it affects and every tenant holding one, through notified windows.

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, so the trays it receives can actually talk to each other at the bandwidth it was sold with.

Placement knows the rack

Machines are placed and maintained with the rack's state taken into account. A rack whose cooling, power or interconnect domain is degraded offers nothing that depends on it, and says which of the three it is.

Bud Ecosystem18
Part II · Service ClassesBud
The Bud GPU Foundry digital twin: a three-dimensional hall floor with racks, coolant and power distribution, one rack's trays and one tray's health, power, coolant and firmware readings
Figure 4 · Digital twin. The 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 Bud GPU Foundry provider console site page: sixteen racks by row, each rack's trays, who holds them, and the racks that need attention
Figure 5 · Provider console. The same hall as the site page draws it: sixteen racks by row, who holds each tray, and the racks that need attention.
Bud Ecosystem19
Part II · Service ClassesBud
The Bud GPU Foundry provider console showing one rack: a coolant leak on one tray contained and quarantined, the interconnect domain degraded during a switch-tray update, and the rack's elevation
Figure 6 · Provider console. One 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.

A leak takes machines off sale

Coolant leaks, accelerator errors, interconnect faults, power and thermal faults and management-controller faults are recorded against the tray and rack they concern, each with its recommended action. A leak or a power fault takes every machine it affects off sale until it is resolved.

Every event has a person

Each health event is acknowledged and resolved by a named person, and a hardware return to the vendor is tracked as a case against the tray and part it concerns, so a fault never ends as a closed alert nobody owned.

Read from outside, never from inside

On a tray a tenant holds, the platform reads only what it can read from outside: power and firmware through the management controller, partitions from the switch trays, the segment from the switch it hangs off. The tenant's own pages show those readings, and say where each one came from.

The hall at a glance

Operators see the floor by row and rack, each rack's elevation of trays, switch trays and power shelves, and its interconnect domain with every partition in it. Every site and every machine is presented in one design, rack-scale or not, and a site that lacks a capability says so rather than drawing a zero.

Bud Ecosystem20
Part II · Service ClassesBud
Section 06

A guest with its own kernel, and accelerators attached in hardware.

A virtual machine is the unit for a tenant who needs their own operating system without a whole host: a hardware-virtualized guest running its own kernel, with accelerators passed through at the hardware level. It carries the isolation claim of its grade, no shared kernel with any other tenant, and the same lifecycle, metering and audit discipline as everything else on the fleet.

What a virtual machine declares
imageA platform image carrying a trust tier, or the tenant's own, including a proprietary operating system the platform does not itself distribute.
capacity or unit idThe shape wanted (cards, memory per card, vCPU and memory) resolved to exactly one sellable unit, or a unit named outright. Both paths refuse identically.
boot volumeSize and performance tier, created from the image and surviving a stop.
data volumesNetwork volumes attached at launch or afterwards, detachable and re-attachable to another guest in the region.
networkWhich of the project's networks and subnets to attach to, with an address from the tenant's pool and an optional public address.
keys and user dataThe tenant's registered public keys and a cloud-init document applied at first boot. The platform never holds a private key.
Bud Ecosystem21
Part II · Service ClassesBud

Lifecycle, placement and migration

A lifecycle, not just a launch

Start, stop, reboot, reset, resize to another unit, and delete. A stopped guest keeps its boot volume and its addresses and stops being metered for compute. What survives a stop and what does not is stated at the point of stopping.

Console access that does not need the guest

A serial and graphical console reach the guest through the platform's own gateway, authorized per session by the same authorizer as every other path, so a tenant who has broken their own networking can still get in, and every such session is a record.

Snapshots and images

Point-in-time snapshots of boot and data volumes, restorable in place or into a new guest, and capture of a configured guest into a private image the tenant's own projects can launch from.

Placed by topology, not by count

Placement accounts for the memory and device topology of the host (which accelerators share a link, which belong to the same socket) so a multi-card guest receives cards that can actually talk to each other at the bandwidth its unit names.

Confidential execution where hardware supports it

Where the silicon offers attested execution, it is offered as its own catalog unit with the attestation verifiable by the tenant, priced as a premium tier and scoped honestly against its documented constraints.

Live migration is not promised

Accelerator-attached guests are not live-migrated. The platform states this rather than deferring it, and evacuation is a drain with notice, not a silent move.

The isolation claim a guest carries

A virtual machine carries the claim of the grade it was sold under: no shared kernel with any other tenant, accelerators attached at the hardware level, and the same lifecycle, metering and audit discipline as everything else on the fleet. Metered on allocation-seconds, from healthy to release.

Both paths refuse identically

Whether a tenant asks for a shape and lets the platform resolve it, or names a unit outright, the same catalog rules, the same isolation ceiling and the same tenant-class guards decide the answer. There is no second path that reaches a unit the first would have refused.

Bud Ecosystem22
Part II · Service ClassesBud
Section 07

A cluster of the tenant's own, reached without a standing credential.

A tenant who wants Kubernetes receives a cluster of their own, not a namespace on ours: whole machines handed over to them with root on every node, a version from the published supported set, accelerator support from first boot, and administered by the tenant.

The platform builds it, changes it only when asked, and reclaims every machine like any other. Its own orchestration substrate stays invisible: the credential a tenant holds reaches nothing of it, and the cluster they hold is theirs.

A cluster's phaseDerived from its nodes, never set
buildingAny node is still short of joined. Each node shows its own step (allocated, provisioning, joining, joined) with the site's time.
runningEvery node has joined and the cluster's API has answered through the platform's gateway.
incompleteA node failed and the control plane stands. The cluster names what was and was not built, bills only the nodes that joined, and can be completed or cleaned up.
failedThe control plane never initialized. Every machine is returned through reclaim and nothing is billed.
deleting · deletedEvery node drained, its access cut and its machine reclaimed. The bill shows each node's join and access cut.

Built from whole machines

Choose a region, a supported version, a count of machines from a bare-metal unit, and a control plane on the first machine or highly available on three CPU-only machines. The allocator admits the cluster whole, every machine at one site in one decision or none, so a cluster never starts half-reserved.

Conformant and supported

Upstream Kubernetes passing the conformance suite at every supported minor release, with the supported set published per site. A version leaving the set is announced in advance, after which no new cluster may use it, and a running cluster is never upgraded without its tenant.

Bud Ecosystem23
Part II · Service ClassesBud
The Bud GPU Foundry customer console showing a tenant's Kubernetes cluster on whole machines: every node's state, its interconnect partition and its firmware, all read from outside
Figure 7 · Customer console. A 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.

Accelerators arrive configured, once

Node images carry the accelerator driver for their version, and the cluster network and the accelerator operator are installed once, at creation. After that they are the tenant's: nothing of the platform reconciles inside the cluster, and no agent of the platform runs on its machines.

Changed only when asked

Add machines by count, or remove one by name: it is drained within a published bound, leaves the cluster, has its access cut and goes through reclaim, and no other machine changes. A node the platform judges unhealthy is reported to the tenant, never replaced on the platform's own initiative.

Upgraded by replacement

An upgrade replaces each machine with one freshly reclaimed from the pool, control plane first, and every replaced machine is reclaimed in turn. Local disks are erased on every replaced machine, said before the upgrade starts, with the overlap's cost estimated. A step that stalls waits for the tenant to resume or cancel; nothing rolls back on its own.

Bud Ecosystem24
Part II · Service ClassesBud

Access, network, billing and enforcement

Access is brokered, and time-bounded

The cluster's API is reached through the platform's gateway, which forwards by the name in the connection and never terminates it. The credential is a short-lived certificate over a key the member makes on their own machine, signed at the site once the relation store has decided, and every issue is recorded. Removing the member stops the next issue. What the tenant mints inside their own cluster is theirs, and the platform says so.

A lifecycle credential, kept at the site and declared

Building, scaling, upgrading and deleting a cluster needs a credential to it. The platform keeps one at the site only, readable by no person through the platform, uses it only for operations the tenant asks for, records every lifecycle step on the organization's trail and never uses it to enter a workload. It tells the tenant it exists, and what breaking it would cost them.

Its network is the organization's

The cluster lives in its organization's segment, with one virtual address for its API. Its pod and service ranges are checked against every range at the site before the cluster is admitted, so an overlap is refused rather than discovered as a route that fails. The tenant's storage is offered to it as a storage class.

Billed from each node's join

A cluster is billed as the host-hours of the machines it holds, from each node's join as the site observed it to its access cut. A machine that never joins is never billed, and any per-cluster charge is published beside the machine price before the cluster is created.

No machine without a record

The cluster and every one of its nodes are recorded before any machine is assigned, so no machine is ever provisioned without a row naming its cluster. A cluster whose orderly teardown cannot finish is removed by a named, separately authorized and recorded forced removal, which still reclaims every machine.

The ladder, without breaking the cluster

Under enforcement a hold stops new clusters, added machines and upgrades. Revoking access closes the cluster's API and its nodes' shells at the gateway and leaves the network ports alone, because cutting a cluster's own traffic would destroy it rather than revoke access. Contract tenants are never suspended for balance reasons.

Provider cells from the same pool

The provider builds its own cells (the clusters that sell cards and slices) from the same site pool, declaring each cell's fabric and storage domain. Nobody installs a cell's accelerator stack by hand, a machine joining a cell is shown as the cell's and not sellable, and a tenant's cluster can never be registered as one of the provider's cells.

Bud Ecosystem25
Part II · Service ClassesBud
Section 08

The scheduler an HPC team already knows, delivered as a governed tenancy.

Research and training organizations do not want to rewrite their job scripts. A SLURM unit gives a tenant login nodes, partitions and an accounting database, with their own accelerators behind it, and reconciles what the scheduler recorded against what the platform observed, so chargeback reports and invoices describe the same jobs.

Partitions, QoS and fair share

An organization divides its cluster into named partitions with quality-of-service classes and fair-share weights across its own projects. Capacity is admitted in priority order, and preemption inside an organization follows published rules with notice not shorter than the preempted job's declared checkpoint interval.

Login nodes, reached the same way

Interactive access to a login node runs through the same gateway as every other shell: the tenant's own key material or a short-lived certificate, authorized per session, recorded as a session with a beginning, an end and an actor.

Containers inside jobs

Container execution inside batch jobs is supported natively, so the same image a tenant runs as a workload runs as a job step without a second build.

A shared filesystem that behaves like one

A POSIX filesystem with per-user quotas is mounted across the cluster's nodes, which is what a job array, a checkpoint and a module tree all assume.

Topology-aware job placement

Multi-node jobs are placed with the fabric in mind, so collective operations run across the interconnect the unit was sold with rather than across whatever was free.

Accounting that reconciles

The scheduler's own accounting records are reconciled against the platform's observed allocation windows. Where the two disagree beyond a published threshold, the difference is raised to human review before it reaches a tenant's invoice.

Metered on node-hours

A SLURM tenancy is a per-tenant cluster, metered in node-hours from the platform's observed allocation windows. The scheduler's accounting is the tenant's internal view; the platform's record is what the invoice reads, and the two are reconciled rather than assumed to agree.

Bud Ecosystem26
Part II · Service ClassesBud
Section 09

The smallest declaration that still says everything the platform needs.

A workload is the unit most tenants think in: an image, what to run, what it needs and where it can be reached. It is declared once and launched many times, from a reusable template or inline. The declaration is deliberately small: everything that varies by site, cluster or hardware is resolved by the platform, so a declaration keeps working when the fleet underneath it changes.

What a workload declares
imageThe container image to run, from a public registry or from a private one using a credential the project holds.
command · args · envWhat to execute and the environment to execute it in, overriding the image's own entrypoint where needed.
portsNamed container ports, which become the addresses the platform publishes for the workload.
ephemeralDiskGiBScratch space on the node. The platform states plainly that it does not survive a stop, and names it in the stop preview among the things that would be lost.
volumesNetwork volumes attached at launch, which do survive, and which several workloads in a region can attach at once.
capacity or unit idThe shape wanted, resolved to exactly one sellable unit, or a unit named by the tenant. Both paths refuse identically.
projectIdThe project the workload belongs to, which determines its region, its quota, its network scope and who may reach it.
The service classes, summarized

Five ways to consume, one catalog, one API, one invoice. Whatever form a tenant takes capacity in, the same six verbs apply: discovered, sold, provisioned, observed, metered from healthy, reclaimed with evidence.

Bud Ecosystem27
Part II · Service ClassesBud
The Bud GPU Foundry customer console instances list across an organization's projects: running and billing, waiting with a reason, released, stopped, and failed at the start deadline and never billed
Figure 8 · Customer console. Instances 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.

Creation returns a handle, not a wait

A launch is accepted and returns an operation to poll. Provisioning never blocks the request, and the operation carries the workload's own lifecycle phases by reference, so the progress a caller polls and the phases the workload records are the same data and cannot drift apart.

Replay is safe by construction

Every creation carries an idempotency key. Replaying it inside the published window returns the original result rather than creating a second workload, so a client that times out or runs twice in a pipeline cannot double-spend a tenant's quota or money.

Stop is previewed before it happens

Asking to stop with preview returns exactly what would be lost (ephemeral disk, open sessions), computed the same way the stop itself computes it, and deletes nothing.

Stop, resume, and move

A workload can be stopped and later resumed with its persistent volume intact, and moved between units or regions without its published address changing, so whatever is calling it does not have to be reconfigured.

Interactive or batch, declared

A declaration states whether the container holds itself open for someone to attach to or does a job and exits. That difference decides what a finished workload means, and the console shows it.

A queue is never silence

A request that cannot yet be placed carries a machine-readable reason (no placeable capacity, no quota, or awaiting admission) and its one-based position among the instances waiting in the same project queue, read from the scheduler rather than estimated.

Bud Ecosystem28
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 03

Operational Integrity

State observed from the hardware, quota that cannot be bypassed, isolation the network enforces, and storage whose billed capacity is its enforced capacity.

Part III · Operational IntegrityBud
Section 10

State is observed from the hardware, never assumed from intent.

Three records exist for everything the platform has ever accepted, and they are kept apart on purpose. Intent is what was asked for, written by the API only. Observation is the phase log, written by the lifecycle informer only. Billing is a set of allocation windows derived over that log, never written twice.

1 · Not metered
1
admitted

The quota reservation exists: the scheduler's admission, not the API's acknowledgement

2 · Not metered
2
scheduled

A machine is bound. Whether the image was already resident chooses the start deadline

3 · Not metered
3
image-ready

The image is resident on that machine, read from the machine's own inventory

4 · Not metered
4
device-attached

From the grade's declared attachment source: a bind, a started container, or a hand-over report

5 · Metering starts
5
healthy

The accelerator is attached and what was sold answers. Nothing before this line is ever charged

6 · Metering stops
6
released

The allocation is gone. A release from below healthy is recorded as a failure

7 · Zero-cost record
7
failed

Terminal, never metered, always carrying a reason from one closed vocabulary

Figure 9. The seven observed phases. Four are provisioning and never charged; the meter runs from healthy to released; failed is a zero-cost record that still exists, because an absent record and a zero record are different facts.

The screen a tenant reads and the invoice they are sent come from the same log, so they cannot disagree and arrive as a dispute.

Bud Ecosystem30
Part III · Operational IntegrityBud
The Bud GPU Foundry customer console showing one instance's start-up phase by phase, each with the time the platform observed it, the rule that resolved its unit, and billing starting at healthy
Figure 10 · Customer console. One 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.

Healthy means what the unit sold promises

Each service class declares its own readiness half in the catalog: a container answering, a guest's agent responding, a cluster node joined, a scheduler node online in its partition, a whole machine handed over. A unit with no declared readiness source cannot be published into the catalog at all.

Published start deadlines

One deadline for a start whose image or system disk was already resident, a longer one for a start that had to fetch it, each counted from admission. Missing it terminates the allocation, reports a machine-readable reason and charges nothing, because a timeout that promotes is a timeout that bills.

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.

The log is append-only

Keyed on allocation and phase, so a replay is a no-op rather than a second row, and a new leader resynchronizes from observed state before emitting anything.

Capacity that ran outside the platform is still counted

Accelerator work created outside the platform's own path is reconstructed from its observed timestamps into a zero-cost window: recorded, counted against the fleet, and never billed, so nothing consumes capacity invisibly.

Deterministic event identity

A metering event's identity is a pure function of the allocation and its window bounds, so a replay after a broker failure is idempotent end to end and cannot double-charge. Completeness is verified by an independent nightly recomputation rather than asserted.

Bud Ecosystem31
Part III · Operational IntegrityBud

Why something failed: a closed vocabulary

Every terminal state carries one reason from this set, and the platform refuses to write outside of it, so a downstream system never parses prose to know what happened.

ReasonWhat happened
start deadline exceededIt did not reach healthy within the deadline for its start path. Terminated, and charged nothing
image pull failedThe image could not be retrieved: wrong reference, missing credential, or a registry that did not answer
device never attachedIt was scheduled and the accelerator never attached by the mechanism its grade requires
provisioning failedA machine, guest, cluster or scheduler did not complete provisioning; the underlying system's own words are carried alongside
stoppedEnded because somebody asked it to stop
failedThe workload itself failed, with the cluster's own words carried alongside rather than flattened into the code
released before healthyThe allocation disappeared before it was ever usable: recorded as a failure, because failure means never billed
backfilledReconstructed after the fact from observed timestamps, for capacity that ran without going through the platform's own path. Recorded, counted, never billed
Failed means never billed, always

A release from below healthy is recorded as a failure, and a failure is a zero-cost record. The record still exists, because an absent record and a zero record are different facts, and the difference is what lets an operator see capacity that was consumed without ever earning.

Bud Ecosystem32
Part III · Operational IntegrityBud
Section 11

What an organization is allowed, how it is shared inside, and where the work lands.

Quota is the instrument an operator sells with. A grant is an organization's allowance for one sellable unit in one region, in whole instances of that unit, never in a raw device count. Projects draw on that grant through named shares, and idle headroom is borrowable between them, never across organizations.

Where work lands

1

The region

The project's declared region, and only that region. Residency is a placement record, not a preference.

2

Placeable headroom

Among clusters in that region, only those that could actually place the requested grade and shape right now, not those with a matching free-device count.

3

The most room

Of those, the cluster with the most headroom, so capacity is spread rather than packed into the first cluster that fits.

4

The right silicon

Inside the cluster, placement accounts for memory and device topology, so a multi-card unit receives cards that can talk at the bandwidth it was sold with.

Never

A cluster that is draining, cordoned or being withdrawn, checked again immediately before the work is written.

Re-run

For work still waiting, placement is evaluated again as headroom changes rather than being decided once at submission and left stale.

Bud Ecosystem33
Part III · Operational IntegrityBud

Per organization, per unit, per region

Granting is an operator action on an operator surface. An organization does not grant its own quota and cannot read what other organizations were sold. A grant reaches only the clusters in its region, and can be made at onboarding, before the organization has a project there; it waits for the first one. A region no cluster serves is refused.

Whole instances, never fractions

A grant is divided in whole instances of the unit it names, so an organization can always tell exactly how many machines, guests, clusters or workloads of that shape it may run at once. Whole machines are granted in machines, and a tenant's cluster draws on the same grant as the machines it holds.

Borrowing stays inside the organization

Idle headroom is shared between one organization's own projects in a region. An organization that was granted nothing can never run on another organization's idle grant.

Priority classes and fair share

An organization divides its quota into named shares across projects and declares priority classes within it. Capacity is admitted in priority order, and lower-class work may be preempted by higher-class work of the same organization under published rules, with notice not shorter than the preempted workload's declared checkpoint interval, delivered before preemption begins.

Revocation and expiry move together

Revoking a grant returns its queue to zero. An expiring grant reverts both the scheduler's quota and the metering entitlement, never one without the other, which is the failure that leaves a tenant able to run work nobody is allowed to bill for.

Increases are answered

A tenant asks for more through the API or the console and receives a decision or a waitlist position, with the approver, the sized plan and the budget impact recorded. Silence is not one of the outcomes.

Gang-scheduled work starts all-or-nothing

Multi-node training is placed as one unit or not at all. A partial gang (some workers running, some waiting, all of them billable) is a correctness failure rather than a degraded outcome, because it is the shape that quietly charges a tenant for a job that cannot progress.

Headroom counts what is enforced

For a capped grade, headroom is the device's memory minus what placed slices already claim, counted in the thing the cap is expressed in, not in slots. A node whose sharing runtime cannot be read contributes nothing and says why.

No path around it

Admission policy checks that accelerator work is genuinely routed by the scheduler rather than merely labelled as though it were, and anything that still slips past is counted rather than invisible.

Availability is derived, never counted

What a tenant sees as available is what the scheduler could actually place for a shape, per cluster, with a freshness stamp on every figure. A free-device count is not availability, and an unreachable cluster reports unknown, never its last known number.

Bud Ecosystem34
Part III · Operational IntegrityBud
Section 12

Isolation the network enforces, programmed as the tenant is provisioned.

A tenant's network is not configured after their machines arrive; it is programmed as part of provisioning them, and it is the same scope whichever service class they bought. North-south traffic is separated by per-tenant routing domains, east-west accelerator traffic by fabric partitions, and neither depends on a workload behaving itself, nor on a tenant with root on a whole machine choosing not to break it.

LayerWhat the tenant receivesEnforced by
Routed scopeOne segment per organization, carried across the fleet and across every plane a machine touches, in which their own machines address each other by name and no other tenant is visible.Per-tenant routing and segmentation in the fabric, programmed at onboarding
Accelerator fabricA dedicated high-performance path per multi-node unit, isolated from every other tenant's traffic on the same fabric, and on a rack-scale system a partition of the rack's interconnect domain that excludes every other tenant.Fabric and interconnect partitions administered by the platform, never shared across tenants
Management planesNo route from any tenant machine to the provisioning network, the management network or a management controller, and in-band access to a held machine's own controller disabled.The site's network provider, verified by probing from a tenant-controlled machine
Storage routesRoutes from the organization's segment only to the storage it holds, so a tenant's filesystems and buckets are reachable from its own machines and clusters and from nowhere else.Made, and read back, as the storage is attached
AddressesPrivate and public address pools per tenant, allocated, recorded and reusable. An address can outlive the workload it was attached to.Platform address management, with every allocation audited
Access controlSecurity groups on any attachable resource, with rules by address range, port and protocol, plus outbound translation where a tenant needs it.Generated from the tenant's declared scope, never hand-maintained
Published servicesA stable platform-issued hostname with certificates for an HTTP service, and a stable address for a raw TCP port, with no DNS or certificate work by the tenant.The platform's own edge, in front of the tenant's scope
Bud Ecosystem35
Part III · Operational IntegrityBud

Egress is default-deny toward the platform's own control surfaces and metered per tenant whether or not it is billed, because an operator who cannot see egress cannot price it, and cannot detect abuse of it either.

The Bud GPU Foundry provider console network planes page: what each plane carries, what controls it, how organizations are kept apart on it, and when that was last verified
Figure 11 · Provider console. The 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.

Default-deny toward the platform

Tenant egress cannot reach the platform's own control surfaces. The orchestration substrate is not a network a tenant workload can see, let alone authenticate to.

Ceilings are published and enforced

Per-tenant bandwidth ceilings are enforced, and the published egress pricing states its fair-use envelope rather than leaving it to be discovered.

A private path to the platform

An enterprise tenant can reach the platform over a private network path that does not traverse the public internet, and can restrict access to their own control-plane surfaces to a declared set of source networks, so a stolen token is not usable from anywhere on earth.

Bud Ecosystem36
Part III · Operational IntegrityBud

Shown by trying to break it

Isolation is shown by trying to break it

An isolation check probes from inside a tenant's own segment toward every other tenant, the platform and the management planes. The result is a record of what was tried and what answered, not an assertion that the configuration looks right.

Rules root cannot change

Where a machine carries a network processor of its own, an organization's inbound rules are enforced there, so root on the machine cannot alter them. The platform's own rules (its shell front door, a cluster's API forward) are shown to the organization and locked.

Ranges are checked before they collide

A tenant cluster's pod and service ranges are checked against every segment range at the site, and the platform's own, before the cluster is admitted. An overlap is refused with its reason, not discovered later as a route that fails.

Abuse mitigation comes first

Inbound abuse and volumetric attack mitigation is in place before any tenant-facing address is published, rather than added after the first incident.

A fabric that cannot be read contributes nothing

Where the platform cannot confirm a fabric's state, the capacity behind it reports unknown and is not offered.

Every change is a mutation like any other

Creating a network, allocating an address, opening a rule: each is an API operation, attributable to a principal, recorded in the tenant's own audit trail.

Enforced in the fabric, not in the guest

North-south by per-tenant routing domains, east-west by fabric partitions, management planes unreachable by any tenant machine. None of it depends on a workload behaving itself, and none of it can be undone by a tenant holding root on a whole machine.

Bud Ecosystem37
Part III · Operational IntegrityBud
Section 13

Persistence that outlives the thing that wrote it, on the storage you already own.

Two kinds of storage, and the platform never blurs them. Ephemeral disk is scratch space on the machine: fast, cheap, and gone when the workload stops, stated at the point of declaring it and again in the stop preview. Everything else survives: network volumes, shared filesystems, boot volumes, images and objects. The enforced capacity and the billed capacity are the same number.

Storage typeWhat it is forAttaches to
Network volumeDurable block or file capacity created independently of any workload, surviving termination, with performance tiers whose throughput and IOPS characteristics are published.Containers, guests, cluster nodes, and every machine a tenant holds whole; several at once in a region
Shared filesystemA POSIX filesystem with per-user quotas, mounted across every node of a cluster, which is what job arrays, checkpoints and module trees assume.SLURM and Kubernetes clusters, and any machine in the tenant's scope
Boot volumeThe system disk a guest or a host boots from, created from an image and snapshot-able in place.Virtual machines and bare-metal hosts
Object storageAn S3-compatible surface with scoped credentials the platform issues, so existing tooling works without a bridge.Anything, including from outside the fleet
ImageOperating-system and container images as first-class objects, versioned, checksummed, carrying a trust tier and a publisher.Every service class that boots something
Ephemeral diskScratch space on the machine, declared in GiB, and stated everywhere as not surviving a stop.Containers and guests
Machine-local diskA whole machine's own disks, which are the holder's while they hold it and are sanitized at reclaim. An upgrade that replaces a cluster's machines erases them, and says so before it starts.Bare-metal machines and cluster nodes
Bud Ecosystem38
Part III · Operational IntegrityBud
The Bud GPU Foundry provider console storage page at a site: the systems the platform drives but does not run, what is promised to organizations in quotas, and what those quotas bill
Figure 12 · Provider console. Storage at a site: the systems the platform drives but does not run, what is promised to organizations in quotas, and what those quotas bill.

The storage your fleet already owns

The platform carves your storage systems; it does not run them. Their disks, upgrades and support stay with your storage team. A supported system is attached through a documented integration point and a conformance test, and from then on the platform makes each organization's tenancy on it (the quota, enforced and billed; the key; the route from its segment; the mount) and reads each one back.

Isolated, and reachable only by its tenant

Each tenant receives their own namespace, access zone and object policy in the backing system, reachable only from that tenant's own machines and clusters. Storage is mounted on every machine a tenant holds whole or offered to its cluster as a storage class, and detached before a machine is reclaimed. The platform never holds a credential a tenant could not have issued for themselves.

Quota is the billing primitive

A capacity request is enforced as a hard limit, and the enforced quota is the same number the tenant is billed for. Metering is in capacity-hours from that allocation, reconciled nightly against what is enforced.

Bud Ecosystem39
Part III · Operational IntegrityBud

Data paths, snapshots and keys

Fast paths where the hardware offers them

Where the fabric and the storage support it, data moves to the accelerator over a remote-direct path rather than through the host, declared per unit, like any other performance claim.

Data placed before dispatch

Large datasets and model weights are positioned close to compute before work is dispatched, and work whose data is not yet in place is not admitted to burn accelerator time waiting.

Checkpoint durability

Checkpoint writes are acknowledged only once durably stored, and a workload can make its own progress conditional on that acknowledgement, so a long training run's restart point is real.

Snapshots, restore and replication

Take, list, restore and delete point-in-time snapshots through the API and the console against a published durability and recovery-point objective. Cross-region replication is an explicit, priced capability with its own objective, never an implied property of having a volume.

Browse from the console

List, upload and download volume and bucket contents directly, for the cases where a tenant needs a file in or out without standing up a machine to do it.

Encryption, with the key holder named

Data is encrypted at rest and the platform publishes which key protects it and who holds that key. A tenant with a contractual requirement supplies and controls that key themselves, and revoking it renders the data unrecoverable, which is the point of holding it.

The enforced capacity is the billed capacity

A storage quota is enforced as a hard limit, and that same number is what the tenant is billed for, in capacity-hours from the allocation. The two are reconciled nightly, which is what makes a storage line on an invoice arguable rather than estimated.

Bud Ecosystem40
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 04

Access and Developer Experience

Several ways in and one authorizer, a developer surface where the second launch is a command, and three records that answer three different questions.

Part IV · Access and Developer ExperienceBud
Section 14

Several ways in, one authorizer, and every session a record.

Every path into a tenant's capacity goes through the same authorizer, so there is no second permission model to drift out of step with the first. Nothing is said about a resource before the decision is made: something the caller may not see costs the same, says the same and reads back the same as something that does not exist, on the API and at the gateway alike.

A session is not just a connection: it is a record with a beginning, an end, an actor and, where recording is enabled, a replayable transcript of what it showed.

SSH, on the tenant's own key material

A front door routes on the resource identifier as the username, so a tenant connects to a workload, a guest, a host or a login node rather than to a machine in your fleet. A registered public key is enough; a short-lived certificate whose only valid principal is that resource is the stronger path to the same place. The platform never holds the private half of anything, and the address is derived from the API's own host so a client never has to trust a second configured endpoint. Interactive shells, command execution, file transfer and loopback port forwarding are all supported.

Browser terminal and console

An interactive terminal inside the console, opened with a single-use ticket minted through the API on a click, so a browser session never becomes a long-lived credential. The same path reaches a virtual machine's serial and graphical console, which means a tenant who has broken their own networking can still get in. Authorization is re-checked while the session runs, not only at the door, and refusals are drawn in the page's own chrome with the reason rather than as a blank frame.

Notebooks and editors

A managed notebook or browser editor is launched against a workload or a volume and authorized per session against the same identity the API uses. It is reached at a stable platform-issued address with certificates the platform manages, and it is a session like any other: it appears in the session list, it ends when the relation behind it ends, and it is recorded.

Brokered cluster and scheduler access

A tenant's Kubernetes API is reached at the platform's own host and forwarded by the cluster's name, never terminated: the platform sees only ciphertext, so issuing the credential is the audited act. The credential is a certificate over a key the member makes locally, minted for minutes by the command-line client, or carried inside a downloaded kubeconfig for a lifetime the operator caps, which says on its face that it cannot be revoked before it expires. A scheduler's login node is reached over SSH. Neither path reaches the platform's own substrate.

Bud Ecosystem42
Part IV · Access and Developer ExperienceBud

What a session record holds

Field
kindWhether it was an SSH connection, a browser terminal, a console, a notebook or a brokered API session.
principalWho opened it, as the identity provider issues them.
opened · closedWhen it began, when it ended, and how: closed by the user, by the resource ending, or by revocation.
source addressWhere the connection arrived from, as far as the platform can honestly know it. Where a load balancer does not preserve client addresses, the platform records the path into itself rather than presenting a proxy's address as the tenant's.
recordingWhat the session showed, as replayable events, read one page at a time rather than as one large download.

Revocation reaches live connections

Removing a relation or deleting a key ends sessions already open, on every transport, inside a published bound: a bound on a connection, which is a stronger claim than a bound on a request.

An unauditable session is not opened

If the audit row for a session cannot be written, the session does not begin. Access that cannot be recorded is refused rather than allowed quietly.

Transfers and tunnels are named

A file transfer or a forwarded port is recorded as a marker naming what happened. The bytes are never copied into the recording; an audit trail is not a data exfiltration path. Where a recording could not be kept complete, the gap is a marker rather than a silent join.

Operator staff cannot attach

There is no provider path into a running tenant workload, guest or host. The break-glass path is to cordon and evacuate, and an attempt to do otherwise is refused and audited.

One authorizer, no second model

SSH, the browser terminal, the notebook, the brokered cluster API and the REST API all ask the same relation store the same question at the moment of the request. There is no role stamped on a session at sign-in to drift out of step, and no path that reaches the platform's own orchestration substrate.

Bud Ecosystem43
Part IV · Access and Developer ExperienceBud
Section 15

Everything the console can do, from a terminal, a script or an agent.

Most work is not written from scratch; it starts from something, and it is repeated. The platform treats the starting point as a first-class object with a visible trust level, and treats automation as the primary path rather than an afterthought, because the difference between a platform an engineer adopts on a Friday and one that needs a meeting is whether the second launch is a command.

Templates

A reusable declaration held by a project: image, command, environment, ports, disks, networks and minimum unit. A template is copied into the resource at launch rather than referenced, so editing one never changes anything already running, and a running resource can always be explained by its own record.

Starters and a curated library

A platform-owned set of reference declarations a project copies on first use, for the platform's most common workloads. Each starter says what to run and deliberately carries no capacity: how big the job should be is the tenant's question, not the library's. A starter can declare a memory floor, so a request that could never have loaded is refused at declaration rather than at runtime.

Trust tiers, shown first

Every offered template and image carries a trust tier (official, verified or community) visible before deployment rather than in the small print. Community contributions are scanned and signed before they can be deployed outside the contributing tenant's own scope.

Publish and share

A tenant publishes a template for their own use and, where they choose, for others in the platform's catalog, with authorship recorded and the trust tier applied.

Deploy from a repository

Point a project at a git repository and the platform builds the image, stores it in the project's registry with its provenance recorded, and launches it. A new commit produces a new image and a new launch, not a mutated one.

Private registries

Credentials are stored per project, never readable back through the API, and projected to the cluster that needs them by the platform, with every projection read recorded.

Bud Ecosystem44
Part IV · Access and Developer ExperienceBud

Clients, leases and events

Images distributed to the machine

Images are distributed within a cluster so that a popular image does not pull once per machine from a single registry, which is what turns a burst of launches into a slow start.

Clients, SDKs and agents

A command-line client covering every operation, Python and TypeScript SDKs generated from the same specification, an infrastructure-as-code provider covering every resource type, and a tool server that lets an autonomous agent use the same operations under the same authorization and the same audit trail.

Leases, schedules and idle

Anything a tenant creates can carry a lifetime: a time to live, a schedule that starts and stops it, and an idle threshold that releases it. Expiry uses the same preview as a manual stop, so a tenant sees in advance exactly what a lease will cost them.

Told when capacity frees

A tenant can ask to be notified when a shape they want becomes placeable, and receives the notification when it does, separately from asking for more quota, which is a different question with a different answer.

Cost-center labels

Any billable resource carries labels a tenant chooses, and usage is broken down by them in the console, through the API and on the invoice.

Events, not polling

Signed, retryable, replayable webhooks on lifecycle transitions, so an integration is built against events rather than a polling loop.

The second launch is a command

Every operation the console offers has a command-line command, an SDK call and an infrastructure-as-code resource, generated from one published specification. An engineer who launched something on Friday can script it on Monday without a meeting, and an autonomous agent can do the same under the same authorization and the same audit trail.

Bud Ecosystem45
Part IV · Access and Developer ExperienceBud
Section 16

Three separate records: what ran, what the hardware did, and who changed what.

These are kept apart deliberately, because they answer different questions and have different audiences. Logs are the workload's own output. Telemetry is what the accelerator did, sampled at a published resolution. The audit trail is what people and credentials changed, and it is the one a compliance function reads. All three are scoped by the same authorization as everything else, and all three can be exported continuously to a destination the tenant controls.

Per-resource telemetryWhat it tells a tenantWhen it cannot be observed
UtilizationHow busy the accelerator actually was, at the published sampling resolutionThe metric carries unobservable and the stated reason instead of a value, and no value key at all. A grade that passes a device into a guest the platform does not enter, or hands over a whole machine it does not read inside, is declared blind in advance, so the absence is a disclosure rather than a gap
Memory used · totalHow much device memory was held, and what the device offers, so occupancy is a ratio the tenant can compute
Power drawWatts at the device, for efficiency and for capacity planning
Error countersHardware error events attributable to this tenant's devices
ClockAchieved clock, which is how thermal or power throttling becomes visible
Fabric and storageInterconnect throughput and storage throughput, IOPS and latency for the capacity the tenant holds
Three questions, three records

"What did my job print?" is answered by the log store. "What did the accelerator do?" is answered by telemetry, or by a declared absence where the platform cannot see. "Who changed what, and was anything refused?" is answered by the audit trail. Mixing the three is how a platform ends up with a charge nobody can explain.

Bud Ecosystem46
Part IV · Access and Developer ExperienceBud

Logs, telemetry and the audit trail

Logs outlive what wrote them

Lines are collected into a tenant log store as they are produced and read back from there, never from the container or machine that wrote them. That is the only arrangement in which a crashed workload's last output is still there when somebody goes looking for the cause.

Live or historic, one endpoint

Read from a point in time, take the last n lines, or follow and have lines delivered as they arrive. The published retention period is returned with every read, so a client never has to look it up or assume it.

Scope is fixed server-side

The project a query runs against is taken from the authorized resource, not from anything the client sends, so no client string reaches the query, and no client can widen its own scope.

Joined to the tenant, not to the machine

Telemetry is joined to a tenant's resource by the node and device it actually ran on, so a figure always belongs to one tenant's work rather than to a machine several tenants shared.

Every mutating action, exactly once

The audit trail is written from one place rather than by each handler individually, and the set of operations that must write a row is enumerated from the API specification, so a new capability cannot ship without its audit row.

Denials are recorded too

A refused action is as interesting as a successful one. Denied rows carry the reason, which is the difference between an audit trail and an activity feed.

What a row records

When it happened; which principal acted and whether it was a person, a token or a platform service; the operation, named exactly as the published specification names it; what was acted on and in which scope; the outcome and, for a refusal, why; and the request identifier that correlates the row with the request.

No before-and-after document

Deliberate. A diff that quotes a token or a key puts a live credential into a record kept for the retention period and readable by every administrator of the scope. The row names what changed rather than the value it changed to.

Queryable by the tenant

An organization reads its own trail for its own scope, and a project's trail is visible to anyone who can view the project. The operator's own actions are recorded on the operator's scope, readable by other operator staff and not by tenants.

Read from outside, for the tenant's window

For a whole machine, the tenant sees the out-of-band readings (power draw, temperatures, fans, power-supply health and the event log) for the window they held it and no other, labelled as read from outside the machine. They are never presented as utilization and never used as a charge basis.

Reported by the tenant, if they choose

A tenant can opt in to report telemetry from inside their own machine or cluster, with a credential they can revoke. It is shown as their own report, and no line of their bill moves because of it.

Every step on a tenant's cluster is a row

Each lifecycle step the platform takes on a tenant's cluster (create, add, remove, upgrade, renew, delete, forced removal, a credential issued) is a row on the organization's trail, naming the operation that asked for it.

Bud Ecosystem47
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 05

Tenancy and Commercial Model

Permission as a property of a pair, a fleet one operator runs and several businesses sell, and metering that reconciles to billing an enterprise buyer can sign.

Part V · Tenancy and Commercial ModelBud
Section 17

Permission is a property of a pair, decided per request, and it fails closed.

A user belongs to organizations and projects without maintaining separate accounts, and their permission to act on a specific resource is decided at the moment they ask, from a relation store, not from a role stamped on a session at sign-in. Roles are modelled as relations because a role is a property of a person and a relation is a property of a pair.

There are three scopes, eight relations and one inheritance rule, and the absences in that inheritance are the design: an organization member inherits nothing on a project, which is what makes another department's project invisible rather than merely forbidden.

Platform

The operator's own scope: the fleet, the cluster registry, the sellable unit set and quota. A scope rather than a special case, so "may operate the platform" is answered by the same checker as everything else.

Organization

owner → admin → member, and billing → member. Owner implies admin, admin implies member. Billing sits beside admin rather than under it, so somebody who pays the invoices does not thereby gain the ability to delete work.

Project

admin → developer → viewer. A project names its parent organization as a relation rather than as a column, so inheritance is answered in one lookup and a project can never drift out of its organization.

Project scopeAdminDeveloperViewer
View the project and its members●●●
Read the project's audit trail●●●
View resources, phases, logs, telemetry and sessions●●●
Launch, stop and reach machines, guests, clusters and workloads●●—
Manage templates, images, volumes, networks and registry credentials●●—
Update or delete the project, change its members●——
Bud Ecosystem49
Part V · Tenancy and Commercial ModelBud
The Bud GPU Foundry customer console showing an organization's members and their roles, with one-shot invitations bound to the address they were issued to
Figure 13 · Customer console. An organization's members and their roles. Invitations are one-shot and bound to the address they were issued to.

Two shapes of refusal

No relation to the parent scope returns not found. A forbidden response confirms every lucky guess, so a resource a principal has no route to is indistinguishable from one that does not exist. A relation without the action returns forbidden, and that response names the action and nothing else: not the resource, not its owner, not what relation would have sufficed.

Operator staff hold no standing access

There is no relation anywhere in the model that grants a platform administrator any organization or project capability. Provider access exists only as an explicit, granted, listed and revocable relation on one organization, which appears in that organization's member list and audit trail like any other grant.

Members, roles and delegation

Set a member's role at the organization or on a single project. An administrator can delegate a scoped subset of their own rights without handing over full organization administration.

Bud Ecosystem50
Part V · Tenancy and Commercial ModelBud

Every credential, its rule and its revocation

CredentialRuleRevocation
API tokenScoped to a subset of the issuing user's own permissions, with optional expiry. Shown once, never retrievable afterwardsImmediate, per token
SSH public keyRegistered by the user; the platform never holds the private halfRemoving the key ends the sessions opened with it
SSH certificateOne of the user's registered keys signed briefly for one resource, whose id is the certificate's only valid principalExpiry, plus the same live relation re-check
Terminal ticketSingle-use, one session on one resource, minted on a click, so a browser session never becomes a standing credentialConsumed on use
Cluster credential (tenant's own)A certificate over a key the member makes locally, signed at the site for minutes at a time once the relation store decides. Optionally carried in a downloaded kubeconfig for a lifetime the operator caps, never more than a dayRemoving the relation stops the next issue, so access ends within minutes. A kubeconfig carrying its own certificate is bounded, not revocable, and says so; revoking the organization's access still closes it at the gateway
Lifecycle credential (the platform's, to a tenant cluster)Kept at the site only, used only for operations the tenant requests, readable by no person through the platform, and declared to the tenant at creationThe tenant can rotate their cluster's authority at any time; the platform can then no longer change the cluster except by reclaiming its machines, and says so
Registry credentialStored per project for private images, never readable back through the API, projected to the cluster by the platform with every read auditedDelete revokes, and the projection follows
Platform credentialNever issued to a tenant, in any form or by any path. This is a guarantee, not a default—
Bud Ecosystem51
Part V · Tenancy and Commercial ModelBud

People, access and attribution

Invitations

Invite by email with the role decided at issue, single-use, revocable before acceptance, and landing on a real acceptance page rather than an error.

Verified domains and federation

Claim an email domain and receive the DNS record that proves it, re-checked on demand. Authentication then routes to the organization's own identity provider by verified domain, over SAML or OpenID Connect, with directory provisioning creating, updating and deactivating accounts, and deactivation revoking sessions and issued keys inside a published bound.

Multi-factor, and mandatable

Available to every user, and an organization can require it of all its members rather than hoping they enable it individually.

Always an owner

An organization always has at least one owner: removing or demoting the last one is refused. Recovering an organization none of whose owners can be reached is a provider action, approved by a second principal and recorded on that organization's own trail.

Signed in, but in no organization

A person who authenticates but belongs to no organization is told so plainly, is shown any invitation addressed to them, can reach nothing else, and the sign-in is recorded.

Projects of one's own, if the organization allows

An organization can let its members create projects of their own, within its isolation ceiling and a limit it sets on how many each may hold; a member who creates one administers it. Without that permission, creating a project stays an administrator's action.

Usage is attributed to a person

Every unit of usage is attributed, when it is recorded, to the member who requested the work (or, for work requested with an API token, to the person who issued it) beside its organization, project and cost center. The attribution is fixed at that moment and cannot be altered afterwards by anyone, the platform included. It counts in full against every dimension it carries: attribution, never apportionment.

Members see their own spend

A member sees the usage attributed to them in each organization they work in, their remaining allowance where a member cap applies, and a per-window explanation of each charge, without thereby reading the organization's total, its invoices or any other member's usage. Whoever may read the organization's usage sees it by member, summing to the same total as every other breakdown.

A member's cap belongs to the organization

An administrator can cap an individual member's spend in that organization. The cap belongs to the organization, not to the person: one person's caps in two organizations are independent, and neither organization's administrators can see the other's.

Bud Ecosystem52
Part V · Tenancy and Commercial ModelBud
Section 18

A fleet one operator runs and several businesses sell.

Capacity is rarely sold by only one party. A service provider resells to its own customers; a group function serves subsidiaries that invoice separately; a platform team serves product teams that answer to different budgets. The platform treats that as a first-class arrangement rather than as several deployments: organizations nest, branding follows the seller, and the metered truth is available to whoever does the billing.

Organizations nest

A reseller organization holds sub-organizations it creates, administers and is billed for. It sees their quota, their consumption and their spend, and not the contents of their work: a reseller administrator has no relation to a customer's workloads, sessions or logs, and the audit trail records the boundary holding.

Quota flows down, usage flows up

A reseller is granted quota and divides it among its customers in whole instances, exactly as an organization divides quota among projects. Consumption aggregates back up the same tree, so a reseller's position is the sum of what it sold and never a separate ledger.

White-label

Brand, logo, color, custom domain and language are properties of an organization, applied to the console, the documentation links, the invitation emails and the notifications its users receive. A customer of a reseller sees the reseller.

A usage feed for someone else's billing

Metered usage is available as 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 without reconciling two truths. What they charge is theirs; what was consumed is one number.

Price books per segment

Rate cards are drafted, diffed and published with an effective date, and an organization or a segment can carry its own. A published rate never applies retroactively, and a price below its computed cost floor requires an explicitly recorded decision.

Segments are a property, not a deployment

Tenant class, isolation ceiling, verification tier, price book and brand are all attributes of an organization. One fleet serves an internal platform team, a sovereign customer and a commercial reseller at once, with the differences visible in the record rather than in which installation they were pointed at.

The channel guarantee

A reseller relation reaches quota, consumption and spend. There is no relation from it to a workload, a session or a log line. Bud GPU Foundry will never let a reseller see inside its customers' work, and the audit trail records that boundary holding.

Bud Ecosystem53
Part V · Tenancy and Commercial ModelBud
Section 19

Metering that reconciles, billing that suits an enterprise buyer, and caps that actuate.

The part of billing that cannot be bolted on later is built into the lifecycle itself: an allocation window with a provisioning phase priced at zero exists on the first record ever written. Everything above it (metering, rating, invoices, chargeback, budgets and enforcement) reads that one log. Usage on a screen, the figure on an invoice and the number an enforcement decision is made on are the same number, taken from the same place, which is what makes a disputed charge answerable.

The Bud GPU Foundry customer console billing page: spend so far, the forecast against the organization's cap and how it is worked out, the current burn rate, and where the money went
Figure 14 · Customer console. The 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.
Bud Ecosystem54
Part V · Tenancy and Commercial ModelBud

Metering, rating and budgets

Metering

Windowed events whose identity is a pure function of the allocation and the window's bounds, so a replay is idempotent end to end and a broker failure cannot double-charge. Completeness is verified by an independent nightly recomputation rather than asserted, and no metered quantity is smoothed, clamped, interpolated or discarded as an outlier before it is rated.

Rating and invoices

Usage by project, by cost-center label and by member, a forecast of the current period, and invoices carrying purchase-order references and the agreed cost-center breakdown, in the electronic formats the jurisdiction mandates.

Budgets and caps

Spend caps on an organization, a project, a cost center (covering the centers beneath it) and an individual member. Each is enforced independently and the most restrictive governs, inside a published actuation time bounded by cap × latency rather than by a webhook's timing. The exposure that bound implies is signed off rather than discovered.

The enforcement ladder

RungFor any workFor whole machines and clusters
1 · NotifyThe tenant is told they are approaching the limit, with enough time to act. Nothing changes about what is running or what can be launched.The same
2 · HoldNew work stops being admitted; work already admitted keeps running, because draining a training run to enforce a budget destroys more value than it protects. A cap the tenant set stops here; the rungs below are for money the platform is owed.No new lease or cluster, no added machine; an upgrade in progress pauses at its next step
3 · Revoke accessInteractive access is withdrawn while the work itself continues, so a tenant cannot start new work by hand around the hold.A machine's port moves to an isolation segment. A cluster's API and its nodes' shells close at the gateway and its ports stay, so the cluster's own traffic is not cut
4 · EvictThe last rung, and only for tenant classes where it applies. A contract-billed tenant never reaches it automatically.Powered off and isolated, control plane last, with nothing erased; after a published grace the machines are returned and reclaimed
Bud Ecosystem55
Part V · Tenancy and Commercial ModelBud
The Bud GPU Foundry customer console spend caps page: 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
Figure 15 · Customer console. Spend 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.

Disputes are answerable

A tenant disputes a charge and the platform answers with a per-window explanation of what was billed and why, including the provisioning windows charged at zero, which is usually the question behind the dispute.

Nightly reconciliation

Prepaid balance, contract commitment, scheduler accounting and invoice records reconcile to one another nightly, and any divergence beyond a published threshold is routed to human review before it reaches a tenant.

Cost model and margin

Every unit's price derives from a cost model covering capacity acquisition, power, network, storage and support. Achieved margin is reported per unit at least monthly, and nothing is published below its computed floor without an explicitly recorded decision.

One number, three places

Usage on a screen, the figure on an invoice and the number an enforcement decision is made on are the same number, taken from the same log. A cap that refuses names what has been spent against it and when that figure was computed, and nothing already running is stopped by a cap the tenant set.

Bud Ecosystem56
Part V · Tenancy and Commercial ModelBud

How a tenant is billed

PrepaidContract
How it worksOne balance, carried across periods, drawn down as usage is metered, with balance and forecast visible at all timesBilled in arrears against agreed terms, drawing against a committed spend level over a term
Who gets itThe default for self-serve tenantsGranted after an identity and credit assessment recorded against the account
CommitmentNone; the balance is the limitA committed spend level with the remaining commitment visible at all times, and an agreed discount applied to matching usage
Going beyond itThe enforcement ladder appliesAn agreed overage rate applies. Usage beyond a commitment is a commercial event, not a service interruption
SuspensionAutomatic, by the ladder, when the balance is exhausted. A cap the tenant set holds new work and goes no furtherNever automatic for balance reasons; suspension requires a human decision recorded in the audit trail
PaymentThe methods appropriate to the jurisdiction and account type; a payment received outside the platform is recorded against the account by the provider, with its referenceIncluding bank transfer, which is how enterprises actually pay

Member and cost-center caps refuse at submission

A person and a cost center have no queue to hold, so their caps are checked when work is requested: a request that would start new work past one is refused before any capacity is reserved, naming the cap. Work already admitted is not held, and a member's cap never stops work that is already running.

A balance that does not lapse

A prepaid account holds one balance (every credit recorded against it, less everything spent) which carries across billing periods until it is spent and binds whether or not any cap is set. Payment reaches enforcement within a published time, and a hold caused by an exhausted balance lifts without anyone acting.

A hold covers only the time ahead

Admission reserves the rest of the period's cost of the work it admits, and the reservation shrinks as the period passes and the spend accrues. Spent plus held is one period's cost, so a cap or a balance is never counted twice against the same hours, and the figure a member reads is the figure they are refused against.

Bud Ecosystem57
Part V · Tenancy and Commercial ModelBud

Commitments, availability and change

Commitments and reservations

A prepaid capacity commitment over a fixed term at a discount, auto-applied to matching usage and backed by a reservation ledger that guarantees the capacity exists. A future-dated reservation returns either a confirmed grant or an honest refusal with an alternative date.

Interruptible capacity

Offered at a published discount, with a guaranteed minimum notice before reclamation that is not shorter than the tenant's declared checkpoint interval and is delivered before reclamation begins. It is offered only to work that has declared itself resumable, and the declaration is enforced at submission.

An availability commitment you can claim against

A defined measurement, a service-credit schedule by breach band, a published exclusions list and a claim process, with the credits computed from platform telemetry and offered without the tenant having to detect the breach. Planned maintenance is published in advance, excluded from the commitment, and can be accepted or moved by a tenant within stated limits.

Support tiers

Support is offered in tiers with published response-time targets per severity, and the tier a tenant holds is visible to them rather than being something they discover during an incident.

Change is never retroactive

A tenant-visible change to pricing, terms or published commitments is notified in advance and never applied retroactively.

The commitment never exceeds what has been demonstrated

The availability figure published to customers is bounded by the recovery time the platform has actually demonstrated in a timed restore drill. Where the two conflict, the commitment is lowered rather than the drill relaxed, the only order that keeps a published number meaningful.

Billing an enterprise buyer can sign

Contract billing in arrears against agreed terms, purchase-order references on the invoice, the agreed cost-center breakdown, bank transfer as a payment method, and no automatic suspension for balance reasons. Usage beyond a commitment is a commercial event, not a service interruption.

Bud Ecosystem58
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 06

Trust and Operations

Isolation scoped per unit, a tenant lifecycle specified from signup to exit, one API behind every client, and a fleet kept current without touching anything a tenant holds unannounced.

Part VI · Trust and OperationsBud
Section 20

The isolation is scoped per unit, and the obligations of renting accelerators are built in.

Renting advanced accelerators carries obligations a general-purpose cloud platform does not address: who rented which accelerator class, from where, and under which jurisdiction's rules. Those are platform controls in Bud GPU Foundry rather than a compliance process bolted alongside it. Screening happens at account creation and recurrently, the jurisdiction-and-unit matrix is policy, and the records that evidence it are kept for the period the regulation requires.

Isolation, claimed per unit

No two mutually untrusting tenants share an operating-system kernel on any unit sold to them, and no tenant workload can reach the host's accelerator driver interface on such a unit. The claim is attached to the row being sold, never to the platform in general.

Memory cleared between tenants

Accelerator memory is verifiably cleared before a device is re-offered, per hardware generation. A tenant is never exposed to another tenant's residual device memory.

Isolation on the wire

Tenant separation is enforced by the fabric (routing domains north-south, fabric partitions east-west) rather than by cooperative configuration inside a tenant's own machines.

Admission is a security boundary

The policy bundle is version-controlled, adversarially tested on every change, and refuses when it cannot be evaluated. Work created outside the platform's own API is refused in path, and if any ever slips past, it is counted rather than invisible.

Runtime pinned by provenance

Admission refuses anything whose runtime class was set by anyone but the platform, including when the value set happens to be the correct one, and tenant-supplied annotations that would reach the host are refused across every namespace.

Export-control screening

Every account is screened against sanctions, denied-party and restricted-jurisdiction lists at creation and recurrently, with each result recorded. Access to advanced accelerator classes is governed by a jurisdiction-and-unit matrix maintained as policy, and requests outside it are refused and recorded.

Bud Ecosystem60
Part VI · Trust and OperationsBud

Evidence, keys, personnel and supply chain

Evidence is a product feature

Records sufficient to evidence who rented which accelerator class, from where and for how long are kept for the period applicable regulation requires. The audit trail is queryable by the tenant for their own scope and exportable continuously to a destination they control.

Encryption and key custody

Tenant data and credentials are encrypted in transit on every path that leaves a host, with mutually authenticated endpoints and any exempt path published with its reason. Data is encrypted at rest, and the platform publishes which key protects it and who holds that key.

Tenant-held keys

A tenant with a contractual requirement supplies and controls the key protecting their data, and revoking it renders that data unrecoverable. Where a tenant has contracted for that, the platform never holds the only copy.

Key lifecycle

Every key and credential the platform manages has a recorded owner, a stated lifetime and a published rotation period. Rotation happens without interrupting tenant work and leaves evidence, and the compromise of any one key is containable by revoking that key alone.

No standing personnel access

Operator personnel hold no standing access to a tenant's data, work or scope. Residual access is time-bounded, reason-recorded, approved by a second principal, expires automatically, and is visible in the tenant's own audit trail.

Supply chain

Every platform artifact is signed and its signature verified at deployment. Secrets are never stored in configuration repositories, are scoped per tenant, and their access is audited.

Firmware a tenant cannot leave behind

While a machine is handed to a tenant, in-band access to its management controller is disabled, and any change to its firmware made during the allocation is detected out of band, against its generation's baseline, before the machine is offered to anyone again.

Firmware only from verified packages

Firmware is installed only from packages whose vendor signature, and the vendor's measurement manifest where one is published, verify when they are imported, including packages carried by hand into a site with no internet access. A tampered package is refused at import, not discovered at flash.

Nothing of ours left running on theirs

None of the platform's own work, agents or controllers runs with standing write access on a machine handed to a tenant, and a tenant's cluster is never registered as one of the platform's own. The one credential the platform keeps to a tenant cluster stays at the site and is declared.

Bud Ecosystem61
Part VI · Trust and OperationsBud

Assurance and disclosure

AssuranceWhat is published or held
Independent assessmentCompleted before the first external tenant, repeated at least annually, and repeated again within a published window of any advisory the platform's own severity policy rates as affecting an isolation boundary it sells.
Controls attestationA recognized security-controls attestation, with the observation window started early enough that the report exists before enterprise commitments depend on it.
Accelerated-cloud conformanceThe fleet 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) using the published validation suite.
Sub-processorsA published register of sub-processors and a data-processing agreement.
Identity verification tiersVerification tier determines capability, spend rate and the classes of accelerator an account may reach, and the tier held is recorded against the account.
Abuse handlingDetection covering resource theft, egress abuse and prohibited-content patterns, with a graduated response ladder, an appeal path, and every step logged.
Notice and takedownA published contact, a defined process and a repeat-infringer policy.
Vulnerability disclosureA published security contact accepting third-party reports under a stated disclosure policy, with published acknowledgement and resolution targets, and a severity-to-remediation schedule with an emergency path for isolation-affecting fixes.
Incident notificationAffected tenants are notified of a confirmed incident within a published period, with a defined minimum content set, and a register of such notifications is maintained.
Data residencyEnforced at placement, with the placement record as the evidence of enforcement, not a configuration setting someone asserts was correct at the time.
Bud Ecosystem62
Part VI · Trust and OperationsBud
Section 21

From first signup to final invoice, including the parts most platforms leave unspecified.

Onboarding is usually designed carefully and exit is usually not, which is how a platform ends up holding data it has promised to delete and issuing a final invoice nobody can reconcile. Both halves are specified here. The exit half is also, in practice, what an enterprise procurement review asks about first, because it is the part that determines whether choosing the platform is reversible.

1

Signup

A tenant goes from signing up to running capacity without human intervention, subject to their identity-verification tier. An individual becomes an organization of one, so every money path stays one path.

2

Onboarding

Federated identity, directory provisioning, network scope, storage and contract terms are configured before the first workload rather than retrofitted after it.

3

Operating

Projects, people, quota, budgets, machines and services, all self-served through the same API the operator uses, with an audit trail the tenant can read.

4

Closure

A final reconciled invoice covers usage to the moment of closure, not to the end of a billing period. Every machine and cluster the tenant held goes back through reclaim, and the evidence is kept.

5

Exit

All stored data exported within a published window, unthrottled by the normal egress ceiling, then deleted within a published period and evidenced on request.

Bud Ecosystem63
Part VI · Trust and OperationsBud

Deletion, holds, migration and screening

Deletion includes backups

Tenant data is deleted within a published period after closure, including from backups and from the media of any host that held it, and evidence of deletion is issued on request. A deletion promise that excludes backups is not a deletion promise.

Legal hold

An account under legal hold is exempted from automatic deletion. The hold is recorded and reversible only by an authorized principal.

Unused balance is stated

The disposition of unused prepaid balance or unconsumed commitment on closure is stated in the terms and applied consistently, rather than decided per negotiation at the point of leaving.

Migration without interruption

A tenant can be migrated between organizations, resellers, plans or billing models without interruption to what is running and without their published addresses changing.

Directory deactivation

Deactivating a user in the organization's own directory revokes their platform access, active sessions and issued keys included, within a published time bound.

Screening is continuous

Accounts are screened against sanctions, denied-party and restricted-jurisdiction lists at creation and on a recurring basis thereafter, with each result recorded.

Reversible by design

A final invoice reconciled to the moment of closure, an export window not throttled by the normal egress ceiling, deletion that includes backups and the media of every host that held the data, and evidence on request. Choosing the platform is a decision a tenant can reverse, and the exit is specified as carefully as the entry.

Bud Ecosystem64
Part VI · Trust and OperationsBud
Section 22

One specification, several clients, and no capability that exists in only one of them.

The API is the product; the console, the command-line client and the SDKs are clients of it, generated from the same published specification along with the types your own automation would use. That is enforced rather than intended: every operation has a command-line command, the console may call only published endpoints, and the layer that holds the browser's session is not permitted to contain business logic, because a decision made there would be unreachable from the command line.

API convention
Versioned and publishedOne versioned API with a published machine-readable specification. Clients and documentation are generated from it, and a change that would break an existing client is refused before release.
Stable identifiersEvery resource is addressed by a stable identifier, never by a name, so renaming after a rebrand breaks no saved URL, script or integration.
Idempotent creationEvery create carries an idempotency key, and replaying it within the published window returns the original result rather than a second resource.
Long operations return handlesAnything that takes time returns an operation to poll, and the handle carries the underlying object's own phases by reference.
Cursor paginationLists return an opaque cursor with a bounded page size, so a growing fleet does not change how a client iterates it.
Streaming where it belongsLog reads stream as events over a held connection when following, rather than requiring a client to poll for new lines.
One error shapeEvery refusal carries a machine-readable code and a human-readable message, and where a retry is sensible, how long to wait.
Rate limits with a hintLimits are published and enforced per credential, and a limited response says when to try again rather than leaving a client to guess.
Extensible enumerationsSets that will grow (the reasons a host is not sellable, for instance) are marked extensible, and clients render an unrecognized value as itself rather than defaulting it to something that reads as fine.
Authorized at the queryList operations are scoped by relation in the query rather than fetched broadly and filtered afterwards, so an authorization mistake cannot become a data leak.
Bud Ecosystem65
Part VI · Trust and OperationsBud

What the console covers, and for whom

AreaWhat it holdsAudience
OperateSites, racks, clusters, machines and individual accelerators, with availability, health events, occupancy and the reasons anything is not sellable. Networks, address pools, storage systems, firmware baselines, rollouts and maintenance windows.Operator
SellThe discovered catalog (what was found, what is on sale, what is locked and why), 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, machines and clusters included; the resource lists; queues with a position and a reason.Tenant
WatchDetail for a machine, guest, cluster or workload: the phase breakdown with its metering marker, each cluster node's own steps, live logs, utilization or the readings taken from outside, sessions, maintenance notices, the embedded terminal and console, and the stop preview.Tenant
GovernOrganizations, sub-organizations, projects, people, roles, invitations, domains, member caps, API tokens, SSH keys and the audit trail.Both
SpendUsage by project, cost center and member, invoices, budgets, caps and the balance, with the same numbers the invoice will carry.Both

Speaks the tenant's language

The console says organization and instance where the platform's internals say something else. What a customer reads is named for them, and that naming is held to.

Designed for a fleet

Assets are self-hosted so the console works air-gapped, color is spent only on rows that need attention, and no screen draws a plausible line through a single observation.

The browser never holds a token

The console's session is a cookie held by the platform's own session layer; the browser never receives an API token, and the terminal it opens uses a single-use ticket. A compromised browser tab is not a compromised account.

Bud Ecosystem66
Part VI · Trust and OperationsBud
Section 23

Installed into your fleet, pinned as one set, and upgraded through a canary.

Bud GPU Foundry is delivered as signed images and versioned charts with a declarative deployment tree, so which version runs where, and with what values, is reviewable configuration. The whole component set is pinned and upgraded as one unit through a staging canary before any fleet rollout, with one recorded exception path for isolation-affecting fixes.

One fleet, many sites and clusters

Add capacity by registering another site or cluster at runtime. The API, the console and quota span all of them; placement respects each project's region; withdrawal cordons first and refuses a cluster still holding tenant capacity.

Air-gap supported

Fonts and assets are self-hosted, images are mirrored into your own registry, and no component needs to reach the public internet to serve a tenant.

Version pins carry maturity

Every pin records not just a number but how mature that component is, so upgrade cadence is planned against real risk rather than against release notes.

Restore is drilled

The control plane is restored from backup within a published recovery time and to a published recovery point, verified by timed drill rather than by runbook review. Every stateful service has a named owner, a backup mechanism, a recovery objective and a tested restore.

Incident severity by impact

Severity is defined by tenant impact measured in capacity-hours at risk, and paging is driven by that definition rather than by component alarms.

Error budgets, not tripwires

Every published objective has an owner, an error budget and an alert that fires on budget burn rate rather than on instantaneous breach.

Faults drain, devices quarantine

A faulty accelerator is detected and drained without data loss to running work, and the device is quarantined individually so the scheduler cannot place on it, rather than condemning a whole machine that is otherwise earning.

Firmware, at enrollment and in service

Baseline is verified at enrollment, re-verified at every boot and read back at every reclaim. A host carrying tenant work that drifts, or that an advisory moves, is brought to the new baseline through a staged rollout and returned to the pool as a tracked operation.

Replacement is tracked

Quarantined accelerators are replaced under a tracked process with a recorded owner and elapsed time per replacement, against a spares pool sized from measured failure rates.

Bud Ecosystem67
Part VI · Trust and OperationsBud
The Bud GPU Foundry provider console showing a quarantined tray whose firmware matches no recorded baseline, offered to nobody, with the evidence a person must name to release it
Figure 16 · Provider console. A 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 host leaves the fleet cleanly

Media that has held tenant data is sanitized or destroyed before a host leaves, with evidence retained for the period tenant-data deletion requires.

Capacity triggers

Expansion is triggered by a published demand signal that accounts for hardware acquisition lead time, rather than by the month the fleet ran out.

Dependency register

A register of component dependencies recording maintenance status, license, replacement candidate and estimated cost of replacement, reviewed quarterly.

Pinned, canaried, and never silently upgraded

The whole component set moves together through a staging canary before any fleet rollout. The one exception path, for isolation-affecting fixes that cannot wait, is recorded, and a tenant's cluster is never upgraded without its tenant.

Bud Ecosystem68
Part VI · Trust and OperationsBud

Operating the fleet

Named operator actions on a machine

Power-cycle, re-inspect, run acceptance, reset one accelerator, hold for maintenance, collect a diagnostic bundle, release from quarantine: each is a named, authorized and recorded operation. On a machine a tenant holds, none reads inside it, and none interrupts it outside a window notified to the tenant except to contain a fault, which the tenant is told of.

Quarantine is released by a person

A machine that failed a reclaim step stays withheld until a person releases it with the failing step and its readings in front of them, or it is repaired. Drift is remediated as a tracked operation, never waved through.

Forced removal is a named operation

A tenant resource or a cell whose orderly teardown cannot complete is removed by an operation authorized separately from ordinary deletion and recorded with its reason. Any evidence of deletion the platform issues is derived from what the forced removal actually completed.

Cells built from the pool

The provider builds a cell from a site's pool of machines, declaring its fabric and storage domains, and adds or removes its machines later. A machine assigned to a cell but not yet its node is shown as not sellable, and one leaving a cell is reclaimed before it is offered again.

Occupancy that adds up

Per site and per product, each machine's time since enrollment is divided across available, provisioning, leased, a tenant's cluster node, a cell's node, reclaiming, quarantined and held. The parts add up to the whole, and time the platform did not observe is shown as unobserved, never filled.

A site's loss is bounded

What the loss of a site's management state would cost is stated in advance: what is rebuilt from the center's records, what is not, and what a tenant always holds regardless (root on their own control-plane machines, and a cluster that keeps running). A cluster whose site has gone silent says so, rather than reading as still building.

Tests emit measurements, not verdicts

An acceptance test records what it measured, the threshold it was judged against and the unit, so revising a threshold re-decides existing records without putting a single host back on the bench.

Unknown is a state

A cluster or fabric that cannot be reached reports unknown and contributes nothing, rather than contributing its last known figure. Stale optimism is how a fleet oversells itself.

Commitments are drilled

Every externally visible commitment is validated by a repeatable drill asserting a measured number, and none is published before its drill passes twice consecutively.

Bud Ecosystem69
Part VI · Trust and OperationsBud

Why a host is not sellable

ReasonWhat it means, and who acts on it
Not enrolledA host the platform knows about that has never become usable capacity. Operator action: finish enrollment
Acceptance pendingBurn-in is queued or running and has not yet decided. No action; it will resolve
Acceptance failedBurn-in ran and failed. The record names which test and by how much, so the decision to repair, replace or re-threshold is made against a measurement
Acceptance not recordedThe host never passed acceptance, so it is not the platform's to sell, whatever its hardware suggests
Firmware baseline mismatchAccepted once, then drifted, caught at boot. The host is withheld until it is brought back to baseline
ProvisioningAcceptance passed and the host has not yet become usable capacity
Assigned to a cell, not yet its nodeReserved for a provider cell and still joining it. Shown as the cell's, and never offered as a machine meanwhile
ReclaimingReturned and running reclaim: firmware read-back, sanitize, memory clear, acceptance. It will resolve to available or to quarantined
Quarantined after reclaimA reclaim step failed. The evidence names the step and what it read; a person releases it, or it is repaired
Held for maintenanceAn operator hold, or a notified maintenance window in progress
Rack degradedA leak, power or cooling fault on its rack, or its interconnect domain is unavailable. Every machine the event affects is withheld until it is resolved
Unschedulable or taintedCordoned by an operator, or carrying a taint the platform does not tolerate, usually a deliberate maintenance action
UnhealthyThe host is not ready, or a platform health condition is failing
All devices quarantinedEvery accelerator on the host has faulted. Called out explicitly so that availability reaching zero is never silent
Fabric unavailableThe host's fabric attachment cannot be confirmed, so units that name that fabric are not offered on it
Cluster unreachableThe cluster's own control plane did not answer, so its contribution is unknown rather than assumed to be zero or assumed to be fine
Bud Ecosystem70
Part VI · Trust and OperationsBud
Section 24

Every layer below the tenant kept current, 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. The platform holds one baseline per hardware generation and reads every machine back against it; installs firmware only from verified packages; rolls change out in stages ordered by who holds each machine; and never touches a machine a tenant holds outside a notified window, except to contain a fault, which is also notified.

Wave 1 · Canary

One machine

A single machine nobody holds takes the baseline first, is read back against it and passes acceptance before anything else moves.

Wave 2 · Unheld machines

The pool

Machines nobody holds, in batches of a stated size, each read back and re-accepted before it is offered for sale again.

Wave 3 · A node at a time

Provider cells

The provider's own cells, one machine at a time, drained and returned so the cell keeps selling while it is updated.

Wave 4 · The holder's window

Held machines

Machines and clusters a tenant holds, only inside a maintenance window notified to that tenant: accepted, moved, or simply reached.

Figure 17. A staged rollout. A rollout stops after a stated number of failures and can be paused or stopped by hand; every machine is read back and passes acceptance before it is sold again, and each step on each device names who runs it.
A component, read back against its baselineWhat it means
matchThe component is at the level its generation's current baseline names.
behindAt a level an older baseline names. It is due in the next rollout, and it is 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.
Bud Ecosystem71
Part VI · Trust and OperationsBud
The Bud GPU Foundry provider console showing a 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
Figure 18 · Provider console. A 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.

One baseline per generation

Each hardware generation has one current baseline naming the package for every component it covers. Every machine is read back against it out of band, and its state is kept per component, so a fleet's firmware is a record rather than a spreadsheet.

Packages verified on import

A package is imported from the vendor's mirror, by upload, or carried into an air-gapped site, and its signature (and measurement manifest, where the vendor publishes one) is verified at import. A baseline can name only a package that verified.

One writer per device class

Each class of device has exactly one writer of its firmware. Devices the platform does not update (the fabric's switches, the storage systems, the facility's controllers and the servers the site's own services run on) are read for the record, with when and how each was read and who updates it, and are never written.

Bud Ecosystem72
Part VI · Trust and OperationsBud
The Bud GPU Foundry provider console firmware page: every device class at a site that carries firmware, each one's standing against its baseline, and the classes the platform only reads for the record
Figure 19 · Provider console. Every 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.

Images that state their stack

Every machine image offered to tenants states the accelerator software it carries and each component's version (driver, runtime and communication libraries, monitoring and network-processor software, and for a node image its Kubernetes version) and is signed and published by digest.

An image's life is published

An image moves from candidate to current to deprecated to retired. Tenants running a deprecated image are told its retirement date and its successor; no new lease or cluster can choose a retired one; a provider cell is re-imaged a node at a time.

Advisories shown, never forced

An advisory against an image a tenant's cluster runs is shown on that cluster. Moving to the fixed image is the tenant's upgrade, by replacement, never one applied for them.

Windows a tenant can answer

Planned maintenance appears on the holder's lease or cluster page in advance, excluded from the availability commitment. The tenant can accept the window or move it to a later start within a published limit; an unanswered window goes ahead as published; and a window that interrupts nothing says so.

Bud Ecosystem73
Part VI · Trust and OperationsBud
The Bud GPU Foundry provider console images page: machine images and the software each one carries, its state from candidate to current to deprecated, and its retirement date
Figure 20 · Provider console. Machine images and the software each one carries, with its state from candidate to current to deprecated, and its retirement date.
Faults are contained, and told

Outside a window, the platform acts on a machine a tenant holds only to contain a fault (a leak, a power fault, a failing accelerator) and the tenant is told what was done, when and why.

Nothing a tenant holds is touched unannounced

Held machines are the last wave of every rollout, and only inside a maintenance window notified to their holder. An advisory is shown, never applied for the tenant. A window that interrupts nothing says so, and a window the tenant does not answer goes ahead exactly as published.

Bud Ecosystem74
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 07

Beyond Capacity

Inference, models and token services, delivered by Bud AI Foundry on the same foundation, as a tenant like any other.

Part VII · Beyond CapacityBud
Section 25

Inference, models and token services, delivered by Bud AI Foundry on the same foundation.

Model catalogs, inference endpoints, token metering and agent services are delivered by Bud AI Foundry, which runs on this platform as a tenant like any other. The separation is deliberate: the capacity plane should not know what a token is, and the model plane should not have to re-implement quota, isolation or metering.

Bud AI Foundry is a tenant

It holds an organization, projects, quota and a price book, and it consumes capacity through the same API, the same admission path and the same catalog as any customer. It receives no private interface and no exemption.

Two meters, one truth

Bud GPU Foundry meters capacity (allocation-seconds, node-hours, capacity-hours) from the phase log. Bud AI Foundry meters tokens. Because the capacity underneath an endpoint is recorded separately from the tokens it served, margin per endpoint is a measurement rather than an inference at the end of a quarter.

Sub-tenancy carries through

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 and their isolation is the platform's, not a second implementation of it.

Shared endpoints are declared

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

A shared engine never mixes tenants

A serving engine shared between tenants never serves one tenant, at any cache tier, state computed from another tenant's requests, and never reuses cached state computed under a different model or engine configuration. The cache's scope is set by the platform, never taken from the request, and no response carries a signal derived from another tenant's cached or in-flight state.

For the model plane itself (model onboarding and governance, hardware sizing, the inference gateway, routing, safety and observability) read the companion whitepaper Bud AI Foundry: The Sovereign Control Plane.

Bud Ecosystem76
Bud GPU Foundry · The GPU-as-a-Service Control PlaneBud
Chapter 08

Reference

Every capability, how it works and where you reach it, and the thirty guarantees the platform is held to.

Part VIII · ReferenceBud
Section 26

Every capability, how it works, and where you reach it.

Sixteen groups, covering every capability this document specifies. The surface column names where each one is reached: API, console and CLI are the tenant-facing clients; platform is behavior the system enforces without anyone asking for it; operator is a capability your own staff exercise; public is published outside the platform.

CapabilityHow it worksSurface
A · Catalog and admission
Machine-readable catalogEvery sellable unit bound to one service class, one isolation mechanism, one metering basis and one set of permitted tenant classesAPI · console · CLI
Discovered catalogHardware classes, and the grades each cluster can actually run, discovered from what machines publish; units proposed per class and grade, every one starting not for saleoperator · API
No price, no saleA unit goes on sale only by the provider's decision, and only with a price in force nowoperator · API
Off-catalog refusalAny combination not in the matrix is refused before capacity is reserved: once by the API with a reason the tenant can act on, and again by cluster policy for anything that tries to go around itAPI · policy
Capacity resolutionA shape resolves to one offered unit by a published rule, returning the sentence that chose it, and the nearest units with what each lacks when nothing fitsAPI · console · CLI
Per-organization offeringsWhat a project's organization may actually buy and could launch in its region now, filtered by tenant class and isolation ceiling before anything is displayedAPI · console · CLI
Isolation ceilingThe weakest grade an organization may buy, compared by rank, so every request in every project is measured against one stated policyAPI · platform
Runtime pinningThe runtime class is set by the platform, and anything whose class was written by anyone else is refused, including at the correct valuepolicy
Adversarial policy testingThe policy engine's own evaluator runs the bundle against a locked set of attack cases on every changebuild
Bud Ecosystem78
Part VIII · ReferenceBud
CapabilityHow it worksSurface
B · Bare metal and virtual machines
Bare-metal provisioningThe allocator names an accepted machine; the site powers it on, writes the image, places the tenant's key, attaches fabric and storage and hands it over: one workflow, one pollable operation, the site's own timesAPI · console · CLI
Approved or tenant imagesAn image from the approved list or the tenant's own, a tenant image recorded by digest against each allocation and used only for that tenantAPI · console · CLI
Root through the front doorA whole machine reached on the tenant's own key at a readable address, forwarded by the gateway and never terminatedgateway · CLI
Power and break-fix operationsPower on, off, reset, reboot to rescue, and maintenance state, all as published API operations, serialized per machine and refused while a persistent network-boot override is setAPI · CLI
Verified reclamationAccess cut; firmware read out of band against baseline; every disk sanitized; accelerator memory cleared; acceptance re-run. Any failure quarantines, with every step's evidence keptplatform · operator
Out-of-band readingsPower, temperatures, fans, power supplies and the event log of a held machine, for the tenant's window only, labelled as read from outsideAPI · console
Tenant-reported telemetryOpt-in reporting from inside the tenant's own machine or cluster, shown as theirs and never a charge basisAPI · console
Guest lifecycleStart, stop, reboot, reset, resize and delete, with boot volume and addresses surviving a stopAPI · console · CLI
Tenant-supplied operating systemsA guest running an image the tenant supplies, including its own kernel, out-of-tree modules or a licensed OS the platform does not distributeAPI · console
Console accessSerial and graphical console through the platform's gateway, authorized per session and recordedconsole · API
Snapshots and image capturePoint-in-time snapshots of boot and data volumes, and capture of a configured guest into a private imageAPI · console · CLI
Confidential executionAttested execution where the hardware supports it, verifiable by the tenant and priced as its own unitAPI · platform
C · Kubernetes and SLURM
Bud Ecosystem79
Part VIII · ReferenceBud
CapabilityHow it worksSurface
C · Kubernetes and SLURM (continued)
Tenant clusters on whole machinesA cluster on machines handed to the tenant, admitted whole, at a supported version that passes the conformance suite, with its control plane on one machine or three, administered by the tenantAPI · console · CLI
Add, remove and upgradeAdd by count, remove by name, upgrade by replacing each machine with one freshly reclaimed, and no machine changed that was not asked to changeAPI · console · CLI
Brokered cluster accessThe API forwarded by the gateway and never terminated; a short-lived certificate over a member-made key, signed at the site, ending within minutes of the relation's removalgateway · CLI
Declared lifecycle credentialKept at the site only, used only for operations the tenant requests, every step on the organization's trail, and declared to the tenantplatform
Partial failure as a recordEach node's observed phase; an incomplete cluster names what was built, bills only joined nodes, and can be completed or cleaned upAPI · console · CLI
Billed from each joinHost-hours per node from its join to its access cut; a machine that never joins is never billedplatform
SLURM partitions and QoSNamed partitions, quality-of-service classes and fair share across an organization's projects, with preemption under published rulesAPI · console
Login-node reachInteractive access over the tenant's own key material through the same gateway and the same session record as every other shellgateway · CLI
Accounting reconciliationScheduler accounting reconciled against observed allocation windows, with divergence beyond a published threshold raised to human reviewplatform
D · Workloads and templates
Launch from a templateA reusable declaration copied into the resource at launch, so editing it never changes running workAPI · console · CLI
Starter library and minimumsPlatform-owned reference declarations copied on first use, able to declare a memory floor that refuses an impossible request at declarationAPI · console
Build from a repositoryBuild from git, store in the project's registry with provenance, and launch. A new commit is a new image, never a mutated oneAPI · console · CLI
Bud Ecosystem80
Part VIII · ReferenceBud
CapabilityHow it worksSurface
D · Workloads and templates (continued)
Private registry credentialsStored per project, never readable back through the API, projected to the cluster with every read auditedAPI · console · CLI
Operation handlesCreation returns a pollable handle carrying the resource's own phases by reference, so the two cannot drift apartAPI · CLI
Idempotent creationA replayed create under an explicit key within the published window returns the first result rather than a second resourceAPI · CLI
Destructive-action previewBefore a stop or an expiry, exactly what would be lost, computed the same way the action computes itAPI · console · CLI
Leases and schedulesA time to live, a start and stop schedule, and an idle threshold on anything a tenant createsAPI · console · CLI
Stable published addressAn HTTP service reachable at a platform-issued hostname and a raw TCP port at a stable address, without tenant DNS or certificate workAPI · console
E · Lifecycle and metering correctness
Observed lifecycleState derived from the capacity actually running the work, never from the platform's record of what it intended to createAPI · console · CLI
Phase-by-phase start-upAdmitted, scheduled, image ready, device attached, healthy, with the metering marker on the phase that starts the chargeAPI · console
Metering starts at healthyTime spent provisioning, pulling images or failing to start is never charged, on any unit, under any circumstanceAPI · console
Start deadline terminationAnything that misses its published deadline is terminated, reported with a machine-readable reason, and charged nothingplatform
Closed reason vocabularyFailure reasons come from one enumerated set, so a downstream system never parses prose to know what happenedAPI · CLI
Zero-cost records existEverything that reached admission produces an allocation record, including what failedrevenue
Deterministic event identityA metering event's identity is a pure function of the allocation and its window bounds, so replay cannot double-chargerevenue
Ungoverned capacity backfillAccelerator work created outside the platform's API is counted from its own timestamps into a zero-cost windowplatform
Bud Ecosystem81
Part VIII · ReferenceBud
CapabilityHow it worksSurface
F · Quota, queues and placement
Quota grantsAn organization's allowance for one catalog unit in one region, divided in whole instances (whole machines in machines), reconciled into scheduler quota, and grantable before the organization has a projectAPI · console · CLI
Revocation and expiryRevoking returns the queue to zero; an expiring grant reverts both scheduler quota and the metering entitlement, never one without the otherAPI · console · CLI
Borrowing within an organizationIdle quota is borrowable inside one organization's own cohort in a region, never across organizationsplatform
Fair share and preemptionNamed shares across projects with priority classes, and preemption within an organization with notice delivered before it beginsAPI · console
Placement ruleRegion, then clusters with placeable headroom, then the one with the most, then the right silicon by topology, re-run for queued workplatform
Gang schedulingMulti-node work starts all-or-nothing; a partial gang is treated as a correctness failureplatform
Queue position and reasonA request that cannot yet be placed shows its place in line and a machine-readable reason, rather than pending silentlyAPI · console · CLI
Quota increase requestsA tenant requests an increase and receives a decision or a waitlist position, with approver and budget impact recordedAPI · console · CLI
G · Network and address space
Per-tenant routed scopeA private routing domain per tenant across the fleet, programmed as the tenant is provisioned, identical across service classesplatform · API
Fabric partitioningAccelerator fabric isolated per tenant, so a dedicated high-performance path is never an adapter shared with another tenantplatform
Isolation against rootWhole machines isolated at the fabric from every other tenant and from the provisioning, management and management-controller networks, holding against root, and shown by probing from insideplatform
Address managementPrivate and public pools per tenant, allocated and recorded, with an address able to outlive the resource it was attached toAPI · console · CLI
Bud Ecosystem82
Part VIII · ReferenceBud
CapabilityHow it worksSurface
G · Network and address space (continued)
Security groups and translationRules by address range, port and protocol on any attachable resource, generated from the declared scope and audited like any mutationAPI · console · CLI
Default-deny toward the platformTenant egress cannot reach the platform's own control surfacesplatform
Metered and capped egressEgress measured per tenant regardless of whether it is charged, with published per-tenant ceilings and a stated fair-use envelopeplatform · API
Private and restricted reachA private path to the platform that does not traverse the public internet, and control-plane access restricted to declared source networksplatform
Abuse mitigationInbound abuse and volumetric attack mitigation in place before any tenant-facing address is publishedplatform
H · Storage and data
Network volumesPersistent beyond the resource that used them, attachable across a region, with the enforced quota being the number billedAPI · console · CLI
Shared filesystemPOSIX semantics with per-user quotas across a cluster's nodesAPI · console
Bring your own storageSupported storage systems attached through a documented integration point and a conformance test, then carved per organization (quota, key, route and mount) and never run by the platformoperator
Storage on whole machinesA tenant's storage mounted on every machine it holds or offered to its cluster as a storage class, reachable only from that tenant, detached before reclaimAPI · console
Per-tenant storage isolationNamespace, access zone and object policy per tenant, with scoped credentials the platform never holds a stronger version ofplatform
Object access and browsingAn S3-compatible surface with scoped credentials, browsable, uploadable and downloadable from the consoleAPI · console
Images and boot volumesVersioned, checksummed image objects with a trust tier and a publisher, and boot volumes created from themAPI · console · CLI
Tiers, snapshots and replicationPublished throughput and IOPS per tier, point-in-time snapshots, and cross-region replication as an explicit priced capabilityAPI · console · CLI
Checkpoint durabilityCheckpoint writes acknowledged only when durably stored, so a workload can make its progress conditional on the acknowledgementplatform
Bud Ecosystem83
Part VIII · ReferenceBud
CapabilityHow it worksSurface
H · Storage and data (continued)
Data placed before dispatchDatasets and weights positioned close to compute before work is dispatched, and work whose data is not in place is not admittedplatform
Accelerated data pathRemote-direct transfer from storage to device where the fabric and the storage support it, declared per unitplatform
I · Fleet, clusters and hosts
Derived availabilityWhat the scheduler could actually place for a shape, per cluster, never a free-device countAPI · console · CLI
Per-cluster freshnessEvery aggregate carries how current each cluster's contribution is, so a stale source is visible rather than silently optimisticAPI · console
Cluster registrationAn independent cluster registered and withdrawn at runtime, its credential never readable through the API, every change auditedAPI · console · CLI
Burn-in acceptanceA thermal soak, a device diagnostic and a collective-communication floor, each result recording what was measured against what thresholdAPI · console
Firmware baselineVerified at enrollment against the recorded standard for the hardware generation, and re-verified on every bootplatform
In-service remediationA host already carrying tenant work is drained, brought to a new baseline and returned to the pool as a tracked operationplatform · operator
Fault detection and quarantineA faulty accelerator is detected and drained without data loss to running work, and quarantined individuallyplatform
Spares and replacementReplacement under a tracked process with a recorded owner and elapsed time, against a spares pool sized from measured failure ratesoperator
Sites and their hardware layerEach site runs its own providers, one per capability, with write access to its own machines and nothing centraloperator
Provider cells from the poolA cell built from a site's machines with its fabric and storage domains declared; a joining machine is not sellable, a leaving one is reclaimedoperator · API
OccupancyEach machine's time since enrollment divided across its states and assignments, adding up, with unobserved time shown as suchAPI · console
Named machine actionsPower-cycle, re-inspect, acceptance, accelerator reset, maintenance hold, diagnostic bundle and quarantine release, each authorized and recordedAPI · console · CLI
Bud Ecosystem84
Part VIII · ReferenceBud
CapabilityHow it worksSurface
J · Organizations, projects and people
Multi-organization membershipOne account across many organizations and projects, with no separate logins to maintainAPI · console · CLI
Per-resource authorizationPermission to act on a specific resource decided per request from a relation store, never from an account-level role listAPI · gateway
Two shapes of refusalNot found where there is no relation to the parent scope; forbidden, naming only the action, where there isAPI
Scoped delegationAn administrator grants a subset of their own rights without granting full organization administrationAPI · console · CLI
Invitations and verified domainsSingle-use invitations revocable before acceptance, and a claimed email domain proven by DNS record and re-checked on demandAPI · console · CLI
Federated sign-in and provisioningAuthentication routed to an organization's own provider by verified domain over SAML or OpenID Connect, with directory-driven provisioning and deactivationconsole · platform
Multi-factor authenticationAvailable to every user, and mandatable by an organization for all of its membersconsole
Scoped credentialsRevocable API tokens restricted to a subset of the issuer's permissions, registered SSH keys, short-lived certificates and single-use ticketsAPI · console · CLI
Always an ownerThe last owner cannot be removed or demoted; recovery is a second-approved provider action on the organization's own trailAPI · operator
Usage attributed to a memberFixed at recording to the requester, or to the issuer of the token used, beside organization, project and cost centerplatform
A member's own spendTheir attributed usage, remaining allowance and per-window charges, without the organization's totals or anyone else's usageAPI · console
Personal projectsMembers may create projects of their own where the organization permits it, within its ceiling and a per-member limitAPI · console · CLI
K · Reach, logs and evidence
SSH by tenant keyA registered public key connects to a resource the user may reach; the platform never holds the private halfgateway · CLI
Short-lived certificatesOne of the user's registered keys signed briefly for one resource, with that resource's id as its only valid principalgateway · API · CLI
Bud Ecosystem85
Part VIII · ReferenceBud
CapabilityHow it worksSurface
K · Reach, logs and evidence (continued)
Browser terminal and consoleAn interactive terminal and a machine console in the console, opened with a single-use ticket and re-checked while the session runsgateway · console
Notebooks and editorsA managed notebook or browser editor against a workload or a volume, authorized per session and recorded like any other sessionconsole · API
Live session revocationRemoving a relation or a key ends sessions already open, on every transport, inside a published boundgateway
Session records and recordingsOpened, by whom, from where, closed how, with a replayable transcript, paged rather than served whole, transfers and tunnels named in markersAPI · console · CLI
Live and historic logsStreamed from the tenant log store rather than the machine, so last output survives for the published retentionAPI · console · CLI
Declared blindnessTelemetry the platform cannot observe reports unobservable with a reason, never a zeroAPI · console
Continuous exportLogs, telemetry and the audit trail exported continuously to a destination the tenant controlsAPI
L · Platform surface and developer experience
One versioned APIA published specification from which the server, every client and the console's types are generated, with breaking changes refused at build timeAPI
No console-only capabilityEvery operation has a command-line command, and the console calls only published endpointsAPI · console · CLI
SDKs and infrastructure as codeGenerated Python and TypeScript clients, and a provider covering every resource type, so a fleet can be declared rather than clickedAPI
Agent accessA tool server exposing the published operations to autonomous agents under the same authorization and audit trailAPI
Events and webhooksSigned, retryable, replayable delivery on lifecycle transitions, so integrations are built against events rather than pollingAPI
Capacity notificationsA tenant asks to be told when a shape becomes placeable, and is toldAPI · console
Rate limitsPublished, enforced per credential, returning a machine-readable retry hint rather than an opaque refusalAPI
Bud Ecosystem86
Part VIII · ReferenceBud
CapabilityHow it worksSurface
L · Platform surface and developer experience (continued)
Audit trailEvery mutating action attributable to a principal, written by one path, queryable by the tenant for their own scopeAPI · console · CLI
Independent status pageCurrent and historical health per region and unit family, served from outside the platform it reports onpublic
M · Commercial, contract and channel
Metering completenessWindowed events deduplicated end to end and verified by an independent nightly recomputation rather than assertedplatform
Usage and chargebackUsage by project and cost-center label, a forecast of the current period, and the same numbers the invoice will carryAPI · console · CLI
Prepaid and contract billingOne balance carried across periods and released automatically once restored, or arrears against agreed terms with purchase-order references and the agreed cost-center breakdownAPI · console
Commitments and reservationsA committed spend level auto-applied at the agreed discount, backed by a reservation ledger, with future-dated requests answered honestlyAPI · console
Interruptible capacityA published discount with a guaranteed minimum notice not shorter than the tenant's declared checkpoint intervalAPI · console
Spend caps and the ladderOrganization, project, cost-center and member caps, the most restrictive governing, enforced inside a published actuation time; notify, hold, revoke access, evict, with a hold never draining admitted workAPI · console · platform
Refusal at submissionMember and cost-center caps refuse new work before capacity is reserved, and never stop work that is runningAPI · platform
Holds that shrinkA reservation covers only the period still ahead, so spent plus held is one period's costplatform
Dispute answersA per-window explanation of what was billed and why, including the provisioning windows charged at zeroAPI · console
Nested resellersSub-organizations a reseller administers and is billed for, without visibility into their workAPI · console
White-labelBrand, domain and language per organization, across the console and everything it sendsconsole · operator
Usage feedA continuous, replayable feed of metered usage keyed on the same windows the invoice readsAPI
Bud Ecosystem87
Part VIII · ReferenceBud
CapabilityHow it worksSurface
M · Commercial, contract and channel (continued)
Cost model and marginPrices derived from a cost model covering acquisition, power, network, storage and support, with achieved margin reported per unit monthlyoperator
Availability commitmentA defined measurement, a credit schedule by breach band, an exclusions list and a claim process, with credits offered unpromptedplatform
Support tiers and change noticePublished response targets per severity with the tier visible, and pricing or terms changes notified in advance, never retroactiveconsole · operator
N · Security, compliance and tenant lifecycle
Kernel and driver isolation per unitNo shared kernel between mutually untrusting tenants, and no route to the host's accelerator driver interface, claimed per unitplatform
Memory cleared between tenantsAccelerator memory verifiably cleared per hardware generation before a device is re-offeredplatform
Export-control screening and matrixAccounts screened at creation and recurrently; accelerator classes governed by a jurisdiction-and-unit matrix maintained as policyplatform
Evidence recordsWho rented which accelerator class, from where and for how long, kept for the period regulation requiresAPI · operator
Encryption and key custodyEncrypted in transit on every path leaving a host and at rest, with the protecting key and its holder published, and tenant-supplied keys supportedplatform · API
No standing personnel accessResidual operator access is time-bounded, second-approved, auto-expiring and visible in the tenant's own audit trailplatform
Signed artifacts and secretsEvery artifact signed and verified at deployment; secrets never in configuration repositories, scoped per tenant, access auditedplatform
Firmware tampering detectedIn-band management access disabled while a machine is held, and any firmware change found out of band before it is offered againplatform
No platform agents on tenant machinesNothing of the platform runs with standing write access on a machine handed to a tenant, and a tenant cluster is never registered as a provider cellplatform
Shared-engine cache isolationA serving engine shared between tenants never serves one tenant state computed from another's requests, at any cache tierplatform
Bud Ecosystem88
Part VIII · ReferenceBud
CapabilityHow it worksSurface
N · Security, compliance and tenant lifecycle (continued)
Assurance and disclosureIndependent assessment, a controls attestation, accelerated-cloud conformance, a sub-processor register and a published disclosure policyoperator · public
Self-serve to runningSignup to running capacity without human intervention, subject to identity-verification tierconsole · API
Closure, export and deletionA final reconciled invoice to the moment of closure, an unthrottled export window, deletion including backups, and evidence on requestAPI · console · operator
Legal hold and migrationHold exempts an account from automatic deletion; migration moves a tenant between organizations, resellers or plans without interruptionoperator
O · Operations
Staffed operationsA continuously covered operations function, sized against the availability commitment it supportsoperator
Severity by tenant impactIncident severity defined by capacity-hours at risk, with paging driven by that definition rather than by component alarmsoperator
Error budgetsEvery published objective has an owner, an error budget and an alert that fires on burn rate rather than instantaneous breachoperator
Control-plane restoreRestored within a published recovery time and to a published recovery point, verified by timed drilloperator
Pinned upgradesThe whole component set pinned and upgraded as one unit through a staging canary, with a recorded emergency pathoperator
Bounded blast radiusFailure bounded to a defined domain whose size and composition are documented and testedplatform
Media sanitizationA host leaves the fleet only after media that held tenant data is sanitized or destroyed, with evidence retainedoperator
Commitments are drilledEvery externally visible commitment is validated by a repeatable drill asserting a measured number, and none is published before it passes twiceoperator
Forced removalA resource or cell whose teardown cannot complete is removed by a separately authorized, recorded operation, with deletion evidence derived from what it completedoperator · API
Bud Ecosystem89
Part VIII · ReferenceBud
CapabilityHow it worksSurface
P · Rack-scale systems, firmware and images
The rack as one unitEnrolled whole and accepted tray by tray, with its switch trays, power shelves and cooling inventoried and monitored as parts of the rackoperator · API · console
Interconnect partitionsA tenant's share of a rack's interconnect domain is a partition that excludes every other tenant, made at hand-over and removed at returnplatform
Rack-aware placementMulti-tray units placed inside one interconnect domain; a degraded rack offers nothing that depends on what is degradedplatform
Health eventsLeak, accelerator, interconnect, power, thermal and management-controller events against tray and rack, each with its action and a named person; leaks and power faults take machines off saleAPI · console · operator
Firmware baselinesOne baseline per hardware generation; every component read back as match, behind, drift or unreadableAPI · console · operator
Verified firmware packagesSignature and measurement manifest verified at import, including packages carried into an air-gapped siteoperator · platform
Staged rolloutsOne machine, then the pool, then provider cells a machine at a time, then held machines inside their holder's window; stops after a stated number of failuresoperator · API
Read-only firmware recordSwitches, storage, facility controllers and the site's own servers read for the record (when, how and who updates them) and never writtenoperator
Image stack and lifecycleEvery image states its accelerator software and versions, and moves from candidate to current to deprecated to retired, with tenants told the date and the successorAPI · console · CLI
Maintenance windows a tenant can answerAccept, or move to a later start within a published limit; unanswered goes ahead; a window that interrupts nothing says soAPI · console
Bud Ecosystem90
Part VIII · ReferenceBud
Section 27

Thirty guarantees, each one testable, and together the difference.

These are specified capabilities stated in the negative, not a statement of intent. Each is closed by an automated check that attempts the forbidden behavior and fails if it succeeds. Most of them describe something that happens routinely elsewhere in this market: a charge for a start that never came up, a dashboard showing capacity that cannot be placed, logs that disappear with the container that wrote them. They are written down here so they can be held to.

#Bud GPU Foundry will never…What holds it
01bill for capacity that never became healthyMetering derives from the phase log, and starts at one phase and no other: for a whole machine its hand-over, for a cluster node its join
02display capacity it cannot placeAvailability is derived from placeability per cluster, with a freshness stamp on every figure
03reclaim 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
04discard logs when a workload crashesLines are read from the tenant log store, never from the thing that wrote them
05publish a best-case latency figure as a typical oneEvery published figure is a measured percentile with its measurement method stated
06require a tenant to detect a platform failure in order to be credited for itCredits are computed from platform telemetry and offered without a claim
07charge a stopped resource more than a running one without saying so at the point of stoppingThe stop preview and the metering basis on the unit, both shown before the action
08withhold compliance documentation or security features behind a spend thresholdA published commercial policy, not a matter of sales discretion
09hold the only copy of a key protecting tenant data where the tenant has contracted otherwiseTenant-supplied keys, whose revocation renders the data unrecoverable
Bud Ecosystem91
Part VIII · ReferenceBud
#Bud GPU Foundry will never…What holds it
10suspend a contract-billed tenant automatically for balance reasonsFor that class enforcement is a quota ceiling and a notification; suspension needs a recorded human decision
11present 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
12offer 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
13expose a tenant to another tenant's residual accelerator memoryVerified memory clearing per hardware generation before a device is re-offered
14return 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
15sell 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
16issue 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. A tenant's own cluster is their cluster; ours is never reachable
17require 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
18let 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
19allow 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
20promise live migration of accelerator-attached guestsStated as impossible rather than deferred, so no plan ever quietly assumes it
21market 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
22give operator personnel an interactive session into a running tenant workloadThe break-glass path is cordon and evacuate; the attempt is refused and audited
Bud Ecosystem92
Part VIII · ReferenceBud
#Bud GPU Foundry will never…What holds it
23offer 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
24run 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
25interrupt 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
26install 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
27stop 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
28reveal 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
29smooth, 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
30show 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
Refusals as specified as features

Every line above is closed by an automated check that attempts the forbidden behavior and fails if it succeeds. A guarantee that cannot be tested is a hope, and none of these is a hope.

Bud Ecosystem93
Bud GPU Foundry · In SummaryBud
In summary

A GPU cloud whose refusals are as specified as its features.

A tenant signs in, sees capacity pooled across every site and cluster you have registered, belongs to an organization and a project, and takes it in whatever form their work needs: a whole machine, a tray of a rack, a guest, a cluster of their own, a scheduler or a container.

They watch the start break down phase by phase, open a shell, tail logs that will outlive the work, and give it back, with a record proving exactly what was and was not charged, and evidence that every machine they held was cleaned before anyone else was offered it. You keep the hardware, the data and the control plane, and the platform keeps the guarantees it publishes.

Next steps with Bud Ecosystem

01 · Deployment guide

How Bud GPU Foundry installs into your data centers, site by site, including air-gapped environments.

02 · Full API specification

The published, versioned specification every console, CLI and SDK operation is built on.

03 · Your capacity units

The catalog Bud GPU Foundry would discover and propose from the hardware you already run.

04 · Reference architectures

Proven designs for GPU clouds, enterprise and sovereign platforms, and reseller channels.

Put your data on it

A 30-day proof of concept on your own infrastructure, with your own hardware, against a metric you choose. Request a demo at budecosystem.com/contactus, or read the product page at budecosystem.com/products/bud-gpu-foundry.

Bud Ecosystem94

The capacity is installed. The platform was what was missing. Sell it as governed services.

Bud GPU Foundry turns the accelerators you already own into a governed, multi-tenant cloud inside your own data centers: five service classes from one catalog, isolation scoped to the unit sold, metering that starts at healthy and nowhere earlier, and every machine returned with evidence. Your silicon, your service, your invoice.

Put your data on it.
Bud About Bud Ecosystem, Inc. Bud Ecosystem builds the Bud Novaria AI OS: one native stack from silicon to agents, on the customer's own infrastructure. Bud GPU Foundry is its GPU cloud layer, the GPU-as-a-service control plane for operators who sell accelerated infrastructure as governed services.

Copyright 2026 Bud Ecosystem, Inc. All rights reserved.  ·  budecosystem.com  ·  contact@bud.studio