Model reference · open weights

RLVR-0926

LLMs stepfun-ai Text gen 1 build Open weights 131 dl/mo

RLVR-0926 is an open-weight language model from stepfun-ai. RLVR-8B-0926 (BF16) weighs 16.4 GB; the smallest configuration that runs it is 2× RTX 3060 12 GB.

  • RLVR-0926 is an 8.2B parameter text-generation model developed by stepfun-ai and published as stepfun-ai/RLVR-8B-0926.
  • It serves as the initial checkpoint for the PaCoRe framework, which uses parallel coordinated reasoning to scale test-time compute.
  • The model features a context length of 327,680 tokens and is released under the MIT licence.

Summary of the stepfun-ai/RLVR-8B-0926 model card, 2026-10-01

What it is

Released bystepfun-ai
Released2025-12-09
Parameters8.2B
VRAM16.4 GB for the weights

What it runs on

Memory and cards for RLVR-8B-0926 (BF16)

16.4 GBweights, file size
147 MBcache per 1K tokens
753 MBruntime overhead, at least
327,680 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB … RTX 4060 Ti 16 GB
2 smaller cards
———
RTX 3090 24 GB5141K23.4 GB
RTX 4090 24 GB5141K23.4 GB
RTX 5090 32 GB11291K31.0 GB
L40S 48 GB225177K44.0 GB
A100 80 GB5012all 320K78.2 GB
H100 80 GB4611all 320K78.1 GB
RTX PRO 6000 Blackwell 96 GB5914all 320K93.8 GB
DGX Spark (GB10) 128 GB unified7117all 320K107 GB
H200 141 GB9624all 320K138 GB
B200 180 GB12731all 320K176 GB
2× RTX 3060 12 GB
tensor parallel
4135K11.6 GB a card
2× RTX 4060 Ti 16 GB
tensor parallel
10285K15.4 GB a card
2× RTX 4090 24 GB
tensor parallel
235190K23.4 GB a card
2× RTX 3090 24 GB
tensor parallel
235191K23.4 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
118.3 GB22.0 GB
523.2 GB41.3 GB
826.8 GB55.8 GB
1636.5 GB94.4 GB
3255.8 GB172 GB
6494.4 GB326 GB

One card, with vLLM's small-card settings.

From the model card

What stepfun-ai says about RLVR-0926

Read the model card

Read the Paper | Download Models | Training Data | GitHub

📖 Overview

We introduce PaCoRe (Parallel Coordinated Reasoning), a framework that shifts the driver of inference from sequential depth to coordinated parallel breadth, breaking the model context limitation and massively scaling test time compute:

  • Think in Parallel: PaCoRe launches massive parallel exploration trajectories.
  • Coordinate in Multi-rounds: It employs a message-passing architecture to compact these thoughts into concise messages and synthesize them to guide the next round.

Trained via large-scale, outcome-based reinforcement learning, PaCoRe masters the Reasoning Synthesis capabilities required to reconcile diverse parallel insights.

The approach yields strong improvements across diverse domains, and notably pushes reasoning beyond frontier systems in mathematics: an 8B model reaches 94.5% on HMMT 2025, surpassing GPT-5’s 93.2% by scaling effective TTC to roughly two million tokens.

We open-source model checkpoints, training data, and the full inference pipeline to accelerate follow-up work!


Figure 1 | Parallel Coordinated Reasoning (PaCoRe) performance. Left: On HMMT 2025, PaCoRe-8B demonstrates remarkable test-time scaling, yielding steady gains and ultimately surpassing GPT-5. Right: On LiveCodeBench, the RLVR-8B model fails to leverage increased test-time compute, while PaCoRe-8B model effectively unlocks substantial gains as the test-time compute increases.

Figure 2 | PaCoRe Training dynamics. Left panels: The Training Reward and Response Length steadily increase, demonstrating the training stability and effectiveness. Right panels: Evaluation on HMMT 2025 and LiveCodeBench (2408-2505). Performance is reported using single round coordinated reasoning in PaCoRe inference setting with $\vec{K} = [16]$.

🔥 Releases

[2025/12/09] We are excited to release the PaCoRe-8B ecosystem:

🔍 Experiments

Table 1 | For each benchmark, we report accuracy together with total TTC (in thousands). For Low, Medium, and High, we apply the inference trajectory configuration as $\vec{K}=[4]$, $[16]$, and $[32, 4]$ separately.

Key Findings

  • Message Passing Unlocks Scaling. Without compaction, performance flatlines at the context limit. PaCoRe breaks the memory barrier and lets reasoning scale freely.
  • Breadth > Depth. All compute is not equal. Coordinated parallel reasoning delivers far higher returns than extending a single chain.
  • Data as a Force Multiplier. The PaCoRe corpus provides exceptionally valuable supervision—even baseline models see substantial gains when trained on it.

Getting Started 🚀

Installation

First, install the package from the official repository:

pip install -e .

Model Serving

You can directly use vllm serve to serve the model:

vllm serve stepfun-ai/PaCoRe-8B

Inference Example

Next, you can run our example inference code with PaCoRe-low inference setting:

python playground/example_batch_inference_pacore_low_1210.py

🙏 Acknowledgements

  • This work was supported by computing resources and infrastructure provided by StepFun and Tsinghua University.
  • We are built on amazing open source models and data; thanks again!

📜 Citation

@misc{pacore2025,
      title={PaCoRe: Learning to Scale Test-Time Compute with Parallel Coordinated Reasoning},
      author={Jingcheng Hu and Yinmin Zhang and Shijie Shang and Xiaobo Yang and Yue Peng and Zhewei Huang and Hebin Zhou and Xin Wu and Jie Cheng and Fanqi Wan and Xiangwen Kong and Chengyuan Yao and Kaiwen Yan and Ailin Huang and Hongyu Zhou and Qi Han and Zheng Ge and Daxin Jiang and Xiangyu Zhang and Heung-Yeung Shum},
      year={2026},
      eprint={2601.05593},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2601.05593},
}

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms