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



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.
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.
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.
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.
Share one fleet across business units with chargeback by project and cost center, residency enforced at placement, and fully supported air-gapped deployment.
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.

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.
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.
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.
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.
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.
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.
Hardware classes and the units each cluster can run
You choose what goes on sale, at a price in force
Machine, network and storage in one workflow
Seven phases read from the hardware
From healthy to release, and never before
Wiped, verified and re-accepted, with evidence

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.
Model catalogs · inference endpoints · token metering · agent services. Running on Bud GPU Foundry as a tenant like any other.
Catalog · tenancy and access · isolation · placement · observed lifecycle · metering, billing and enforcement · reclaim.
Multi-vendor accelerators · rack-scale systems · fabric and storage you already own · as many sites and clusters as you register.
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.
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.

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

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 class | What the tenant receives | Isolation | Metered on |
|---|---|---|---|
| Bare metal | A 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 fabric | Host-hours, from hand-over to return |
| Virtual machine | A 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 kernel | Allocation-seconds |
| Kubernetes | A 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 plane | Host-hours per node, from its join |
| SLURM | An HPC cluster with login nodes, partitions, quality-of-service classes and fair share, whose accounting reconciles to the platform's own record. | Per-tenant cluster | Node-hours |
| Container | A 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 partition | Allocation-seconds, GPU-seconds or VRAM-GB-hours |

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.
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.
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.
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.
| Enterprise | Service provider | |
|---|---|---|
| Who the tenants are | An operator's own business units, departments or subsidiaries, sharing one fleet | Independent customers who are mutually untrusting, and may be commercial rivals |
| Isolation posture | Every grade is available, including the memory-capped slice, because a hostile neighbor is not the threat model | Only grades whose isolation is enforced in hardware or by the fabric. Shared-kernel grades are withheld by the platform, not by policy guidance |
| Billing | Chargeback by project and cost center, against internal budgets | Prepaid balance by default; contract billing in arrears after an identity and credit assessment |
| Enforcement | Quota ceilings and notifications; the eviction ladder is available but rarely armed | The full ladder for prepaid tenants; contract tenants are never suspended automatically for balance reasons |
| What does not change | The API, the console, the command-line client, the service classes, the lifecycle, the authorization model, the audit trail and the guarantees | |

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.


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.
| Grade | Rank | What the tenant gets | Attachment observed from | Sold to |
|---|---|---|---|---|
| Bare metal host | 0 | The whole machine, with root on its own operating system and kernel and no other tenant resident on it | The site's report of hand-over: image written, network attached, machine reachable | Both classes |
| Whole node | 0 | Every accelerator on a node dedicated to one tenant for the duration | The node's full device set | Both classes |
| Dedicated GPU in a guest | 1 | A whole device passed through to a hardware-virtualized guest running its own kernel | The host-side device bind | Both classes |
| Hardware partition | 2 | A hardware-partitioned fraction of a device with dedicated memory and compute paths | A started container | Both classes |
| Memory-capped slice | 3 | A share of a device with a hard memory ceiling enforced by the sharing runtime | A started container | Enterprise |
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.
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.
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.

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

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 met | What the tenant is told |
|---|---|
| No offered unit fits the shape | The 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 catalog | The combination and the catalog version, and nothing else |
| The unit is not sold to this tenant class | The constraint that refused it, without naming units the tenant may not buy |
| The unit exists and is not on sale | The grade and the written reason. Never a waitlist for something that is not a capacity problem |
| The grade exceeds the organization's ceiling | The ceiling. Alternatives the ceiling refuses are never offered as substitutes |
| The organization's own terms permit nothing | A different failure with a different audience: no edit to the request will help, and the operator must act |
| A spend cap would be passed | Which 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 spent | The balance, what was spent against it and when. Recording a payment releases the hold without anyone acting |
| A cap could not be evaluated | A refusal, never an admission at zero: a limit the platform cannot read lets nothing through |
| No quota right now | A queued request with its position in line and a machine-readable reason. A queue is not an error |

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

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.
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'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 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 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.
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.

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.

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 it | What happens | Metering |
|---|---|---|
| allocated | The allocator has named an accepted machine from the site's pool for this lease. A record exists before anything at the site moves | Not metered |
| provisioning | Powered on, the image written from the site's own verified copy, the tenant's key placed, the network port moved onto the organization's segment | Not metered |
| handed over | The image is written, the network attached and the machine reachable, each observed at the site, with the site's time | Metering starts |
| returned | The tenant gives it back, or the lease ends. Access is cut first: the port leaves the tenant's segment and the machine powers off | Metering stops at the access cut |
| reclaiming | Firmware read out of band against its generation's baseline, every disk sanitized, accelerator memory cleared, acceptance re-run. Every step, every time | Not metered |
| available · quarantined | Back in the pool only if every step passed. Otherwise quarantined, with the evidence of every step kept and shown | — |


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

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

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 of | What that means |
|---|---|
| Delivery | A 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 cooling | Draw, caps and profiles, inlet and return temperatures, coolant flow and leak sensors are recorded against the rack rather than against whichever tray reported them. |
| Partition | A 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. |
| Firmware | Tray, 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. |
| Maintenance | Work on a shared component is scheduled against every tray it affects and every tenant holding one, through notified windows. |
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.
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.





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

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 | |
|---|---|
| image | A 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 id | The 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 volume | Size and performance tier, created from the image and surviving a stop. |
| data volumes | Network volumes attached at launch or afterwards, detachable and re-attachable to another guest in the region. |
| network | Which 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 data | The tenant's registered public keys and a cloud-init document applied at first boot. The platform never holds a private key. |

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

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 phase | Derived from its nodes, never set |
|---|---|
| building | Any node is still short of joined. Each node shows its own step (allocated, provisioning, joining, joined) with the site's time. |
| running | Every node has joined and the cluster's API has answered through the platform's gateway. |
| incomplete | A 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. |
| failed | The control plane never initialized. Every machine is returned through reclaim and nothing is billed. |
| deleting · deleted | Every node drained, its access cut and its machine reclaimed. The bill shows each node's join and access cut. |
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.
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.


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

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

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

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 | |
|---|---|
| image | The container image to run, from a public registry or from a private one using a credential the project holds. |
| command · args · env | What to execute and the environment to execute it in, overriding the image's own entrypoint where needed. |
| ports | Named container ports, which become the addresses the platform publishes for the workload. |
| ephemeralDiskGiB | Scratch 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. |
| volumes | Network volumes attached at launch, which do survive, and which several workloads in a region can attach at once. |
| capacity or unit id | The shape wanted, resolved to exactly one sellable unit, or a unit named by the tenant. Both paths refuse identically. |
| projectId | The project the workload belongs to, which determines its region, its quota, its network scope and who may reach it. |
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.


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

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

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.
The quota reservation exists: the scheduler's admission, not the API's acknowledgement
A machine is bound. Whether the image was already resident chooses the start deadline
The image is resident on that machine, read from the machine's own inventory
From the grade's declared attachment source: a bind, a started container, or a hand-over report
The accelerator is attached and what was sold answers. Nothing before this line is ever charged
The allocation is gone. A release from below healthy is recorded as a failure
Terminal, never metered, always carrying a reason from one closed vocabulary
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.


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

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.
| Reason | What happened |
|---|---|
| start deadline exceeded | It did not reach healthy within the deadline for its start path. Terminated, and charged nothing |
| image pull failed | The image could not be retrieved: wrong reference, missing credential, or a registry that did not answer |
| device never attached | It was scheduled and the accelerator never attached by the mechanism its grade requires |
| provisioning failed | A machine, guest, cluster or scheduler did not complete provisioning; the underlying system's own words are carried alongside |
| stopped | Ended because somebody asked it to stop |
| failed | The workload itself failed, with the cluster's own words carried alongside rather than flattened into the code |
| released before healthy | The allocation disappeared before it was ever usable: recorded as a failure, because failure means never billed |
| backfilled | Reconstructed after the fact from observed timestamps, for capacity that ran without going through the platform's own path. Recorded, counted, never billed |
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.

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.
The project's declared region, and only that region. Residency is a placement record, not a preference.
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.
Of those, the cluster with the most headroom, so capacity is spread rather than packed into the first cluster that fits.
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.
A cluster that is draining, cordoned or being withdrawn, checked again immediately before the work is written.
For work still waiting, placement is evaluated again as headroom changes rather than being decided once at submission and left stale.

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

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.
| Layer | What the tenant receives | Enforced by |
|---|---|---|
| Routed scope | One 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 fabric | A 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 planes | No 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 routes | Routes 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 |
| Addresses | Private 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 control | Security 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 services | A 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 |

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.

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.
Per-tenant bandwidth ceilings are enforced, and the published egress pricing states its fair-use envelope rather than leaving it to be discovered.
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.

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.
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.
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.
Inbound abuse and volumetric attack mitigation is in place before any tenant-facing address is published, rather than added after the first incident.
Where the platform cannot confirm a fabric's state, the capacity behind it reports unknown and is not offered.
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.
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.

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 type | What it is for | Attaches to |
|---|---|---|
| Network volume | Durable 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 filesystem | A 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 volume | The 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 storage | An S3-compatible surface with scoped credentials the platform issues, so existing tooling works without a bridge. | Anything, including from outside the fleet |
| Image | Operating-system and container images as first-class objects, versioned, checksummed, carrying a trust tier and a publisher. | Every service class that boots something |
| Ephemeral disk | Scratch space on the machine, declared in GiB, and stated everywhere as not surviving a stop. | Containers and guests |
| Machine-local disk | A 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 |


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

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

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

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

