How much GPU memory does a large language model need?

The weights are the parameter count multiplied by the bytes per parameter: two bytes each at 16-bit, one at 8-bit, half at 4-bit. A 7-8 billion parameter model is 16 GB of weights at 16-bit, 8 GB at 8-bit and 5 GB at 4-bit; a 70 billion parameter model is 140 GB, 70 GB and 38 GB. Those figures are the weights alone and are a floor rather than a requirement -- budget a quarter to a half again on top for the runtime, the activations and the key-value cache.

What do I need to run a 70B model like Llama 3.3?

At 4-bit the weights are about 38 GB, so with serving head-room the answer is a card of 64 GB or more -- one card, one machine. At 8-bit the weights are 70 GB and an 80 GB card clears the bar. At full 16-bit precision no single card Primcast fits holds it, and it becomes a multi-card build that is quoted. The fit matrix on the page names the exact cards; the prices are at https://primcast.com/gpu.

Why does my model load but fail to serve?

Because the weights are not the only thing in card memory. The runtime and its buffers are resident, and every token in a conversation leaves an entry in the key-value cache so it does not have to be recomputed. That cache grows with the context length and again with each request served concurrently, so a model whose weights only just fit will hold roughly one short conversation. Size the card at one and a quarter to one and a half times the weights.

Which inference runtime can I install?

Any of them. The machine arrives with a clean operating system and root, and there is no vendor inference service in front of it. vLLM is the usual answer for serving real traffic because continuous batching lets one card answer many requests at once. llama.cpp is the usual answer when memory is tight or the card is older. TGI and SGLang run unchanged. Ollama is the shortest path from an empty machine to a model answering on a port -- and vLLM and Ollama both answer on an OpenAI-compatible endpoint, so existing client code points at your own machine by changing one base URL. You pin the driver, the CUDA or ROCm release and the framework to the versions your code was tested against.

Is self-hosting an LLM cheaper than a per-token API?

It depends entirely on volume, and the crossover is real: an API bills per token and costs nothing when idle; a dedicated machine is a flat monthly figure and costs nothing more when busy. Steady traffic, agents that run all day, batch pipelines and anything with a privacy requirement tend to come out ahead on their own hardware; a workload that fires ten times a day does not. The monthly figures to do that arithmetic with are at https://primcast.com/gpu -- the LLM page deliberately prices nothing.

How many tokens per second will I get?

Primcast does not publish a tokens-per-second figure, because every such number depends on the model, the quantisation, the runtime and its version, the batch size, the prompt length, the reply length and the concurrency, and changing any one moves it by a multiple. What governs it: reading the prompt is compute-bound and happens once per request; generating the reply is memory-bandwidth-bound because each token requires reading the weights; and batching amortises that reading across concurrent requests, which is what makes serving economical until the key-value cache runs out of room. Ask with the model, quantisation and expected concurrency for an answer based on what has actually been observed.

Is the GPU shared with anyone else?

No. One tenant per physical machine, and the card is passed through to your own operating system. There is no hypervisor, no MIG partition, no vGPU profile and no time-slicing scheduler, so nothing else runs on the card and inference latency does not move because of somebody else's batch job.

What if the model does not fit on one card?

Then it is a multi-card build, which is quoted rather than ordered from a checkout: how many cards fit depends on the physical width of the specific card and the power budget of the chassis. Two cards give you the sum of their memory only if the runtime can split the model across both, which every serious runtime supports at some cost in throughput. https://primcast.com/hpc covers what more than one card and more than one machine look like; 128 GB of memory the processor and GPU share in one machine is https://primcast.com/spark.

Does fine-tuning need more memory than serving?

Considerably more. Serving needs the weights; training needs the weights, the gradients and the optimiser state for every parameter being updated, all resident at once, plus the activations kept for the backward pass. A model that serves comfortably on one card can be several times too large to fully fine-tune on it. Parameter-efficient methods update a small fraction of the parameters and need a correspondingly small fraction of the extra memory, which is why most fine-tuning here uses one.

