Skip the Token Tax.
Hosted llm-d on private, dedicated per-customer clusters. Serve Hugging Face or private models behind an OpenAI-compatible API with smart request routing, and pay for actual hardware consumption, not tokens.
# OpenAI-compatible. Any model. Your own GPUs.
$ curl https://inference.alpcrun.ch/v1/chat/completions \
-H "Authorization: Bearer $ALPCRUN_KEY" \
-d '{ "model": "meta-llama/Llama-3.3-70B-Instruct",
"messages": [{ "role": "user", "content": "…" }] }'
< x-alpcrun-cluster: c-9f2a (private, dedicated)
< x-alpcrun-route: kv-cache hit · decode pool
< x-alpcrun-billing: gpu-time (no token charge)Your models. Your cluster. Your bill.
Managed llm-d serving on GPUs that belong to you alone, with routing that squeezes every drop out of them, and billing that only counts what they actually did.
Private, not shared
Every customer gets their own private, dedicated inference cluster: your models, your KV-cache, your GPUs. Spin clusters up or tear them down in minutes, straight from the dashboard.
Smart request routing
KV-cache-aware, load-aware routing with disaggregated prefill and decode. More throughput and lower latency from the same hardware.
Hardware-metered billing
No per-token markup. You pay for the GPU time your cluster runs and the traffic it moves, itemized on your invoice.
The inference core.
Everything you need to serve production LLM workloads, without running the stack yourself.
Hosted llm-d
The open distributed inference stack, run for you: upgrades, monitoring, and ops included.
Private dedicated clusters
Private per-customer GPU clusters, created and destroyed on demand. No noisy neighbors.
Smart routing
KV-cache-aware and load-aware request steering, with prefill/decode disaggregation.
GPU-time metering
Billing counts hardware consumption and traffic over time. No token math, no multipliers.
Hugging Face models
Deploy public models straight from the Hub: pick a model, size the pool, serve.
Private models
Upload your own weights via the dashboard into the private model registry we provide and run.
OpenAI-compatible API
Drop-in endpoints for existing SDKs and tools. Change one base URL, keep your code.
Team API keys
Issue, scope, and revoke keys per team or app from one LiteLLM entrypoint.
Chargeback reporting
Consumption per key and per team, ready to bill back to internal budgets.
Multi-region redundancy
Connect clusters across regions for geo-redundancy and failover.
Want the full picture?
Register for early access →One URL in, your cluster out.
Your apps call one OpenAI-compatible endpoint. The gateway routes, isolates, and meters every request. Your private cluster does the crunching, and responses flow back the same way.
Your Apps
Anything that speaks the OpenAI API talks to your models unchanged.
LiteLLM Entrypoint
Your single front door: issue keys, route requests, and meter every call.
Your Private Cluster
llm-d and vLLM workers serve your models on GPUs reserved for you.
From the Hub, or from your vault.
Serve public models from Hugging Face or upload your own fine-tuned weights into the private model registry we provide. Both run side by side on the same private, dedicated cluster.
- ▸Hugging Face Hub: pick any public model in the dashboard and deploy it in a few clicks.
- ▸Private model registry included: we host the registry for you. Upload your own weights via the dashboard, versioned and encrypted, pulled only by your cluster.
- ▸Per-model pools: size, pin, or scale each model independently, down to zero when idle.
One entrypoint for the whole org.
A managed LiteLLM entrypoint is where your teams get their keys and where you see exactly who spent what. Connect as many clusters, regions, and external providers as you need behind it.
- ▸Self-service API keys: create, scope, and revoke keys per team, app, or environment.
- ▸Chargeback-ready reporting: consumption broken down per key and per team, so internal costs land on the right budget.
- ▸Geo-redundancy: connect multiple clusters across multiple regions and fail over between them.
- ▸Frontier providers: attach external frontier model APIs alongside your own clusters and route per model.
The meter is the bill.
Your invoice adds up the GPU time your cluster actually ran and the traffic it moved. Nothing else, and never tokens.
# itemized by hardware consumption and traffic
llama-3.3-70b-instruct H100 ×4 114.5 GPU-h $412.13
mistral-small-3.2 L40S ×2 22.5 GPU-h $24.27
acme/underwriter-8b-v4 L4 ×1 5.7 GPU-h $3.10
egress traffic transfer 1.84 TB $16.56
cluster baseline flat 720 h $18.00
total $474.06
tokens billed 0- ▸Hardware and traffic only: your bill adds up GPU time and data transfer over the period, never tokens.
- ▸Per-key breakdown: roll consumption up by API key and team for internal chargeback.
- ▸Live analytics: every cluster ships with logging pipelines and usage insights out of the box.
- ▸Spend controls: cap total spend with usage limits per cluster or environment.
- ▸Scale to zero: idle models release their GPUs; only a low per-cluster baseline remains.
Serve your first model in minutes.
Pick a model from the Hub or upload your own, spin up a private dedicated cluster, and point your SDK at one URL. Billing that stops when you do.