| Field | |
|---|---|
| kind | Whether it was an SSH connection, a browser terminal, a console, a notebook or a brokered API session. |
| principal | Who opened it, as the identity provider issues them. |
| opened · closed | When it began, when it ended, and how: closed by the user, by the resource ending, or by revocation. |
| source address | Where 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. |
| recording | What the session showed, as replayable events, read one page at a time rather than as one large download. |
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.
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.
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.
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.
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.

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

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.
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.
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.
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.
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.
Signed, retryable, replayable webhooks on lifecycle transitions, so an integration is built against events rather than a polling loop.
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.

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 telemetry | What it tells a tenant | When it cannot be observed |
|---|---|---|
| Utilization | How busy the accelerator actually was, at the published sampling resolution | The 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 · total | How much device memory was held, and what the device offers, so occupancy is a ratio the tenant can compute | |
| Power draw | Watts at the device, for efficiency and for capacity planning | |
| Error counters | Hardware error events attributable to this tenant's devices | |
| Clock | Achieved clock, which is how thermal or power throttling becomes visible | |
| Fabric and storage | Interconnect throughput and storage throughput, IOPS and latency for the capacity the tenant holds |
"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.

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

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.

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.
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.
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.
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 scope | Admin | Developer | Viewer |
|---|---|---|---|
| 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 | ● | — | — |


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

