MTPLX Decode Profiles Explained: Turbo, Sustained, and Burst Modes

MTPLX provides three primary decode profiles—Turbo for maximum speed on quantized models, Sustained for memory-safe long-context decoding, and Burst (performance-cold) for short-context throughput—that configure kernel optimizations, KV-cache handling, and fan control via specific runtime environments.

The youssofal/MTPLX repository implements a flexible runtime profiling system that controls how transformer models decode tokens. These decode profiles in MTPLX manage the trade-off between inference velocity and resource safety by selecting distinct combinations of kernel optimizations, KV-cache repaging strategies, and thermal management settings.

The Three Decode Profiles in MTPLX

MTPLX defines three core runtime configurations in mtplx/profiles.py that determine how the engine processes token generation. Each profile maps to a specific native runtime and sets environment variables that toggle specialized compute kernels.

Turbo Profile

The Turbo profile prioritizes raw decoding velocity for quantized flagship models, such as Qwen 3.8 27B. According to the source code in mtplx/profiles.py (lines 617-629), this profile activates the native_mtp_turbo runtime and enables aggressive optimizations:

• NAX-Verify Kernels: Sets MTPLX_NAX_VERIFY=1 for accelerated verification loops
• Compiled Verification: Enables MTPLX_COMPILED_VERIFY=1 for 4-bit quantized models
• Packed GQA SDPA: Activates MTPLX_GQA_PACKED_SDPA=1 for fast scaled dot-product attention on grouped-query attention architectures

This configuration maximizes throughput on compatible hardware but assumes the model fits within aggressive memory layouts.

Sustained Profile

The Sustained profile serves as the default for most models and focuses on memory-safe, long-context decoding. Implemented in mtplx/profiles.py (lines 699-713), it utilizes the native_mtp_sustained runtime with conservative resource management:

• Chunked Pre-fill: Processes input prompts in segments to control peak memory usage
• Repaged KV Decode: Dynamically manages key-value cache pagination during generation
• Conservative Layout: Sets MTPLX_SUSTAINED_PREFILL=1 for stable memory allocation
• Standard Verification: Disables NAX-verify to prioritize correctness over speed

Use this profile when processing contexts exceeding 8K tokens or when running on memory-constrained hardware.

Burst Profile (Performance-Cold)

The Burst profile, exposed to users as performance-cold, targets short-context, high-throughput scenarios where thermal headroom allows fan boosting. Defined in mtplx/profiles.py (lines 681-693), it selects the native_mtp_60_cold runtime:

• Max-Fan Lane: Optimizes for the "max-fan" thermal corridor (the original Burst engine)
• Stock MLX Path: Disables both compiled-verify and NAX-verify, using pure standard MLX kernels
• Context Limitation: Designed specifically for contexts of 8K tokens or fewer
• Thermal Allowance: Permits aggressive fan curves to sustain higher clock speeds

This profile suits batch processing tasks and inference jobs where latency matters more than long-term thermal efficiency.

Selecting a Decode Profile

Command-Line Usage

Map profile names to runtime configurations using the --profile flag. The CLI resolver in mtplx/cli.py (lines 38-44) handles name normalization and alias resolution:

# Fastest decode on quantized 27B models

mtplx start --profile turbo

# Long-context safe decode (default for most models)

mtplx start --profile sustained

# Short-context burst mode (alias for performance-cold)

mtplx start --profile performance-cold

# Or equivalently:

mtplx start --profile burst

The default selection logic, documented in mtplx/cli.py (lines 86-89), automatically selects Turbo for quantized flagship models and Sustained for all other architectures.

Programmatic Configuration

Import profile utilities from mtplx/profiles to inspect or apply configurations within Python:

from mtplx.profiles import apply_profile_env, get_profile, list_profiles

# Apply Turbo profile to current process

apply_profile_env("turbo")

# Inspect active configuration

profile = get_profile("turbo")
print("Environment:", profile.env_dict())

# List available options

for p in list_profiles():
    print(f"{p['name']}: {p['summary']}")

Technical Implementation Details

The profile system centralizes its definitions in mtplx/profiles.py. The PROFILE_CHOICES constant (lines 16-24) enumerates available options, while concrete RuntimeProfile objects instantiate the specific environment variable mappings for each mode:

• Turbo: Lines 617-629 define TURBO_PROFILE with native runtime native_mtp_turbo
• Sustained: Lines 699-713 define SUSTAINED_PROFILE with native_mtp_sustained
• Burst: Lines 681-693 define PERFORMANCE_COLD_PROFILE with native_mtp_60_cold

The CLI entry point in mtplx/cli.py validates user input through resolve_profile_name (lines 38-44) before instantiating the appropriate runtime context.

Summary

• Turbo (mtplx/profiles.py, lines 617-629): Maximum speed for quantized flagships via NAX-verify and compiled verification kernels
• Sustained (mtplx/profiles.py, lines 699-713): Memory-safe default for long contexts using chunked pre-fill and repaged KV caching
• Burst (mtplx/profiles.py, lines 681-693): High-throughput mode for ≤8K contexts using the native_mtp_60_cold runtime and max-fan thermal curves
• Profile selection occurs via --profile flag in CLI or apply_profile_env() in Python, with defaults handled in mtplx/cli.py (lines 86-89)

Frequently Asked Questions

What is the default decode profile in MTPLX?

The default profile depends on the model architecture. According to mtplx/cli.py (lines 86-89), MTPLX automatically selects the Turbo profile when running quantized flagship models (such as Qwen 27B), while defaulting to Sustained for all other model types to ensure memory safety.

What is the difference between Burst and performance-cold?

They are identical configurations. Burst is the conceptual name for the profile that uses the native_mtp_60_cold runtime, while performance-cold is the user-facing CLI alias. Both reference the same PERFORMANCE_COLD_PROFILE object defined at lines 681-693 of mtplx/profiles.py.

Which profile should I use for long-context inference?

Select the Sustained profile for contexts exceeding 8K tokens. This profile enables MTPLX_SUSTAINED_PREFILL=1 and repaged KV-cache management, preventing out-of-memory errors during extended generation sequences that the Turbo or Burst profiles might encounter due to their aggressive memory packing strategies.

How do I verify which profile is active during runtime?

Query the active configuration programmatically using get_profile() from mtplx/profiles, or inspect the process environment for profile-specific variables such as MTPLX_NAX_VERIFY (Turbo) or MTPLX_SUSTAINED_PREFILL (Sustained). The CLI also exposes mtplx profile list to enumerate available options before starting a session.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}