Introducing Forge

How Forge turns fragmented GPU supply into reliable compute

Getting access to GPUs is only part of the problem.

For AI teams, the harder problem is getting compute that is ready to use: configured correctly, secured properly, performant enough for serious workloads, and clean after every customer run.

That gets complicated quickly when GPU supply comes from many different providers.

Some data centers have mature provisioning APIs. Others have more limited automation. Some expose only SSH access to the machine. Infrastructure stacks differ. Security controls differ. Recycling processes differ. The customer wants one simple experience, but the supply side of the market does not behave like one consistent cloud.

Forge is the infrastructure layer Hyperbolic built to solve that.

Forge gives Hyperbolic a way to take heterogeneous GPU supply from providers around the world, manage the full machine lifecycle, and expose that supply through a single customer experience.

Today, the first product built on Forge is bare metal provisioning and instance management for on-demand GPU compute. Over time, Forge is designed to support more of Hyperbolic’s compute platform, including inference, managed Kubernetes, Slurm, and other services that need a reliable foundation underneath.

Why GPU provisioning is harder than it looks

A GPU marketplace or distributed cloud is only as good as the infrastructure behind it.

It is not enough to take a node from a provider and hand it to a customer. That approach creates too many gaps.

Before a customer can use a machine, the environment has to be prepared. The right image has to be applied. Security hardening has to happen. Firewall rules need to be controlled. Access needs to be managed. The node needs to be monitored. After the workload ends, the machine has to be recycled and sanitized before it can be used again.

If Hyperbolic does not own that lifecycle, too much depends on each individual provider.

That limits which suppliers we can work with. It creates operational overhead. It makes the customer experience harder to standardize. It also introduces security and data sanitization risks that are not acceptable for serious AI workloads.

Forge gives Hyperbolic control over that lifecycle.

It lets us take GPU nodes from different provider environments, including nodes where the provider may only give SSH access, and bring them into a controlled provisioning workflow.

What Forge does

Forge is Hyperbolic’s cloud foundation layer.

It is the management plane that allows Hyperbolic to turn distributed GPU supply into usable infrastructure.

With Forge, Hyperbolic can:

• Bring heterogeneous GPU nodes into a controlled provisioning workflow

• Prepare machines with the right configuration and software environment

• Own more of the firewall and security stack

• Apply security hardening before customer access

• Manage golden images for more consistent environments

• Monitor node readiness and access

• Recycle machines after customer workloads complete

• Sanitize nodes so customer data is destroyed before the machine is reused

• Give customers a single interface for accessing GPU supply

Forge is built so customers do not have to care which provider a machine came from, what provisioning system that provider uses, or how much automation exists underneath. They should be able to launch compute and trust that the environment is ready.

More control without giving up performance

The tradeoff with infrastructure control is usually performance.

For AI workloads, that tradeoff matters. Training, fine-tuning, and inference workloads are sensitive to overhead. Teams do not want better lifecycle management if it comes at the cost of materially worse GPU performance.

Forge was designed to avoid that tradeoff.

In internal testing across bare metal nodes and virtualized guest environments, the Forge virtualization layer introduced approximately 2% overhead compared to bare metal performance.

That means Hyperbolic can add the controls needed for security, standardization, recycling, and lifecycle management while preserving near-bare-metal performance for customers.

Why this matters for customers

Customers should not have to think about provisioning infrastructure.

They should not have to ask whether the machine was prepared correctly, whether the environment is clean, whether the image is consistent, or whether the provider’s workflow is mature enough to support real workloads.

Forge helps Hyperbolic make that complexity invisible.

For customers, this means:

More available capacity

Forge makes it easier for Hyperbolic to work with a broader range of GPU providers, including providers that do not expose mature provisioning APIs.

A more consistent launch experience

Customers get a more standardized environment across distributed supply.

Stronger security controls

Hyperbolic has more control over machine preparation, firewall configuration, access patterns, and security hardening.

Cleaner recycling and sanitization

After customer use, nodes can go through a controlled recycling process before being made available again.

Near-bare-metal performance

Forge adds lifecycle control while keeping virtualization overhead to approximately 2% in internal testing.

A single interface for distributed GPU supply

Customers get a simpler way to access compute, even though the underlying supply comes from many different environments.

Why this matters for the GPU market

GPU supply is becoming more distributed.

That is good for AI teams because it creates more paths to capacity. But distributed supply only works if the infrastructure layer can standardize the complexity underneath.

Raw GPU access is not enough. The platforms that matter will be the ones that can turn fragmented capacity into reliable infrastructure: secure, performant, ready to use, and easy to scale.

Forge is Hyperbolic’s foundation for doing that. It starts with bare metal provisioning and instance management. But the same foundation can support more products over time, including inference, managed Kubernetes, Slurm, and other infrastructure services that sit on top of distributed GPU supply.

Forge is how Hyperbolic moves from connecting customers to GPUs to operating a broader AI compute platform.

Building the foundation for AI compute

That means capacity that launches quickly, performs well, follows consistent security standards, and can be safely recycled after use.

Forge gives Hyperbolic the foundation to deliver that experience across a fragmented supply market. It is the infrastructure layer behind reliable GPU provisioning today, and the foundation for the broader compute platform Hyperbolic is building next.