| Credential | Rule | Revocation |
|---|---|---|
| API token | Scoped to a subset of the issuing user's own permissions, with optional expiry. Shown once, never retrievable afterwards | Immediate, per token |
| SSH public key | Registered by the user; the platform never holds the private half | Removing the key ends the sessions opened with it |
| SSH certificate | One of the user's registered keys signed briefly for one resource, whose id is the certificate's only valid principal | Expiry, plus the same live relation re-check |
| Terminal ticket | Single-use, one session on one resource, minted on a click, so a browser session never becomes a standing credential | Consumed 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 day | Removing 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 creation | The 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 credential | Stored per project for private images, never readable back through the API, projected to the cluster by the platform with every read audited | Delete revokes, and the projection follows |
| Platform credential | Never issued to a tenant, in any form or by any path. This is a guarantee, not a default | — |

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.
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.
Available to every user, and an organization can require it of all its members rather than hoping they enable it individually.
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.
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.
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.
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.
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.
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.

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

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.


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.
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.
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.
| Rung | For any work | For whole machines and clusters |
|---|---|---|
| 1 · Notify | The 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 · Hold | New 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 access | Interactive 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 · Evict | The 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 |


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

| Prepaid | Contract | |
|---|---|---|
| How it works | One balance, carried across periods, drawn down as usage is metered, with balance and forecast visible at all times | Billed in arrears against agreed terms, drawing against a committed spend level over a term |
| Who gets it | The default for self-serve tenants | Granted after an identity and credit assessment recorded against the account |
| Commitment | None; the balance is the limit | A committed spend level with the remaining commitment visible at all times, and an agreed discount applied to matching usage |
| Going beyond it | The enforcement ladder applies | An agreed overage rate applies. Usage beyond a commitment is a commercial event, not a service interruption |
| Suspension | Automatic, by the ladder, when the balance is exhausted. A cap the tenant set holds new work and goes no further | Never automatic for balance reasons; suspension requires a human decision recorded in the audit trail |
| Payment | The methods appropriate to the jurisdiction and account type; a payment received outside the platform is recorded against the account by the provider, with its reference | Including bank transfer, which is how enterprises actually pay |
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 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.
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.

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.
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.
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 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.
A tenant-visible change to pricing, terms or published commitments is notified in advance and never applied retroactively.
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.
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.

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.

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

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

| Assurance | What is published or held |
|---|---|
| Independent assessment | Completed 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 attestation | A recognized security-controls attestation, with the observation window started early enough that the report exists before enterprise commitments depend on it. |
| Accelerated-cloud conformance | The 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-processors | A published register of sub-processors and a data-processing agreement. |
| Identity verification tiers | Verification tier determines capability, spend rate and the classes of accelerator an account may reach, and the tier held is recorded against the account. |
| Abuse handling | Detection covering resource theft, egress abuse and prohibited-content patterns, with a graduated response ladder, an appeal path, and every step logged. |
| Notice and takedown | A published contact, a defined process and a repeat-infringer policy. |
| Vulnerability disclosure | A 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 notification | Affected 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 residency | Enforced at placement, with the placement record as the evidence of enforcement, not a configuration setting someone asserts was correct at the time. |

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.
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.
Federated identity, directory provisioning, network scope, storage and contract terms are configured before the first workload rather than retrofitted after it.
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.
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.
All stored data exported within a published window, unthrottled by the normal egress ceiling, then deleted within a published period and evidenced on request.

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.
An account under legal hold is exempted from automatic deletion. The hold is recorded and reversible only by an authorized principal.
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.
A tenant can be migrated between organizations, resellers, plans or billing models without interruption to what is running and without their published addresses changing.
Deactivating a user in the organization's own directory revokes their platform access, active sessions and issued keys included, within a published time bound.
Accounts are screened against sanctions, denied-party and restricted-jurisdiction lists at creation and on a recurring basis thereafter, with each result recorded.
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.

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 published | One 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 identifiers | Every resource is addressed by a stable identifier, never by a name, so renaming after a rebrand breaks no saved URL, script or integration. |
| Idempotent creation | Every create carries an idempotency key, and replaying it within the published window returns the original result rather than a second resource. |
| Long operations return handles | Anything that takes time returns an operation to poll, and the handle carries the underlying object's own phases by reference. |
| Cursor pagination | Lists return an opaque cursor with a bounded page size, so a growing fleet does not change how a client iterates it. |
| Streaming where it belongs | Log reads stream as events over a held connection when following, rather than requiring a client to poll for new lines. |
| One error shape | Every 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 hint | Limits are published and enforced per credential, and a limited response says when to try again rather than leaving a client to guess. |
| Extensible enumerations | Sets 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 query | List operations are scoped by relation in the query rather than fetched broadly and filtered afterwards, so an authorization mistake cannot become a data leak. |

| Area | What it holds | Audience |
|---|---|---|
| Operate | Sites, 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 |
| Sell | The 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 |
| Build | Templates, 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 |
| Watch | Detail 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 |
| Govern | Organizations, sub-organizations, projects, people, roles, invitations, domains, member caps, API tokens, SSH keys and the audit trail. | Both |
| Spend | Usage by project, cost center and member, invoices, budgets, caps and the balance, with the same numbers the invoice will carry. | Both |
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.
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 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 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.
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.
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.
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.
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.
Severity is defined by tenant impact measured in capacity-hours at risk, and paging is driven by that definition rather than by component alarms.
Every published objective has an owner, an error budget and an alert that fires on budget burn rate rather than on instantaneous breach.
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.
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.
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.


Media that has held tenant data is sanitized or destroyed before a host leaves, with evidence retained for the period tenant-data deletion requires.
Expansion is triggered by a published demand signal that accounts for hardware acquisition lead time, rather than by the month the fleet ran out.
A register of component dependencies recording maintenance status, license, replacement candidate and estimated cost of replacement, reviewed quarterly.
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.

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.
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.
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.
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.
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.
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.
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.
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.
Every externally visible commitment is validated by a repeatable drill asserting a measured number, and none is published before its drill passes twice consecutively.

