---
title: "AI and GPUs: run models on GPUs you own, or on ours · Frazer"
description: "Deploy an open model, fine-tune it, train across nodes or open a notebook. On your own GPU servers for a flat $49 per GPU a month, or on the Frazer fleet by the second."
url: https://frazer.ai/ai
index: https://frazer.ai/llms.txt
tokens: 1611
---

> For agents: every page on frazer.ai is indexed at https://frazer.ai/llms.txt.

# AI and GPUs: run models on GPUs you own, or on ours · Frazer

AI and GPUs

# Run models on GPUs you own.  
Or on ours.

Deploy an open model in two clicks, fine-tune it on your data, train across nodes or open a notebook. On your own GPU servers for a flat $49 per GPU a month, or on the Frazer fleet by the second.

[Deploy a model](https://frazer.ai/start?product=ai) [Read the docs](https://frazer.ai/docs)

```
$ frazer ai endpoints deploy hf://openai/gpt-oss-120b \
    --gpu h100-80gb --min 0 --max 3
  Engine     Frazer inference · MXFP4 · max length 128k
  Where      your pool sf-office-default → full; fleet us-virginia1
  Cost       $3.59 / GPU-hour while up · $0 at zero
✓ Weights cached          41 s
✓ Ready · 1 worker
→ https://gpt-oss-120b-4f7a2c.frazer.run/v1
  OpenAI-compatible · key in the LLM gateway
```

```
PROJECT=projects/acme-production
curl -X POST "https://api.frazer.ai/ai/v1/$PROJECT/endpoints" \
  -H "Authorization: Bearer $FRAZER_TOKEN" \
  -d '{"model": "hf://openai/gpt-oss-120b", "validateOnly": true,
       "gpu": {"class": "h100-80gb", "count": 1},
       "scaling": {"min": 0, "max": 3}}'
```

```
# frazer ai endpoints apply -f gpt-oss-120b.yaml --dry-run
apiVersion: ai.frazer.ai/v1
kind: Endpoint
name: projects/acme-production/endpoints/gpt-oss-120b
spec:
  kind: llm
  model: hf://openai/gpt-oss-120b
  gpu: { class: h100-80gb, count: 1 }
  placement: { location: us-virginia1 }   # or { pool: sf-office-default }
  scaling: { min: 0, max: 3 }
```

```
# Python SDK
import frazer

endpoint = frazer.endpoints.deploy(
    "hf://openai/gpt-oss-120b", gpu="h100-80gb", min=0, max=3
)
print(endpoint.url)  # OpenAI-compatible; key in the LLM gateway
```

How it works

## Pick a model. Pick a place. Serve it.

-   1 · Model
    
    ### From anywhere
    
    Hugging Face, your private registry, or a fine-tune you made here. Gated models check your access first.
    
    openai/gpt-oss-120b Hugging Face
    
    acme/support-ft-v4 your fine-tune
    
-   2 · Place
    
    ### Your GPUs first
    
    Frazer shows live free GPUs in your pools and on the fleet, with the price per hour before you click.
    
    sf-office-default · 2× RTX 6000 Ada 0 free
    
    fleet us-virginia1 · H100 80 GB 14 free
    
-   3 · Serve
    
    ### An endpoint that scales
    
    OpenAI-compatible, autoscaling to zero, routed by cache, metered per token in the LLM gateway.
    
    Workers min 0 · max 3
    
    Tokens metered per key
    

Panels show product UI, demo organization

Everything around the model

## From notebook to production, one product.

-   ### Model endpoints
    
    Frazer’s inference engine, cache-aware routing, scale to zero, cold starts shown on every endpoint. Serverless endpoints for your own containers.
    
-   ### Fine-tuning
    
    LoRA, QLoRA, full, SFT and DPO with presets or your Axolotl file; an estimate first.
    
-   ### Training jobs
    
    Multi-node with checkpoints to object storage and automatic restarts.
    
-   ### GPU pods and notebooks
    
    JupyterLab or your image, idle stop after 15 minutes, volumes kept.
    
-   [### LLM gateway
    
    One key for Anthropic, OpenAI, open models and your own endpoints; budgets and logs.](https://frazer.ai/ai/gateway)
-   [### Company RAG
    
    Ingest docs and repos into Qdrant with reranking and evaluations.](https://frazer.ai/knowledge)
-   ### Model catalog
    
    Tested configurations per model and GPU class, so the first deploy works.
    
-   ### GPU health
    
    Burn-in, GPU health metrics and NCCL checks before a GPU takes work.
    

Proof

## Numbers you can verify.  
Measured on your own endpoint.

Cold start p50 and p95

From a request held at zero workers to a ready worker, on every endpoint page.

Time to first token

p50 per endpoint, with inter-token latency, from the engine and the gateway.

Tokens per second

Per worker and per endpoint, next to queue depth and KV-cache use.

Cost per 1M tokens

GPU-seconds from the billing ledger, set against the tokens the endpoint served.

Every endpoint page also shows its engine, version, quantization, max context and prefix-cache hit rate.

Pricing

## One price per GPU class.  
No multipliers.

Billed per second on the fleet, from the moment the GPU is ready. Your own GPUs are a flat fee, whatever runs on them.

[Open the calculator](https://frazer.ai/pricing)

GPU prices on your servers and on the Frazer fleet

| GPU | Memory | On your server | On the Frazer fleet |
| --- | --- | --- | --- |
| H100 80 GB | 80 GB | $49 / month | $3.59 / hour |
| H200 141 GB | 141 GB | $49 / month | $4.49 / hour |
| B200 180 GB | 180 GB | $49 / month | $5.99 / hour |
| A100 80 GB | 80 GB | $49 / month | $1.69 / hour |
| L40S 48 GB | 48 GB | $49 / month | $1.59 / hour |
| L4 24 GB | 24 GB | $49 / month | $0.55 / hour |

From the same price list as the console.

Questions

## AI and GPUs, answered.

Is a model endpoint the same as a serverless endpoint?

No. A model endpoint serves a model: Frazer runs its inference engine, tuned per model and GPU class, behind an OpenAI-compatible API. A serverless endpoint runs your own container as a job queue or an HTTP API. Each has its own page.

What is billed on the Frazer fleet?

GPU-seconds by class, from the moment a worker is ready. Starting, throttled, unhealthy and stopped workers are not billed, and a stopped workload pays only for its storage. Scaling to zero frees your quota.

What do I pay on my own GPU servers?

A flat $49 per data-center GPU a month. Endpoints, pods, fine-tunes and notebooks on those GPUs are included, and usage shows as GPU-seconds so each team sees what it used.

Who else runs on the GPU I get?

On your servers, only your organization. On the Frazer fleet, each organization gets its own virtual machine with whole GPUs. Credentials for Hugging Face and other sources stay in your organization's connections and are never copied into a serving container unless you mount them.

Which workloads run on my GPUs, and which on the Frazer fleet?

All of them run in both places: model endpoints, serverless endpoints, GPU pods and notebooks, fine-tuning, batch jobs and multi-node training. You pick the place for each workload, with the free GPUs and the price per hour shown before you deploy.

## Your models.  
Your GPUs, or ours.

[Deploy a model](https://frazer.ai/start?product=ai) [Read the docs](https://frazer.ai/docs)