# When Does llmfit Report a "Good" Fit Level?

> Discover when llmfit reports a 'Good' fit level. Learn about the 20% memory headroom requirement and how it compares to the 'Perfect' tier for optimal model performance.

- Repository: [Alex Jones/llmfit](https://github.com/AlexsJones/llmfit)
- Tags: how-to-guide
- Published: 2026-08-20

---

**A "Good" fit level in llmfit requires at least 20% memory headroom—meaning available memory must be 1.2× or greater than the model's required memory—while falling short of the "Perfect" tier.**

The `llmfit` crate analyzes whether large language models can run on your hardware by assigning one of four **FitLevel** values: **Perfect**, **Good**, **Marginal**, or **Too Tight**. This article explains exactly when the tool reports **Good** and how the underlying logic works according to the AlexsJones/llmfit source code.

## How llmfit Determines Fit Level

The core decision happens in [`llmfit-core/src/fit.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/fit.rs) inside the `score_fit` function. This function compares three memory figures:

- `mem_required`: Calculated from model size, quantization, and estimated context length
- `mem_available`: VRAM for GPU runs, system RAM for CPU-only paths  
- `recommended`: The vendor's recommended RAM for optimal performance

The function first rejects models that cannot fit at all. For viable models, it branches by **RunMode** to assign the appropriate tier.

## When "Good" Is Reported for GPU and TensorParallel Modes

For **GPU** and **TensorParallel** runs, `score_fit` checks three conditions in order:

1. **Perfect**: `recommended <= mem_available` — the model meets vendor recommendations
2. **Good**: `mem_available >= mem_required * 1.2` — required memory plus 20% slack
3. **Marginal**: Anything tighter than 20% headroom but still fitting

```rust
// llmfit-core/src/fit.rs line 44-78
fn score_fit(mem_required: f64, mem_available: f64,
             recommended: f64, run_mode: RunMode) -> FitLevel {
    if mem_required > mem_available {
        return FitLevel::TooTight;
    }

    match run_mode {
        RunMode::Gpu | RunMode::TensorParallel => {
            if recommended <= mem_available {
                FitLevel::Perfect
            } else if mem_available >= mem_required * 1.2 {
                FitLevel::Good
            } else {
                FitLevel::Marginal
            }
        }
        // ... MoE/CPU branches
    }
}

```

**Key insight**: GPU runs only reach **Good** when they have sufficient headroom but miss the recommended memory threshold. If your GPU exceeds the vendor recommendation, you get **Perfect** instead.

## When "Good" Is Reported for CPU and Offload Modes

**MoE Offload**, **CPU Offload**, and **CPU Only** modes follow a simplified path:

- **Good**: `mem_available >= mem_required * 1.2` (same 20% rule)
- **Marginal**: Anything tighter that still fits

These modes **cannot** achieve **Perfect** regardless of available RAM. As the source comment explains: "Perfect requires GPU acceleration. CPU paths cap at Good."

```rust
// llmfit-core/src/fit.rs
RunMode::MoeOffload |
RunMode::CpuOffload |
RunMode::CpuOnly => {
    if mem_available >= mem_required * 1.2 {
        FitLevel::Good
    } else {
        FitLevel::Marginal
    }
}

```

This design reflects practical reality: even with abundant system RAM, CPU inference lacks the performance characteristics that vendors target with their "recommended" specifications.

## Practical Examples: Checking for "Good" Fit

### Query a Model's Fit Level Programmatically

```rust
// Detect hardware and analyze a 7B model
let system = SystemSpecs::detect();           // queries RAM, GPU, VRAM
let model = LlmModel::from_name("llama-2-7b");
let fit = ModelFit::analyze(&model, &system);

println!("Fit level: {}", fit.fit_text());
// → "Good" when VRAM is 1.2× required but below recommended

```

### Inspect Why a Model Received "Good"

```rust
// Review detailed notes explaining the fit calculation
for note in &fit.notes {
    println!("· {}", note);
}
// Example output: "GPU: model loaded into VRAM"
//                 "VRAM headroom: 23% (Good tier)"

```

### Filter Models by "Good" Fit via CLI

```bash

# Terminal: show only models with Good or better fit

$ llmfit fit --good

```

## The FitLevel Enum Definition

The four-tier system is defined in [`llmfit-core/src/fit.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/fit.rs) at lines 78-83:

```rust
pub enum FitLevel {
    Perfect,  // Recommended memory met on GPU
    Good,     // Fits with headroom (GPU tight, or CPU comfortable)
    Marginal, // Minimum memory met but tight
    TooTight, // Does not fit in available memory
}

```

The `Good` variant specifically covers two scenarios: GPU runs that work but lack recommended memory, and CPU/offload runs with comfortable headroom.

## Summary

- **"Good" requires 20% memory headroom**: `mem_available >= mem_required × 1.2`
- **GPU limitation**: Good only appears when missing the **Perfect** threshold (recommended memory)
- **CPU ceiling**: Offload and CPU-only modes max out at **Good**—no Perfect tier exists
- **Below Good**: Less than 20% headroom drops to **Marginal**; insufficient memory yields **Too Tight**

## Frequently Asked Questions

### What is the exact memory multiplier for "Good" fit in llmfit?

**"Good" requires available memory to be at least 1.2 times the required memory**—a 20% buffer. This multiplier is hardcoded in the `score_fit` function across all run modes in [`llmfit-core/src/fit.rs`](https://github.com/AlexsJones/llmfit/blob/main/llmfit-core/src/fit.rs).

### Can a CPU-only model ever achieve "Perfect" fit?

**No.** According to the source code comments in the [`fit.rs`](https://github.com/AlexsJones/llmfit/blob/main/fit.rs) implementation, "Perfect requires GPU acceleration. CPU paths cap at Good." Even with abundant system RAM, CPU and offload modes cannot exceed the **Good** tier.

### Why did my model show "Marginal" instead of "Good" when it fits in VRAM?

**"Marginal" indicates insufficient headroom.** If your available VRAM is between 100% and 120% of the model's required memory, `llmfit` reports **Marginal** rather than **Good**. The 20% threshold (1.2× multiplier) must be satisfied to advance to the **Good** tier.

### How does quantization affect the "Good" fit calculation?

**Quantization reduces `mem_required`, making "Good" easier to achieve.** The `mem_required` value passed to `score_fit` already accounts for your selected quantization level. Lower-bit quantization decreases memory needs, which can push a **Marginal** fit to **Good** or enable a previously **Too Tight** model to fit.