FP8 vs INT4 Quantization: Production Quality vs Cost 2026

FP8 vs INT4 Quantization: Production Quality vs Cost 2026

Photo by Markus Spiske on Unsplash

Quick Answer: For production LLM serving in 2026, use FP8 for quality-sensitive workloads (perplexity loss <0.5%, MMLU drop <1%) and INT4 for cost-sensitive workloads (2x memory savings, 40-60% higher throughput). FP8 with H100 achieves ~95-97% of FP16 quality while halving VRAM. INT4 (AWQ/GPTQ) delivers 80-85% throughput of FP8 but at half the VRAM cost. The right choice depends on your model size, hardware, and quality requirements — for most production use cases, FP8 is the new default.

Quantization Formats Overview

FP8 is the 2026 production standard. With Blackwell and Hopper native support, FP8 delivers near-FP16 quality at half the memory. INT4 remains essential for consumer GPU inference (RTX 3090/4090/5090) where memory is the bottleneck.

Quality Benchmarks: FP8 vs INT4 vs INT8 vs FP16

Perplexity (Lower Is Better) — Llama 3.1 70B

Benchmark Scores (70B Models)

Key Quality Insights

Rule of thumb: If you can hear the quality difference, use FP8. If you can't fit the model at FP8, use INT4 AWQ (best quality among 4-bit methods). Never use Q3 for code or math.

Hardware Support: What Runs What

Native Hardware Support

What Runs Where

FP8 Deep Dive: The Production Standard

Why FP8 Wins for Production

FP8 was designed specifically for LLM inference on Hopper and Blackwell architectures. It offers:

• 2x memory density vs FP16 (fit 70B in 80GB H100 instead of needing 2x)
• Near-lossless quality — 0.5-1% benchmark degradation
• Native H100 support — runs at 1.3 PFLOPS (vs 990 TFLOPS for FP16)
• Simplified pipeline — no calibration dataset needed (unlike INT4)

FP8 Formats

For inference, E4M3 is used for both weights and activations.

H100 FP8 Throughput

Photo by Google DeepMind on Pexels

INT4 Deep Dive: Maximum Efficiency

INT4 Methods Compared

AWQ: The Gold Standard for INT4

# AWQ quantization
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "meta-llama/Llama-3.1-8B"
quant_path = "llama-3.1-8b-awq-4bit"

# Load and quantize
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)

# AWQ needs 128 calibration samples
quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM",
}

model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized(quant_path)

INT4 VRAM Savings

INT8: The Middle Ground

INT8 via SmoothQuant is worth considering if your hardware doesn't support FP8 but you need better quality than INT4.

When to use INT8 instead of FP8:

• You're on A100/H100 but want slightly better quality than FP8 (unlikely need)
• You're on RTX 4090 (no FP8 support) and quality matters more than speed
• You need INT8 for a specific deployment pipeline requirement

Quantization Decision Workflow

                     ┌─────────────────────┐
                     │  What hardware do   │
                     │  you have?          │
                     └──────────┬──────────┘
                                │
                    ┌───────────┴───────────┐
                    │                       │
            ┌───────▼───────┐       ┌───────▼───────┐
            │   H100/B200   │       │   Consumer    │
            │    (FP8 OK)   │       │   GPU (No FP8)│
            └───────┬───────┘       └───────┬───────┘
                    │                       │
            ┌───────▼───────┐       ┌───────▼───────┐
            │  Does model   │       │  Does model   │
            │  fit in 80GB? │       │  fit in VRAM? │
            │  (FP8 = 50%)  │       │  (FP16)       │
            └───────┬───────┘       └───────┬───────┘
                    │                       │
         ┌──────────┴──────────┐    ┌──────┴──────┐
         │                     │    │              │
    ┌────▼────┐          ┌────▼┐  ┌─▼─┐   ┌──────▼──────┐
    │  Yes    │          │ No  │  │Fits│   │ Doesn't fit │
    └────┬────┘          └──┬──┘  └──┬─┘   └──────┬──────┘
         │                  │       │              │
    ┌────▼────┐        ┌────▼───┐  │    ┌─────────▼───────┐
    │  FP8    │        │ AWQ   │  │    │ AWQ (INT4) or    │
    │default  │        │(INT4) │  │    │ GGUF Q4_K_M      │
    └─────────┘        └───────┘  │    └─────────────────┘
                                  │
                          ┌───────▼─────────┐
                          │ Quality critical?│
                          │ (code, math,     │
                          │  medical)        │
                          └───────┬─────────┘
                                  │
                    ┌─────────────┴─────────────┐
                    │                           │
                ┌───▼────┐               ┌──────▼──────┐
                │  AWQ   │               │  GGUF Q4 or │
                │ (INT4) │               │  AWQ fine   │
                └────────┘               └─────────────┘

Decision Rules

Real-World Performance Benchmarks

Cost Per Token (H100, 70B Model)

Consumer GPU (RTX 4090, 70B Model)

Consumer GPU (RTX 5090, 70B Model)

Related Reads

• Self-Host LLM Break-Even: When Does It Make Financial Sense?
• AWQ vs GPTQ 4-bit: Quality Tradeoffs for Production
• RTX 5090 vs H100 for AI: 2026 Break-Even Analysis

Key Takeaways

• Use FP8 (E4M3) for production LLM serving on H100/B200/RTX 5090—it delivers ~95-97% of FP16 quality with 2x memory savings and native hardware acceleration (1.3 PFLOPS on H100), requiring no calibration datasets.
• Deploy INT4 (AWQ/GPTQ) only for cost-sensitive or memory-constrained scenarios (e.g., consumer GPUs like RTX 4090/3090), as it sacrifices 2-5% quality (notably on coding/math tasks) but halves VRAM vs FP8 and boosts throughput 40-60%.
• Avoid INT4 for quality-critical workloads (e.g., code generation, medical, or reasoning-heavy tasks)—FP8’s <1% quality loss (vs 2-5% for INT4) justifies its use even when VRAM permits larger models.
• For local inference on mixed CPU/GPU setups (e.g., 24GB VRAM), use GGUF Q4_K_M (or Q3_K_M for 70B models) as the only viable option, accepting 3-5% quality degradation for compatibility.
• On H100, FP8 and INT4 cost per token differ by <15%, but FP8’s superior quality makes it the default choice—reserve INT4 for throughput-optimized or VRAM-limited deployments (e.g., 70B on 24GB GPUs).
• Never use Q3_K_M for code/math tasks—its 5-9% quality loss (vs FP16) is unacceptable for reasoning-heavy applications, though it may suffice for creative writing or chat.