Can I run an AMD card, and does ROCm work?

Yes. The AMD Instinct parts are among the largest-memory cards fitted and are frequently the best value per gigabyte, but your stack has to support ROCm rather than CUDA. Most current inference runtimes do; some surrounding tooling still does not. Ask before ordering and it will be checked against your specific runtime rather than answered in general.

Planilha de dimensionamento · modelos de linguagem em bare metal · desde 2004

O que é preciso para rodar um modelo de linguagem em bare metal.

Preenchida de cima para baixo, na ordem em que a decisão acontece: o modelo define os pesos, a precisão os dimensiona, a folga cobre o runtime e a conversa, e o total indica a placa. Nada mais no formulário de pedido altera a resposta — uma placa com dois gigabytes a menos não roda mais devagar, ela simplesmente não carrega.

Desenhado por: Primcast LLC, fundada em 2004
Conferido contra: O catálogo de pedidos, no momento da exibição
Placas em arquivo · maior: 56 · 96 GB GDDR7 ECC
Preços nesta folha: Nenhum — veja /gpu

Preencha a planilha Por que um encaixe ainda pode falhar O que eu instalo nela

Transforme suas GPUs em receita mensal passiva

Tem configurações de GPU ociosas em servidores ou desktops? Anuncie-as hoje no marketplace da Primcast e receba aluguéis mensais constantes de equipes de IA, desenvolvedores e empresas que precisam de computação em nível de produção.

Ir para o Marketplace

Planilha

Quatro linhas, um veredito.

O modelo

A precisão

A carga

70B: 38 GB × 1.5 = 57 GB

Smallest card on the schedule that clears it (3 larger ones also do):

Instinct MI21064 GB HBM2e

The link opens the machine it goes in. What it costs is on /gpu — not on this sheet.

Linha 1 × linha 2 são os pesos; a linha 3 é a regra publicada pelo site de folga de um quarto a metade expressa como aritmética — um quarto a mais para um usuário por vez no llama.cpp ou Ollama, metade a mais para servir tráfego com batching contínuo no vLLM ou TGI. O veredito indica a menor placa do catálogo de pedidos que cobre o total e leva à máquina em que ela entra. Quanto essa máquina custa está deliberadamente fora desta folha: todos os números estão em /gpu, junto à máquina exata a que pertencem.

Fig. 1

Quanto pesam os pesos.

Parâmetros multiplicados por bytes por parâmetro, e esse é todo o cálculo. Pesos de dezesseis bits são dois bytes cada, de oito bits são um, de quatro bits são meio. Quantizar é o que transforma uma máquina que não comporta um modelo em uma que comporta; isso custa qualidade, e quanto custa depende do modelo e do método muito mais do que apenas da contagem de bits. Se a precisão é o objetivo do exercício, teste ambos antes de se comprometer com o hardware — a diferença é mais barata de descobrir agora do que depois da entrega.

Estes números são os pesos e nada mais. São o piso, não o requisito — a Fig. 2 é a parte que pega as pessoas de surpresa.

Weights only — the runtime, the activations and the conversation are extra, and are the subject of the next section.
Model	16-bit	8-bit	4-bit
7-8 billion parameters	16 GB	8 GB	5 GB
13-14 billion parameters	28 GB	14 GB	8 GB
30-34 billion parameters	68 GB	34 GB	19 GB
70 billion parameters	140 GB	70 GB	38 GB

Fig. 2 · interativa

A memória de uma placa, desenhada em planta — e por que um modelo que cabe ainda pode se recusar a servir.

A forma mais comum de uma compra de GPU dar errado, sempre do mesmo jeito: o modelo tem trinta e oito gigabytes, a placa tem quarenta, ele carrega — e sustenta aproximadamente uma conversa curta. Os pesos não estão sozinhos ali dentro. Deslize a carga de trabalho e veja o que acontece com a conversa.

pesos · fixos

runtime

cache chave-valor · cresce

livre

memória de uma placa, 100 %

A conversa · comprimento de contexto × requisições simultâneas

Um usuário, contexto curto: o multiplicador apertado (×1,25) cobre isso.

Cada token em uma conversa deixa uma entrada no cache chave-valor para não ser recalculado. O cache cresce com o comprimento do contexto e de novo com cada requisição servida ao mesmo tempo.
Reserve um quarto a mais sobre os pesos para um usuário por vez, metade a mais para servir tráfego — os dois multiplicadores da planilha, e a própria regra publicada pelo site.
Se estiver apertado, pergunte antes de comprar: modelo, quantização, contexto, concorrência. Preferimos dimensionar uma placa para você agora do que receber um pedido que volta como solicitação de reembolso na primeira semana.

Fig. 3

A matriz de encaixe: qual placa comporta qual modelo.

Leia para baixo até o seu modelo, depois para o lado até a precisão. Cada célula indica a menor placa da lista de peças que comporta esses pesos com espaço sobrando para servir, e leva à máquina em que ela entra. Onde nada comporta sozinho, a célula diz isso em vez de deixar um vazio.

The smallest card we fit that holds the weights with room left to serve — that is 1.5× the weights, the generous end of the quarter-to-a-half head-room rule below. No prices here on purpose: GPU dedicated servers holds every one.
If you want to run	at 16-bit	at 8-bit	at 4-bit
7-8 billion parameters	TESLA P40 / QUADRO P600024 GB16 GB of weights	TITAN V12 GB HBM28 GB of weights	TESLA P48 GB GDDR55 GB of weights
13-14 billion parameters	RTX A600048 GB GDDR6 ECC28 GB of weights	TESLA P40 / QUADRO P600024 GB14 GB of weights	TITAN V12 GB HBM28 GB of weights
30-34 billion parameters	More than one cardNothing we fit holds it alone68 GB of weights	Instinct MI21064 GB HBM2e34 GB of weights	Tesla V100 32GB32 GB HBM219 GB of weights
70 billion parameters	More than one cardNothing we fit holds it alone140 GB of weights	More than one cardNothing we fit holds it alone70 GB of weights	Instinct MI21064 GB HBM2e38 GB of weights

A menor placa que cabe nem sempre é a placa que você quer. A memória decide se um modelo roda; todo o resto da placa decide a velocidade e para quantas pessoas ao mesmo tempo. Se a vazão importa mais que o orçamento, suba um degrau na lista.
Placas mais antigas não falam os formatos numéricos mais novos. Várias peças da lista são anteriores ao FP8 e ao bfloat16, então um runtime que os espera vai cair para algo mais lento ou se recusar. Vale perguntar sobre uma placa específica e um runtime específico antes de pedir.
Uma placa AMD roda ROCm, não CUDA. As peças Instinct têm excelente valor por gigabyte e são a resposta em mais de uma célula, mas sua stack precisa suportar ROCm. A maioria dos runtimes atuais suporta; algumas ferramentas ao redor deles ainda não. Verifique a sua, ou pergunte e verificamos junto com você.
“Mais de uma placa” é uma configuração que orçamos, não uma opção de checkout — quantas placas cabem depende da largura da placa específica e do orçamento de energia do chassi. Multi-GPU e multi-nó é aquela folha. A outra resposta nesse tamanho são 128 GB de memória compartilhada entre processador e GPU, em uma máquina: alugar um NVIDIA DGX Spark.

Lista A

Lista de peças: toda placa que instalamos com um número de memória publicado.

Da maior para a menor — esta folha responde “qual é a maior coisa que posso rodar”, o inverso de servidores dedicados com GPU, que ordena o mesmo catálogo pela máquina completa mais barata porque está respondendo “quanto isso custa”. Uma placa cuja memória o fabricante não publica fica de fora em vez de ser estimada.

Várias peças aparecem em mais de um chassi, às vezes com preços diferentes, e a geração de barramento da máquina por baixo muda o que uma placa moderna consegue de fato fazer — ambos estão em servidores dedicados com GPU. O que está em rack e pronto neste minuto é outra pergunta, respondida por servidores instantâneos.

Referência

Modelos nomeados, mapeados para as linhas.

As famílias de pesos abertos que as pessoas trazem aqui, com a contagem de parâmetros publicada que diz qual linha da Fig. 1 se aplica. As contagens de parâmetros são dos próprios editores; nada mais em um modelo importa para a questão do encaixe. Um modelo que não está nesta lista se dimensiona exatamente do mesmo jeito — parâmetros × bytes por parâmetro, mais a folga. Famílias novas chegam mensalmente; a aritmética não muda.

Nota 1 · mistura de especialistas

Um modelo “30B com 3B ativos” precisa da memória de um modelo de 30B e roda mais perto da velocidade de um modelo de 3B: todos os especialistas precisam estar residentes, porque tokens diferentes acordam especialistas diferentes. Dimensione sempre pela contagem total de parâmetros.

Família	Tamanhos	Linha
Llama 3.1 / 3.3 Meta	8B · 70B	7–8B, e 70B para o lançamento 3.3
Qwen3 Alibaba	8B · 14B · 32B	As três primeiras linhas
DeepSeek-R1 destilados	7B – 70B	Um por linha — escolha o destilado que sua placa comporta
Mistral Small 3 Mistral AI	24B	Entre as linhas 2 e 3; dimensione pela aritmética, não pelo rótulo
Gemma 3 Google	12B · 27B	Linha 2, e logo abaixo da linha 3
Phi-4 Microsoft	14B	Linha 2
gpt-oss OpenAI	20B · 120B	Publicado nativamente em 4-bit: uma placa de 16 GB e uma placa de 80 GB

Notas de instalação

O runtime é seu. Esse é o ponto do bare metal.

A máquina chega com um sistema operacional limpo e root. Nenhum serviço de inferência do fornecedor na frente do seu modelo, nenhum runtime gerenciado que se atualiza sozinho na semana anterior a um prazo. vLLM e Ollama respondem ambos em um endpoint compatível com OpenAI — código escrito contra um provedor de API aponta para a sua própria máquina mudando uma URL base. Fixe o driver, a versão do CUDA ou ROCm e o framework nas versões contra as quais seu código foi testado; nada se move sob você. Se preferir que o driver seja instalado antes da entrega, diga isso no pedido e informe a versão.

vLLM — servindo tráfego real. Batching contínuo e atenção paginada permitem que uma placa responda a muitas requisições ao mesmo tempo: a diferença entre uma demonstração e um serviço. Exige uma placa razoavelmente moderna.
llama.cpp — memória apertada, ou placa mais antiga. Seus formatos quantizados são a razão de um modelo grande caber em uma placa pequena; ele usa processador e placa juntos quando os pesos não cabem exatamente.
TGI · SGLang — servidores de produção da mesma família, com pontos fortes diferentes em saída estruturada, reuso de prefixo e serviço de múltiplos modelos. Rodam aqui sem alterações.
Ollama — o caminho mais curto de uma máquina vazia a um modelo respondendo em uma porta. Dez minutos dizem se o seu dimensionamento estava certo.

Condições do local

O que a sua própria máquina faz que uma API não consegue.

Os prompts nunca saem do prédio

Pesos, prompts, documentos recuperados e cada token gerado permanecem em hardware no qual só você consegue entrar. Amsterdã ou Bucareste e os dados ficam na UE; Nova York, Miami ou São Francisco e ficam nos EUA. Para cargas de trabalho que respondem a um encarregado de privacidade, essa frase é todo o caso de negócio.

O medidor nunca roda

Uma API por token cobra cada token, e um agente ou um pipeline em lote gera tokens o dia inteiro. Uma máquina dedicada é o mesmo valor todo mês em qualquer volume, com banda não medida por baixo — pesos entrando e tokens saindo não custam nada além da porta. Qual é esse valor, é a linha de /gpu para preencher, não a desta folha.

Ninguém limita taxa, deprecia ou troca o modelo sob você

O modelo que você fixa responde inalterado em seis meses. Sem teto de requisições por minuto, sem fila na hora cheia de outra pessoa, sem aviso de descontinuação. A troca é honesta: as atualizações são suas, no seu cronograma.

O trabalho ao lado do modelo tem um lar

Recuperação quer um modelo de embeddings, um armazenamento vetorial e disco rápido; agentes querem espaço para rodar ferramentas. NVMe para o armazenamento, núcleos de processador para o pipeline, a placa para os tokens — uma máquina carrega tudo isso.

Nota 2 · classificações

Nenhum número de tokens por segundo aparece nesta folha.

Deliberadamente. Todo número desse tipo depende do modelo, da quantização, do runtime e da sua versão, do tamanho do lote, do comprimento do prompt, do comprimento da resposta e da concorrência — mude qualquer um e ele se move por um múltiplo. Um número de destaque que não carrega tudo isso é um número escolhido para parecer bom, e seríamos citados por ele. O que o governa: ler o prompt é limitado por computação e acontece uma vez por requisição; gerar a resposta é limitado por largura de banda de memória, porque cada token exige ler os pesos; o batching amortiza essa leitura entre requisições concorrentes, até o cache chave-valor ficar sem espaço. Folga de novo.

Peça uma resposta real em vez disso

Diga-nos o modelo, a quantização que pretende, o comprimento do contexto e aproximadamente quantas requisições concorrentes. Se já rodamos algo comparável, diremos o que vimos e em quê. Se não rodamos, diremos isso também.

Toda hora de todo dia — telefone, chat e tickets. Suporte tem os tempos de resposta por escrito.

Nota 3 · ajuste fino

Treinar precisa consideravelmente de mais espaço do que servir.

Servir precisa dos pesos. Treinar precisa dos pesos, dos gradientes e do estado do otimizador para cada parâmetro que atualiza, tudo residente ao mesmo tempo, mais as ativações guardadas para a passada reversa — um modelo que serve confortavelmente em uma placa pode ser várias vezes grande demais para ajuste fino completo nela. Métodos eficientes em parâmetros atualizam uma fração pequena dos parâmetros e precisam de uma fração correspondentemente pequena da memória extra, e é por isso que a maioria dos ajustes finos aqui usa um deles. O laço de treinamento também transmite lotes continuamente pelo enlace processador-placa, então a geração PCIe da máquina por baixo é uma restrição real ali de um jeito que não é para servir — qual plataforma dá a qual placa qual enlace está em servidores dedicados com GPU. Diga-nos o modelo, o método, o comprimento da sequência e o tamanho do conjunto de dados e nós dimensionaremos em vez de você descobrir depois da entrega; mais de uma placa é a folha de multi-GPU e multi-nó.

Folhas adjacentes

As páginas de cada lado desta.

Esta folha responde a uma pergunta: o que é preciso para rodar um modelo. Tudo o que é adjacente tem sua própria página, e estas são todas elas.

Perguntas levantadas

Perguntado em revisões anteriores desta ficha.

Retirado do que as pessoas realmente nos perguntam no chat e nos tickets, aproximadamente na ordem em que perguntam. As três primeiras são as que decidem se uma compra funciona.

Quanta memória de GPU um modelo de linguagem grande precisa?: Os pesos são a contagem de parâmetros multiplicada pelos bytes por parâmetro: dois bytes cada em 16 bits, um em 8 bits, meio em 4 bits. Um modelo de 7–8 bilhões de parâmetros tem 16 GB de pesos em 16 bits, 8 GB em 8 bits e 5 GB em 4 bits; um modelo de 70 bilhões de parâmetros tem 140 GB, 70 GB e 38 GB. Esses números são apenas os pesos e são um piso, não um requisito — reserve de um quarto a metade a mais por cima para o runtime, as ativações e o cache de chave-valor.
O que preciso para rodar um modelo de 70B como o Llama 3.3?: Em 4 bits os pesos são cerca de 38 GB, então com folga para servir a resposta é uma placa de 64 GB ou mais — uma placa, uma máquina. Em 8 bits os pesos são 70 GB e uma placa de 80 GB passa do limite. Em precisão total de 16 bits nenhuma placa única que instalamos comporta, e vira uma montagem multi-placa que orçamos. A Fig. 3 acima nomeia as placas exatas; os preços estão em servidores dedicados com GPU.
Por que meu modelo carrega mas falha ao servir?: Porque os pesos não são a única coisa na memória da placa. O runtime e seus buffers estão residentes, e cada token em uma conversa deixa uma entrada no cache de chave-valor para não precisar ser recalculado. Esse cache cresce com o comprimento do contexto e novamente com cada requisição servida simultaneamente, então um modelo cujos pesos cabem por pouco comportará aproximadamente uma conversa curta. Dimensione a placa em uma vez e um quarto a uma vez e meia os pesos.
Qual runtime de inferência posso instalar?: Qualquer um. A máquina chega com um sistema operacional limpo e root, e não há serviço de inferência de fornecedor na frente. vLLM é a resposta usual para servir tráfego real porque o batching contínuo permite que uma placa responda muitas requisições ao mesmo tempo. llama.cpp é a resposta usual quando a memória está apertada ou a placa é mais antiga. TGI e SGLang rodam sem alterações. Ollama é o caminho mais curto de uma máquina vazia a um modelo respondendo em uma porta — e vLLM e Ollama respondem em um endpoint compatível com OpenAI, então código cliente existente aponta para sua própria máquina mudando uma URL base. Você fixa o driver, a versão do CUDA ou ROCm e o framework nas versões contra as quais seu código foi testado.
Auto-hospedar um LLM é mais barato que uma API por token?: Depende inteiramente do volume, e o ponto de cruzamento é real: uma API cobra por token e não custa nada ociosa; uma máquina dedicada é um valor mensal fixo e não custa nada a mais ocupada. Tráfego constante, agentes que rodam o dia todo, pipelines em lote e qualquer coisa com requisito de privacidade tendem a sair na frente em hardware próprio; uma carga que dispara dez vezes por dia não. Os valores mensais para fazer essa aritmética estão em servidores dedicados com GPU — esta ficha deliberadamente não precifica nada.
Quantos tokens por segundo vou obter?: Não publicamos um número de tokens por segundo, porque cada número desses depende do modelo, da quantização, do runtime e sua versão, do tamanho do lote, do comprimento do prompt, do comprimento da resposta e da concorrência, e mudar qualquer um move por um múltiplo. O que governa: ler o prompt é limitado por computação e acontece uma vez por requisição; gerar a resposta é limitado por largura de banda de memória porque cada token exige ler os pesos; e o batching amortiza essa leitura entre requisições concorrentes, que é o que torna servir econômico até o cache de chave-valor ficar sem espaço. Pergunte com o modelo, a quantização e a concorrência esperada para uma resposta baseada no que realmente observamos.
A GPU é compartilhada com mais alguém?: Não. Um locatário por máquina física, e a placa é passada diretamente para seu próprio sistema operacional. Não há hipervisor, partição MIG, perfil vGPU nem escalonador de fatia de tempo, então nada mais roda na placa e a latência de inferência não se move por causa do job em lote de outra pessoa.
E se o modelo não couber em uma placa?: Então é uma montagem multi-placa, que é orçada em vez de pedida em um checkout: quantas placas cabem depende da largura física da placa específica e do orçamento de energia do chassi. Duas placas dão a soma da memória delas apenas se o runtime puder dividir o modelo entre ambas, o que todo runtime sério suporta com algum custo em vazão. Mais de uma placa ou máquina cobre como essa montagem se parece.
O fine-tuning precisa de mais memória que servir?: Consideravelmente mais. Servir precisa dos pesos; treinar precisa dos pesos, dos gradientes e do estado do otimizador para cada parâmetro sendo atualizado, todos residentes ao mesmo tempo, mais as ativações mantidas para a passada reversa. Um modelo que serve confortavelmente em uma placa pode ser várias vezes grande demais para fine-tuning completo nela. Métodos eficientes em parâmetros atualizam uma fração pequena dos parâmetros e precisam de uma fração correspondentemente pequena da memória extra, que é por que a maioria do fine-tuning aqui usa um.
Posso rodar uma placa AMD, e o ROCm funciona?: Sim. As peças AMD Instinct estão entre as placas de maior memória que instalamos e frequentemente são o melhor valor por gigabyte, mas sua stack tem que suportar ROCm em vez de CUDA. A maioria dos runtimes de inferência atuais suporta; algumas ferramentas ao redor ainda não. Pergunte antes de pedir e verificaremos contra seu runtime específico em vez de responder em geral.

For the record

Everything on this sheet, as figures.

Card memory is the manufacturers’ published figure; which cards exist is read from the order catalogue when this page was served. No monthly price appears here on purpose — GPU dedicated servers holds every one, against the exact machine it belongs to.

What decides whether a model runs: Card memory, and almost nothing else on the order form. The weights either fit or they do not — a card a couple of gigabytes short does not run slower, it fails to load. Clock speed and core count decide how fast it is once it fits.
How much memory a model needs: Parameters multiplied by bytes per parameter: two bytes each at 16-bit, one at 8-bit, half at 4-bit. That is the WEIGHTS. The runtime, the activations and the key-value cache for the conversation live in the same memory, so budget a quarter to a half again on top before choosing a card.
Largest model on a single card here: 70 billion parameters at 4-bit, with room left to serve. Past that the answer is more than one card in one machine, which is a build we quote rather than a checkout option — multi-GPU and multi-node is the page for it.
Biggest card we fit: RTX PRO 6000 Blackwell 96GB, 96 GB GDDR7 ECC. Card memory figures are the manufacturers' published ones; a card whose figure we could not source is left out of the comparison rather than guessed at.
Which runtime: Yours. The machine arrives with a clean operating system and root, and you install vLLM, llama.cpp, TGI, SGLang, Ollama or anything else, pinned to the version your code was tested against. Nothing upgrades underneath you, and there is no vendor runtime you have to go through.
Throughput: We publish no tokens-per-second figure, deliberately, because we have not measured one under conditions we would be willing to have quoted back at us. What governs it is the card's memory bandwidth while generating, its arithmetic while reading the prompt, and how many requests you batch. Ask with the model, the quantisation and the expected concurrency and we will say what we have actually seen.
Fine-tuning and training: Both are ordinary work here, and both need considerably more memory than serving the same model: gradients and optimiser state sit alongside the weights. A parameter-efficient method needs a fraction of what a full fine-tune does. Tell us the method and the model and we will size it rather than have you find out after delivery.
Tenancy: One tenant per physical machine and the card passed straight through to your operating system. No hypervisor, no MIG partition, no vGPU profile, no time-slicing scheduler, and nobody else's workload on the card. What you measure on the first afternoon is what you keep.
Bandwidth: Unmetered in both directions at every port speed, with no transfer allowance and no egress line on any invoice. Pulling weights down and serving tokens back out costs nothing beyond the port.
What this page does not price: Cards, or anything else. Every card we fit, what each adds per month and what the machine under it costs are on GPU dedicated servers, each figure against the exact machine it belongs to.