# Which Recognized Architectures Are Still Pending Implementation in MTPLX?

> Discover which recognized architectures are pending implementation in MTPLX. Learn why deepseek-v4-mtp and step3p5-mtp are not yet supported due to missing custom kernels and MTP runtime infrastructure.

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

---

**MTPLX currently recognizes but does not support two architectures: `deepseek-v4-mtp` and `step3p5-mtp`, both pending due to missing custom kernels and Multi-Token-Predictor (MTP) runtime infrastructure.**

MTPLX maintains a comprehensive registry of neural network architectures it can identify from model configuration files. While the system recognizes these pending architectures and can parse their [`config.json`](https://github.com/youssofal/MTPLX/blob/main/config.json) metadata, they remain in the **recognized-backend-pending** tier because the necessary GPU kernels and quantization pathways have not yet been merged into the codebase.

## Pending Architectures in the Registry

The MTPLX architecture registry tracks implementation status through distinct tiers. Currently, two specific model families are classified as recognized but pending backend support.

### DeepSeek V4 (MTP)

The `deepseek-v4-mtp` architecture represents DeepSeek's V4 model with Multi-Token-Prediction capabilities. MTPLX can identify this architecture from its configuration files and lists it when querying available architectures. However, the server cannot instantiate inference engines for this model type.

### Step-3-P5 (MTP)

Similarly, `step3p5-mtp` identifies the Step-3-P5 model series using MTP-style transformers. Like its DeepSeek counterpart, this architecture appears in registry listings but lacks the necessary dispatch tables for runtime execution.

## Why These Architectures Remain Unsupported

Both pending architectures rely on **novel Multi-Token-Predictor (MTP) implementations** that diverge from standard transformer inference patterns. According to the MTPLX source code, supporting these models requires:

- **Custom GPU kernels** optimized for MTP-style parallel token prediction
- **Conversion pipelines** capable of transforming MTP-specific weight formats
- **Quantization pathways** compatible with the unique tensor layouts used by these architectures

Until these components are integrated into [`mtplx/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/registry.py) and the underlying runtime, MTPLX categorizes these models under the `recognized-backend-pending` tier rather than fully supported implementations.

## How to Check for Pending Architectures

You can discover which architectures are recognized but pending support using either the command-line interface or the Python API.

### Using the CLI

The `mtplx model architectures` command exposes registry metadata in JSON format. Filter for pending implementations using `jq`:

```bash
mtplx model architectures --json | jq '.architectures[] | select(.tier=="recognized-backend-pending")'

```

This returns structured output including the architecture ID and status:

```json
{
  "arch_id": "deepseek-v4-mtp",
  "model_type": "deepseek-v4",
  "tier": "recognized-backend-pending",
  "description": "DeepSeek V4 (MTP) – support pending"
}

```

### Using the Python API

Programmatically query the registry through the `ArchitectureRegistry` class defined in [`mtplx/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/registry.py):

```python
from mtplx.registry import ArchitectureRegistry

registry = ArchitectureRegistry()
pending = [
    arch for arch in registry.all()
    if arch.tier == "recognized-backend-pending"
]

for arch in pending:
    print(f"{arch.arch_id}: {arch.description}")

```

This script outputs the currently pending architectures:

```

deepseek-v4-mtp: DeepSeek V4 (MTP) – support pending
step3p5-mtp: Step‑3‑P5 (MTP) – support pending

```

## Key Source Files

The pending status is defined and validated across three critical files:

- **[`mtplx/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/registry.py)** – Contains the `ArchitectureRegistry` class that maps architecture IDs to implementation tiers, including the `recognized-backend-pending` classification
- **[`mtplx/cli.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/cli.py)** – Implements the `model architectures` command that serializes registry data to JSON
- **[`tests/test_forge_cli.py`](https://github.com/youssofal/MTPLX/blob/main/tests/test_forge_cli.py)** – Validates that `deepseek-v4-mtp` and `step3p5-mtp` report `"pending"` status in CLI output and asserts correct `architecture_id` fields

These files collectively ensure that while MTPLX can identify and catalog these emerging architectures, it accurately reports their unsupported status to prevent runtime errors.

## Summary

- MTPLX recognizes two pending architectures: **`deepseek-v4-mtp`** and **`step3p5-mtp`**
- Both use **Multi-Token-Predictor (MTP)** transformers requiring custom infrastructure not yet available in the runtime
- The **recognized-backend-pending** tier indicates configuration parsing works but inference serving does not
- Check current status via **`mtplx model architectures --json`** or the **`ArchitectureRegistry`** Python class
- Implementation blocked by missing GPU kernels, conversion pipelines, and quantization pathways

## Frequently Asked Questions

### What does "recognized-backend-pending" mean in MTPLX?

This tier indicates that MTPLX can parse the model's configuration files and identify its architecture type, but lacks the backend infrastructure—specifically custom kernels and dispatch tables—to actually serve the model for inference. The model appears in registry listings but cannot be loaded into the serving runtime.

### When will DeepSeek V4 and Step-3-P5 get full support?

The timeline depends on merging the required MTP-style transformer kernels and conversion pipelines into the main codebase. Until these custom GPU implementations and quantization pathways are added to [`mtplx/registry.py`](https://github.com/youssofal/MTPLX/blob/main/mtplx/registry.py) and the underlying execution engine, these architectures remain in pending status.

### How can I verify if my model is supported or pending?

Run `mtplx model architectures --json` and search for your architecture ID. If the `tier` field shows `recognized-backend-pending`, MTPLX recognizes the model but cannot serve it. Fully supported architectures display a different tier status indicating active backend implementation.