Which Recognized Architectures Are Still Pending Implementation in MTPLX?

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 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 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:

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

This returns structured output including the architecture ID and status:

{
  "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:

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 – Contains the ArchitectureRegistry class that maps architecture IDs to implementation tiers, including the recognized-backend-pending classification
• mtplx/cli.py – Implements the model architectures command that serializes registry data to JSON
• 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 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.

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