# Which Experimental Native Backends Are Contract-Gated in MTPLX?

> Discover which experimental native backends like Step-3.5 MTP are contract-gated in MTPLX. Learn how the experimental-mtp-cohorts flag controls access to these powerful inference engines.

- Repository: [Youssof Altoukhi/MTPLX](https://github.com/youssofal/MTPLX)
- Tags: deep-dive
- Published: 2026-09-04

---

**MTPLX gates six experimental native backends—including Step‑3.5 MTP, Nemotron‑H, and DeepSeek—behind the `experimental-mtp-cohorts` flag, requiring explicit opt-in before the backend registry exposes them to the inference engine.**

According to the youssofal/MTPLX repository, the inference platform uses a strict contract‑gating mechanism to isolate unstable features from production workloads. Understanding which experimental native backends are contract‑gated in MTPLX helps developers safely evaluate cutting‑edge model architectures that are not yet generally available. These backends are identified by the `support_level` value `"experimental-native-contract-gated"` in the central registry and remain inaccessible until explicitly enabled via command‑line flag or Python API.

## What Are Contract‑Gated Experimental Native Backends?

Contract‑gated backends are native implementations that require users to accept experimental terms before activation. In [`mtplx/backends/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/registry.py), the registry assigns these backends a `support_level` of `"experimental-native-contract-gated"`, which prevents the loader from instantiating them unless the `experimental-mtp-cohorts` flag is active. This design ensures that users explicitly acknowledge the experimental nature of these features, preventing accidental deployment of unfinished backends in production environments.

## Complete List of Contract‑Gated Backends

The following six backends are currently marked as contract‑gated experimental native implementations in the MTPLX source tree:

- **Step‑3.5 MTP** – Implementation in [`mtplx/backends/step3p5_mtp.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/step3p5_mtp.py); registry entry defined around lines 229‑236 of [`registry.py`](https://github.com/youssofal/MTPLX/blob/main/registry.py).
- **Nemotron‑H MTP** – Implementation in [`mtplx/backends/nemotron_h_mtp.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/nemotron_h_mtp.py); registry entry defined around lines 39‑46.
- **MIMO MTP** – Implementation in [`mtplx/backends/mimo_mtp.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/mimo_mtp.py); registry entry defined around lines 39‑46.
- **HY‑V3 MTP** – Implementation in [`mtplx/backends/hy_v3_mtp.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/hy_v3_mtp.py); registry entry defined around lines 52‑59.
- **GLM MTP** – Implementation in [`mtplx/backends/glm_mtp.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/glm_mtp.py); registry entry defined around lines 44‑51.
- **DeepSeek MTP** – Implementation in [`mtplx/backends/deepseek_mtp.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/deepseek_mtp.py); registry entry defined around lines 45‑52.

All entries share the identical `support_level` metadata, causing the registry to reject instantiation attempts unless the experimental cohorts contract is accepted.

## How to Enable Contract‑Gated Backends

You can activate the experimental backends by passing the `--experimental-mtp-cohorts` flag through the CLI or setting the equivalent parameter in Python.

### Command‑Line Interface

Enable all contract‑gated experimental native backends when starting the server:

```bash
mtplx serve --experimental-mtp-cohorts

```

To use a specific gated backend, specify it with the model flag:

```bash
mtplx serve \
  --model step3p5_mtp \
  --experimental-mtp-cohorts

```

### Python API

When invoking the server programmatically through `mtplx.cli`, pass the flag as an argument:

```python
from mtplx.cli import main

# Enable experimental‑mtp‑cohorts for a programmatic run

main(["serve", "--experimental-mtp-cohorts"])

```

For OpenAI‑compatible handler initialization, set the boolean parameter:

```python
from mtplx.server.openai import OpenAIHandler

handler = OpenAIHandler(
    model="nemotron_h_mtp",
    experimental_mtp_cohorts=True   # Activates the contract‑gated experimental path

)

```

## Checking Backend Availability Programmatically

Before attempting to load a model, verify whether the contract‑gated backend is accessible using the `BackendRegistry` class:

```python
from mtplx.backends.registry import BackendRegistry

registry = BackendRegistry()

# Default check returns False for experimental contract‑gated backends

print(registry.is_enabled("deepseek_mtp"))   # → False

# Check with experimental flag returns True when cohorts are enabled

print(registry.is_enabled("deepseek_mtp", experimental=True))  # → True

```

This pattern allows conditional logic in deployment scripts that must handle both stable and experimental backend configurations.

## Summary

- **Six experimental native backends** are contract‑gated in MTPLX: Step‑3.5 MTP, Nemotron‑H MTP, MIMO MTP, HY‑V3 MTP, GLM MTP, and DeepSeek MTP.
- **Registry marker**: Each backend is tagged with `support_level="experimental-native-contract-gated"` in [`mtplx/backends/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/registry.py).
- **Activation method**: Pass `--experimental-mtp-cohorts` via CLI or set `experimental_mtp_cohorts=True` in the Python API.
- **Default behavior**: Without the flag, registry queries return `False` for these backends, and instantiation attempts fall back to stable alternatives or raise an availability error.

## Frequently Asked Questions

### What happens if I try to use a contract‑gated backend without enabling the flag?

The backend registry will block instantiation and return `False` for availability checks. Depending on your configuration, the system either falls back to a stable non‑experimental backend or raises an explicit error indicating that the contract‑gated feature is unavailable until you enable `experimental-mtp-cohorts`.

### Where is the contract‑gating logic defined in the source code?

The gating logic resides in [`mtplx/backends/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/backends/registry.py), which evaluates the `support_level` metadata field and checks for the presence of the experimental cohorts flag. The CLI parser in [`mtplx/cli.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/cli.py) and the OpenAI handler in [`mtplx/server/openai.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/server/openai.py) propagate this flag to the registry during initialization.

### Are contract‑gated backends considered production‑ready?

No. The `experimental-native-contract-gated` designation explicitly marks these backends as unstable and subject to breaking changes. They are intended for testing and evaluation only, and the maintainers require explicit opt‑in via the cohorts flag to acknowledge the experimental status.

### How do I check if a specific backend is enabled in my current session?

Query the `BackendRegistry.is_enabled()` method with the backend name and the `experimental=True` parameter. This returns a boolean indicating whether the contract‑gated backend is currently active based on your session’s flag configuration.