| Reason | What it means, and who acts on it |
|---|---|
| Not enrolled | A host the platform knows about that has never become usable capacity. Operator action: finish enrollment |
| Acceptance pending | Burn-in is queued or running and has not yet decided. No action; it will resolve |
| Acceptance failed | Burn-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 recorded | The host never passed acceptance, so it is not the platform's to sell, whatever its hardware suggests |
| Firmware baseline mismatch | Accepted once, then drifted, caught at boot. The host is withheld until it is brought back to baseline |
| Provisioning | Acceptance passed and the host has not yet become usable capacity |
| Assigned to a cell, not yet its node | Reserved for a provider cell and still joining it. Shown as the cell's, and never offered as a machine meanwhile |
| Reclaiming | Returned and running reclaim: firmware read-back, sanitize, memory clear, acceptance. It will resolve to available or to quarantined |
| Quarantined after reclaim | A reclaim step failed. The evidence names the step and what it read; a person releases it, or it is repaired |
| Held for maintenance | An operator hold, or a notified maintenance window in progress |
| Rack degraded | A 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 tainted | Cordoned by an operator, or carrying a taint the platform does not tolerate, usually a deliberate maintenance action |
| Unhealthy | The host is not ready, or a platform health condition is failing |
| All devices quarantined | Every accelerator on the host has faulted. Called out explicitly so that availability reaching zero is never silent |
| Fabric unavailable | The host's fabric attachment cannot be confirmed, so units that name that fabric are not offered on it |
| Cluster unreachable | The cluster's own control plane did not answer, so its contribution is unknown rather than assumed to be zero or assumed to be fine |

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.
A single machine nobody holds takes the baseline first, is read back against it and passes acceptance before anything else moves.
Machines nobody holds, in batches of a stated size, each read back and re-accepted before it is offered for sale again.
The provider's own cells, one machine at a time, drained and returned so the cell keeps selling while it is updated.
Machines and clusters a tenant holds, only inside a maintenance window notified to that tenant: accepted, moved, or simply reached.
| A component, read back against its baseline | What it means |
|---|---|
| match | The component is at the level its generation's current baseline names. |
| behind | At a level an older baseline names. It is due in the next rollout, and it is never shown in the same color as drift. |
| drift | At a level no baseline names. The machine is quarantined until it is brought back and re-accepted. |
| unreadable | The management controller cannot read the component back. A stated limit, and never a pass. |


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


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


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

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

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

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

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.
| Capability | How it works | Surface |
|---|---|---|
| A · Catalog and admission | ||
| Machine-readable catalog | Every sellable unit bound to one service class, one isolation mechanism, one metering basis and one set of permitted tenant classes | API · console · CLI |
| Discovered catalog | Hardware 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 sale | operator · API |
| No price, no sale | A unit goes on sale only by the provider's decision, and only with a price in force now | operator · API |
| Off-catalog refusal | Any 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 it | API · policy |
| Capacity resolution | A 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 fits | API · console · CLI |
| Per-organization offerings | What a project's organization may actually buy and could launch in its region now, filtered by tenant class and isolation ceiling before anything is displayed | API · console · CLI |
| Isolation ceiling | The weakest grade an organization may buy, compared by rank, so every request in every project is measured against one stated policy | API · platform |
| Runtime pinning | The runtime class is set by the platform, and anything whose class was written by anyone else is refused, including at the correct value | policy |
| Adversarial policy testing | The policy engine's own evaluator runs the bundle against a locked set of attack cases on every change | build |

| Capability | How it works | Surface |
|---|---|---|
| B · Bare metal and virtual machines | ||
| Bare-metal provisioning | The 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 times | API · console · CLI |
| Approved or tenant images | An image from the approved list or the tenant's own, a tenant image recorded by digest against each allocation and used only for that tenant | API · console · CLI |
| Root through the front door | A whole machine reached on the tenant's own key at a readable address, forwarded by the gateway and never terminated | gateway · CLI |
| Power and break-fix operations | Power 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 set | API · CLI |
| Verified reclamation | Access 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 kept | platform · operator |
| Out-of-band readings | Power, temperatures, fans, power supplies and the event log of a held machine, for the tenant's window only, labelled as read from outside | API · console |
| Tenant-reported telemetry | Opt-in reporting from inside the tenant's own machine or cluster, shown as theirs and never a charge basis | API · console |
| Guest lifecycle | Start, stop, reboot, reset, resize and delete, with boot volume and addresses surviving a stop | API · console · CLI |
| Tenant-supplied operating systems | A guest running an image the tenant supplies, including its own kernel, out-of-tree modules or a licensed OS the platform does not distribute | API · console |
| Console access | Serial and graphical console through the platform's gateway, authorized per session and recorded | console · API |
| Snapshots and image capture | Point-in-time snapshots of boot and data volumes, and capture of a configured guest into a private image | API · console · CLI |
| Confidential execution | Attested execution where the hardware supports it, verifiable by the tenant and priced as its own unit | API · platform |
| C · Kubernetes and SLURM | ||

| Capability | How it works | Surface |
|---|---|---|
| C · Kubernetes and SLURM (continued) | ||
| Tenant clusters on whole machines | A 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 tenant | API · console · CLI |
| Add, remove and upgrade | Add by count, remove by name, upgrade by replacing each machine with one freshly reclaimed, and no machine changed that was not asked to change | API · console · CLI |
| Brokered cluster access | The 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 removal | gateway · CLI |
| Declared lifecycle credential | Kept at the site only, used only for operations the tenant requests, every step on the organization's trail, and declared to the tenant | platform |
| Partial failure as a record | Each node's observed phase; an incomplete cluster names what was built, bills only joined nodes, and can be completed or cleaned up | API · console · CLI |
| Billed from each join | Host-hours per node from its join to its access cut; a machine that never joins is never billed | platform |
| SLURM partitions and QoS | Named partitions, quality-of-service classes and fair share across an organization's projects, with preemption under published rules | API · console |
| Login-node reach | Interactive access over the tenant's own key material through the same gateway and the same session record as every other shell | gateway · CLI |
| Accounting reconciliation | Scheduler accounting reconciled against observed allocation windows, with divergence beyond a published threshold raised to human review | platform |
| D · Workloads and templates | ||
| Launch from a template | A reusable declaration copied into the resource at launch, so editing it never changes running work | API · console · CLI |
| Starter library and minimums | Platform-owned reference declarations copied on first use, able to declare a memory floor that refuses an impossible request at declaration | API · console |
| Build from a repository | Build from git, store in the project's registry with provenance, and launch. A new commit is a new image, never a mutated one | API · console · CLI |

| Capability | How it works | Surface |
|---|---|---|
| D · Workloads and templates (continued) | ||
| Private registry credentials | Stored per project, never readable back through the API, projected to the cluster with every read audited | API · console · CLI |
| Operation handles | Creation returns a pollable handle carrying the resource's own phases by reference, so the two cannot drift apart | API · CLI |
| Idempotent creation | A replayed create under an explicit key within the published window returns the first result rather than a second resource | API · CLI |
| Destructive-action preview | Before a stop or an expiry, exactly what would be lost, computed the same way the action computes it | API · console · CLI |
| Leases and schedules | A time to live, a start and stop schedule, and an idle threshold on anything a tenant creates | API · console · CLI |
| Stable published address | An HTTP service reachable at a platform-issued hostname and a raw TCP port at a stable address, without tenant DNS or certificate work | API · console |
| E · Lifecycle and metering correctness | ||
| Observed lifecycle | State derived from the capacity actually running the work, never from the platform's record of what it intended to create | API · console · CLI |
| Phase-by-phase start-up | Admitted, scheduled, image ready, device attached, healthy, with the metering marker on the phase that starts the charge | API · console |
| Metering starts at healthy | Time spent provisioning, pulling images or failing to start is never charged, on any unit, under any circumstance | API · console |
| Start deadline termination | Anything that misses its published deadline is terminated, reported with a machine-readable reason, and charged nothing | platform |
| Closed reason vocabulary | Failure reasons come from one enumerated set, so a downstream system never parses prose to know what happened | API · CLI |
| Zero-cost records exist | Everything that reached admission produces an allocation record, including what failed | revenue |
| Deterministic event identity | A metering event's identity is a pure function of the allocation and its window bounds, so replay cannot double-charge | revenue |
| Ungoverned capacity backfill | Accelerator work created outside the platform's API is counted from its own timestamps into a zero-cost window | platform |

| Capability | How it works | Surface |
|---|---|---|
| F · Quota, queues and placement | ||
| Quota grants | An 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 project | API · console · CLI |
| Revocation and expiry | Revoking returns the queue to zero; an expiring grant reverts both scheduler quota and the metering entitlement, never one without the other | API · console · CLI |
| Borrowing within an organization | Idle quota is borrowable inside one organization's own cohort in a region, never across organizations | platform |
| Fair share and preemption | Named shares across projects with priority classes, and preemption within an organization with notice delivered before it begins | API · console |
| Placement rule | Region, then clusters with placeable headroom, then the one with the most, then the right silicon by topology, re-run for queued work | platform |
| Gang scheduling | Multi-node work starts all-or-nothing; a partial gang is treated as a correctness failure | platform |
| Queue position and reason | A request that cannot yet be placed shows its place in line and a machine-readable reason, rather than pending silently | API · console · CLI |
| Quota increase requests | A tenant requests an increase and receives a decision or a waitlist position, with approver and budget impact recorded | API · console · CLI |
| G · Network and address space | ||
| Per-tenant routed scope | A private routing domain per tenant across the fleet, programmed as the tenant is provisioned, identical across service classes | platform · API |
| Fabric partitioning | Accelerator fabric isolated per tenant, so a dedicated high-performance path is never an adapter shared with another tenant | platform |
| Isolation against root | Whole 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 inside | platform |
| Address management | Private and public pools per tenant, allocated and recorded, with an address able to outlive the resource it was attached to | API · console · CLI |

| Capability | How it works | Surface |
|---|---|---|
| G · Network and address space (continued) | ||
| Security groups and translation | Rules by address range, port and protocol on any attachable resource, generated from the declared scope and audited like any mutation | API · console · CLI |
| Default-deny toward the platform | Tenant egress cannot reach the platform's own control surfaces | platform |
| Metered and capped egress | Egress measured per tenant regardless of whether it is charged, with published per-tenant ceilings and a stated fair-use envelope | platform · API |
| Private and restricted reach | A private path to the platform that does not traverse the public internet, and control-plane access restricted to declared source networks | platform |
| Abuse mitigation | Inbound abuse and volumetric attack mitigation in place before any tenant-facing address is published | platform |
| H · Storage and data | ||
| Network volumes | Persistent beyond the resource that used them, attachable across a region, with the enforced quota being the number billed | API · console · CLI |
| Shared filesystem | POSIX semantics with per-user quotas across a cluster's nodes | API · console |
| Bring your own storage | Supported 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 platform | operator |
| Storage on whole machines | A 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 reclaim | API · console |
| Per-tenant storage isolation | Namespace, access zone and object policy per tenant, with scoped credentials the platform never holds a stronger version of | platform |
| Object access and browsing | An S3-compatible surface with scoped credentials, browsable, uploadable and downloadable from the console | API · console |
| Images and boot volumes | Versioned, checksummed image objects with a trust tier and a publisher, and boot volumes created from them | API · console · CLI |
| Tiers, snapshots and replication | Published throughput and IOPS per tier, point-in-time snapshots, and cross-region replication as an explicit priced capability | API · console · CLI |
| Checkpoint durability | Checkpoint writes acknowledged only when durably stored, so a workload can make its progress conditional on the acknowledgement | platform |

| Capability | How it works | Surface |
|---|---|---|
| H · Storage and data (continued) | ||
| Data placed before dispatch | Datasets and weights positioned close to compute before work is dispatched, and work whose data is not in place is not admitted | platform |
| Accelerated data path | Remote-direct transfer from storage to device where the fabric and the storage support it, declared per unit | platform |
| I · Fleet, clusters and hosts | ||
| Derived availability | What the scheduler could actually place for a shape, per cluster, never a free-device count | API · console · CLI |
| Per-cluster freshness | Every aggregate carries how current each cluster's contribution is, so a stale source is visible rather than silently optimistic | API · console |
| Cluster registration | An independent cluster registered and withdrawn at runtime, its credential never readable through the API, every change audited | API · console · CLI |
| Burn-in acceptance | A thermal soak, a device diagnostic and a collective-communication floor, each result recording what was measured against what threshold | API · console |
| Firmware baseline | Verified at enrollment against the recorded standard for the hardware generation, and re-verified on every boot | platform |
| In-service remediation | A host already carrying tenant work is drained, brought to a new baseline and returned to the pool as a tracked operation | platform · operator |
| Fault detection and quarantine | A faulty accelerator is detected and drained without data loss to running work, and quarantined individually | platform |
| Spares and replacement | Replacement under a tracked process with a recorded owner and elapsed time, against a spares pool sized from measured failure rates | operator |
| Sites and their hardware layer | Each site runs its own providers, one per capability, with write access to its own machines and nothing central | operator |
| Provider cells from the pool | A cell built from a site's machines with its fabric and storage domains declared; a joining machine is not sellable, a leaving one is reclaimed | operator · API |
| Occupancy | Each machine's time since enrollment divided across its states and assignments, adding up, with unobserved time shown as such | API · console |
| Named machine actions | Power-cycle, re-inspect, acceptance, accelerator reset, maintenance hold, diagnostic bundle and quarantine release, each authorized and recorded | API · console · CLI |

| Capability | How it works | Surface |
|---|---|---|
| J · Organizations, projects and people | ||
| Multi-organization membership | One account across many organizations and projects, with no separate logins to maintain | API · console · CLI |
| Per-resource authorization | Permission to act on a specific resource decided per request from a relation store, never from an account-level role list | API · gateway |
| Two shapes of refusal | Not found where there is no relation to the parent scope; forbidden, naming only the action, where there is | API |
| Scoped delegation | An administrator grants a subset of their own rights without granting full organization administration | API · console · CLI |
| Invitations and verified domains | Single-use invitations revocable before acceptance, and a claimed email domain proven by DNS record and re-checked on demand | API · console · CLI |
| Federated sign-in and provisioning | Authentication routed to an organization's own provider by verified domain over SAML or OpenID Connect, with directory-driven provisioning and deactivation | console · platform |
| Multi-factor authentication | Available to every user, and mandatable by an organization for all of its members | console |
| Scoped credentials | Revocable API tokens restricted to a subset of the issuer's permissions, registered SSH keys, short-lived certificates and single-use tickets | API · console · CLI |
| Always an owner | The last owner cannot be removed or demoted; recovery is a second-approved provider action on the organization's own trail | API · operator |
| Usage attributed to a member | Fixed at recording to the requester, or to the issuer of the token used, beside organization, project and cost center | platform |
| A member's own spend | Their attributed usage, remaining allowance and per-window charges, without the organization's totals or anyone else's usage | API · console |
| Personal projects | Members may create projects of their own where the organization permits it, within its ceiling and a per-member limit | API · console · CLI |
| K · Reach, logs and evidence | ||
| SSH by tenant key | A registered public key connects to a resource the user may reach; the platform never holds the private half | gateway · CLI |
| Short-lived certificates | One of the user's registered keys signed briefly for one resource, with that resource's id as its only valid principal | gateway · API · CLI |

| Capability | How it works | Surface |
|---|---|---|
| K · Reach, logs and evidence (continued) | ||
| Browser terminal and console | An interactive terminal and a machine console in the console, opened with a single-use ticket and re-checked while the session runs | gateway · console |
| Notebooks and editors | A managed notebook or browser editor against a workload or a volume, authorized per session and recorded like any other session | console · API |
| Live session revocation | Removing a relation or a key ends sessions already open, on every transport, inside a published bound | gateway |
| Session records and recordings | Opened, by whom, from where, closed how, with a replayable transcript, paged rather than served whole, transfers and tunnels named in markers | API · console · CLI |
| Live and historic logs | Streamed from the tenant log store rather than the machine, so last output survives for the published retention | API · console · CLI |
| Declared blindness | Telemetry the platform cannot observe reports unobservable with a reason, never a zero | API · console |
| Continuous export | Logs, telemetry and the audit trail exported continuously to a destination the tenant controls | API |
| L · Platform surface and developer experience | ||
| One versioned API | A published specification from which the server, every client and the console's types are generated, with breaking changes refused at build time | API |
| No console-only capability | Every operation has a command-line command, and the console calls only published endpoints | API · console · CLI |
| SDKs and infrastructure as code | Generated Python and TypeScript clients, and a provider covering every resource type, so a fleet can be declared rather than clicked | API |
| Agent access | A tool server exposing the published operations to autonomous agents under the same authorization and audit trail | API |
| Events and webhooks | Signed, retryable, replayable delivery on lifecycle transitions, so integrations are built against events rather than polling | API |
| Capacity notifications | A tenant asks to be told when a shape becomes placeable, and is told | API · console |
| Rate limits | Published, enforced per credential, returning a machine-readable retry hint rather than an opaque refusal | API |

| Capability | How it works | Surface |
|---|---|---|
| L · Platform surface and developer experience (continued) | ||
| Audit trail | Every mutating action attributable to a principal, written by one path, queryable by the tenant for their own scope | API · console · CLI |
| Independent status page | Current and historical health per region and unit family, served from outside the platform it reports on | public |
| M · Commercial, contract and channel | ||
| Metering completeness | Windowed events deduplicated end to end and verified by an independent nightly recomputation rather than asserted | platform |
| Usage and chargeback | Usage by project and cost-center label, a forecast of the current period, and the same numbers the invoice will carry | API · console · CLI |
| Prepaid and contract billing | One balance carried across periods and released automatically once restored, or arrears against agreed terms with purchase-order references and the agreed cost-center breakdown | API · console |
| Commitments and reservations | A committed spend level auto-applied at the agreed discount, backed by a reservation ledger, with future-dated requests answered honestly | API · console |
| Interruptible capacity | A published discount with a guaranteed minimum notice not shorter than the tenant's declared checkpoint interval | API · console |
| Spend caps and the ladder | Organization, 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 work | API · console · platform |
| Refusal at submission | Member and cost-center caps refuse new work before capacity is reserved, and never stop work that is running | API · platform |
| Holds that shrink | A reservation covers only the period still ahead, so spent plus held is one period's cost | platform |
| Dispute answers | A per-window explanation of what was billed and why, including the provisioning windows charged at zero | API · console |
| Nested resellers | Sub-organizations a reseller administers and is billed for, without visibility into their work | API · console |
| White-label | Brand, domain and language per organization, across the console and everything it sends | console · operator |
| Usage feed | A continuous, replayable feed of metered usage keyed on the same windows the invoice reads | API |

| Capability | How it works | Surface |
|---|---|---|
| M · Commercial, contract and channel (continued) | ||
| Cost model and margin | Prices derived from a cost model covering acquisition, power, network, storage and support, with achieved margin reported per unit monthly | operator |
| Availability commitment | A defined measurement, a credit schedule by breach band, an exclusions list and a claim process, with credits offered unprompted | platform |
| Support tiers and change notice | Published response targets per severity with the tier visible, and pricing or terms changes notified in advance, never retroactive | console · operator |
| N · Security, compliance and tenant lifecycle | ||
| Kernel and driver isolation per unit | No shared kernel between mutually untrusting tenants, and no route to the host's accelerator driver interface, claimed per unit | platform |
| Memory cleared between tenants | Accelerator memory verifiably cleared per hardware generation before a device is re-offered | platform |
| Export-control screening and matrix | Accounts screened at creation and recurrently; accelerator classes governed by a jurisdiction-and-unit matrix maintained as policy | platform |
| Evidence records | Who rented which accelerator class, from where and for how long, kept for the period regulation requires | API · operator |
| Encryption and key custody | Encrypted in transit on every path leaving a host and at rest, with the protecting key and its holder published, and tenant-supplied keys supported | platform · API |
| No standing personnel access | Residual operator access is time-bounded, second-approved, auto-expiring and visible in the tenant's own audit trail | platform |
| Signed artifacts and secrets | Every artifact signed and verified at deployment; secrets never in configuration repositories, scoped per tenant, access audited | platform |
| Firmware tampering detected | In-band management access disabled while a machine is held, and any firmware change found out of band before it is offered again | platform |
| No platform agents on tenant machines | Nothing 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 cell | platform |
| Shared-engine cache isolation | A serving engine shared between tenants never serves one tenant state computed from another's requests, at any cache tier | platform |

| Capability | How it works | Surface |
|---|---|---|
| N · Security, compliance and tenant lifecycle (continued) | ||
| Assurance and disclosure | Independent assessment, a controls attestation, accelerated-cloud conformance, a sub-processor register and a published disclosure policy | operator · public |
| Self-serve to running | Signup to running capacity without human intervention, subject to identity-verification tier | console · API |
| Closure, export and deletion | A final reconciled invoice to the moment of closure, an unthrottled export window, deletion including backups, and evidence on request | API · console · operator |
| Legal hold and migration | Hold exempts an account from automatic deletion; migration moves a tenant between organizations, resellers or plans without interruption | operator |
| O · Operations | ||
| Staffed operations | A continuously covered operations function, sized against the availability commitment it supports | operator |
| Severity by tenant impact | Incident severity defined by capacity-hours at risk, with paging driven by that definition rather than by component alarms | operator |
| Error budgets | Every published objective has an owner, an error budget and an alert that fires on burn rate rather than instantaneous breach | operator |
| Control-plane restore | Restored within a published recovery time and to a published recovery point, verified by timed drill | operator |
| Pinned upgrades | The whole component set pinned and upgraded as one unit through a staging canary, with a recorded emergency path | operator |
| Bounded blast radius | Failure bounded to a defined domain whose size and composition are documented and tested | platform |
| Media sanitization | A host leaves the fleet only after media that held tenant data is sanitized or destroyed, with evidence retained | operator |
| Commitments are drilled | Every externally visible commitment is validated by a repeatable drill asserting a measured number, and none is published before it passes twice | operator |
| Forced removal | A resource or cell whose teardown cannot complete is removed by a separately authorized, recorded operation, with deletion evidence derived from what it completed | operator · API |

