miniTE speeds up RL in NVFP4 on B300: 1.39× over BF16 on Qwen3-30B-A3B

The InfiX.ai team has introduced miniTE, an open framework for training large language models with reinforcement learning in native NVFP4 (W4A4, meaning 4-bit weights and activations). On a single NVIDIA B300 node, the optimized learner processes 33,540 tokens per second. That's 1.39 times faster than BF16 and 1.47 times faster than a naive NVFP4 implementation on Transformer Engine. Long-horizon RL on Qwen3-30B-A3B remains stable throughout, and benchmarks stay close to BF16.

Same weights, different policy

RL for LLMs typically relies on two engines. One samples responses (rollout), the other computes gradients (learner). The algorithm assumes both see the same policy. In practice, token probabilities computed by the two engines diverge even with identical weights. The lower the precision, the sharper the divergence — and training can eventually fall apart.

The authors uncovered an unpleasant truth: matching weights and numerical format isn't enough. Even if both the learner and the rollout engine run in NVFP4, if the order of operations, the scaling scheme, and the kernel design differ, the policies still diverge. This creates a meaningful train-inference gap. The error accumulates step by step and destabilizes RL over a long horizon.

miniTE attacks the problem from two angles: numerical and systemic. The RL objective itself doesn't change. The framework aligns the execution itself rather than patching the training algorithm.

Diagnostics, alignment, and fast kernels

The first part of miniTE is a diagnostic toolkit. It pinpoints where the two engines compute things differently. After alignment, the log-probability gap between training and inference in strict-alignment mode drops to ~1e-8 — a level at which the two implementations can be considered practically the same policy.

The second part is speed. Native W4A4 only makes sense if 4-bit computation is actually faster. The authors optimized NVFP4 kernels, the scaling scheme, and grouped GEMMs. The latter matter for MoE architectures like Qwen3-30B-A3B, where computation is split across many experts. It's precisely the overhead of such operations that often keeps naive FP4 from delivering the expected gains — here it even ran slower than BF16. miniTE beats TE NVFP4 by 1.47× and BF16 by 1.39×.

Key parameters:

• Framework: miniTE, open-source, from the InfiX.ai team (authors: Zhen Li, Mingfa Feng, Yiming Zhang, Yang Yu, Changhai Zhou, Pengxiang Li, Dongkuan Wu, Congkai Xie, Hongxia Yang)
• Format: native NVFP4, W4A4 (4-bit weights and activations)
• Validation model: Qwen3-30B-A3B, long RL experiments
• Hardware: a single NVIDIA B300 node (an 8×B300 configuration is also mentioned in the announcement)
• Learner throughput: 33,540 tokens/s at full update
• Speedup over BF16: 1.39×
• Speedup over TE NVFP4: 1.47×
• Log-prob gap between training and inference: ~1e-8 in strict-alignment mode
• Quality: stable training, benchmarks close to BF16, better than naive TE NVFP4
• Open-sourced: framework, kernels, diagnostics, training configs

What you can take into your own stack

The main practical takeaway applies to anyone running an RL pipeline with separate learner and sampler engines, even outside FP4. If you're lowering precision, check not just the weights themselves but how each engine computes. The log-prob divergence metric between them deserves a place in monitoring right alongside reward and KL.

For teams with B300 hardware, miniTE provides a ready-made starting point: the kernels, diagnostics, and training recipes can be taken and reproduced on your own setup. The 1.39× gain over BF16 was so far measured on a single node and a single model — on larger clusters and other architectures, it will need to be verified separately. But the direction is clear: the bottleneck for low-bit RL is compute consistency between engines, not the data format.

The paper is available on arXiv (2610.23928); details and materials are on the project page at infix.io/research/miniTE.