| Capability | How it works | Surface |
|---|---|---|
| P · Rack-scale systems, firmware and images | ||
| The rack as one unit | Enrolled whole and accepted tray by tray, with its switch trays, power shelves and cooling inventoried and monitored as parts of the rack | operator · API · console |
| Interconnect partitions | A tenant's share of a rack's interconnect domain is a partition that excludes every other tenant, made at hand-over and removed at return | platform |
| Rack-aware placement | Multi-tray units placed inside one interconnect domain; a degraded rack offers nothing that depends on what is degraded | platform |
| Health events | Leak, 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 sale | API · console · operator |
| Firmware baselines | One baseline per hardware generation; every component read back as match, behind, drift or unreadable | API · console · operator |
| Verified firmware packages | Signature and measurement manifest verified at import, including packages carried into an air-gapped site | operator · platform |
| Staged rollouts | One 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 failures | operator · API |
| Read-only firmware record | Switches, storage, facility controllers and the site's own servers read for the record (when, how and who updates them) and never written | operator |
| Image stack and lifecycle | Every image states its accelerator software and versions, and moves from candidate to current to deprecated to retired, with tenants told the date and the successor | API · console · CLI |
| Maintenance windows a tenant can answer | Accept, or move to a later start within a published limit; unanswered goes ahead; a window that interrupts nothing says so | API · console |

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 |
|---|---|---|
| 01 | bill for capacity that never became healthy | Metering 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 |
| 02 | display capacity it cannot place | Availability is derived from placeability per cluster, with a freshness stamp on every figure |
| 03 | reclaim interruptible capacity on less notice than the tenant's declared checkpoint interval | The notice period is a property of the unit and is delivered before reclamation begins |
| 04 | discard logs when a workload crashes | Lines are read from the tenant log store, never from the thing that wrote them |
| 05 | publish a best-case latency figure as a typical one | Every published figure is a measured percentile with its measurement method stated |
| 06 | require a tenant to detect a platform failure in order to be credited for it | Credits are computed from platform telemetry and offered without a claim |
| 07 | charge a stopped resource more than a running one without saying so at the point of stopping | The stop preview and the metering basis on the unit, both shown before the action |
| 08 | withhold compliance documentation or security features behind a spend threshold | A published commercial policy, not a matter of sales discretion |
| 09 | hold the only copy of a key protecting tenant data where the tenant has contracted otherwise | Tenant-supplied keys, whose revocation renders the data unrecoverable |

| # | Bud GPU Foundry will never… | What holds it |
|---|---|---|
| 10 | suspend a contract-billed tenant automatically for balance reasons | For that class enforcement is a quota ceiling and a notification; suspension needs a recorded human decision |
| 11 | present utilization telemetry as a charge basis on any unit where it cannot observe the tenant | Blind classes are declared in the catalog in advance, and render as a stated absence |
| 12 | offer a fractional tier to mutually untrusting tenants unless the isolation is enforced in hardware | Tenant classes are a property of the catalog row, and the generator refuses the combination outright |
| 13 | expose a tenant to another tenant's residual accelerator memory | Verified memory clearing per hardware generation before a device is re-offered |
| 14 | return a machine to the pool without verified erasure of the media that held tenant data | Sanitization is part of the reclaim workflow, with evidence retained for the deletion period |
| 15 | sell a dedicated fabric path that is in fact shared with another tenant | Fabric partitions are per tenant, and a fabric the platform cannot confirm offers no capacity at all |
| 16 | issue a tenant credentials of any kind to the platform's own orchestration control plane | Asserted against the API and against the access gateway's certificate issuer. A tenant's own cluster is their cluster; ours is never reachable |
| 17 | require a tenant to hold a long-lived credential to reach what they bought | Certificates, tickets and cluster credentials are minted on demand and expire on their own |
| 18 | let a reseller see inside its customers' work | A reseller relation reaches quota, consumption and spend; there is no relation from it to a workload, a session or a log line |
| 19 | allow a capacity request to bypass quota accounting by any path | Admission policy checks that work is routed by the scheduler, and anything that slips past is counted |
| 20 | promise live migration of accelerator-attached guests | Stated as impossible rather than deferred, so no plan ever quietly assumes it |
| 21 | market an isolation grade it does not enforce on the specific unit being sold | Runtime pinning by provenance, and grade constraints checked against what the hardware publishes |
| 22 | give operator personnel an interactive session into a running tenant workload | The break-glass path is cordon and evacuate; the attempt is refused and audited |

| # | Bud GPU Foundry will never… | What holds it |
|---|---|---|
| 23 | offer a machine again after a tenant changed its firmware | In-band management access is disabled for the allocation, and reclaim reads every component back out of band; a mismatch quarantines |
| 24 | run its own agents or controllers with standing write access on a machine handed to a tenant | The one credential kept to a tenant's cluster stays at the site, is used only for operations the tenant asks for, and is declared |
| 25 | interrupt a machine a tenant holds outside a window they were told of, except to contain a fault | Every operator action on a held machine is named and recorded, and fault containment is notified when it happens |
| 26 | install firmware whose vendor signature has not verified | Packages are verified at import, air-gapped sites included, and a baseline can name only a package that verified |
| 27 | stop work that is already running because a member's spend cap was reached | A member cap refuses new work at submission; only the organization's own ladder can reach running work |
| 28 | reveal one member's usage to another member who may not read the organization's usage | A member reads their own attribution; the breakdown by member needs the relation that reads the organization's usage |
| 29 | smooth, clamp, interpolate or discard a metered quantity before it is rated | The quantity rated is the quantity metered, and a late correction is spent the moment it lands |
| 30 | show a tenant any signal derived from another tenant's cached or in-flight state | Cache scope on a shared serving engine is set by the platform, never taken from the request |
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.

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.
How Bud GPU Foundry installs into your data centers, site by site, including air-gapped environments.
The published, versioned specification every console, CLI and SDK operation is built on.
The catalog Bud GPU Foundry would discover and propose from the hardware you already run.
Proven designs for GPU clouds, enterprise and sovereign platforms, and reseller channels.
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 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.
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.