Model reference · open weights

NCP_ArchPreview_dolma3_8.9B_Stage1

LLMs ArchSpace-Collection Text gen 1 build Open weights 630 dl/mo

NCP_ArchPreview_dolma3_8.9B_Stage1 is an open-weight language model from ArchSpace-Collection. NCP_ArchPreview_dolma3_8.9B_Stage1 (BF16) weighs 17.9 GB; the smallest configuration that runs it is 2× RTX 4060 Ti 16 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • NCP_ArchPreview_dolma3_8.9B_Stage1 is a latent-space autoregressive language model developed by ArchSpace-Collection for text generation.
  • It features an 8.9B parameter architecture that jointly predicts next tokens and next concepts, with a maximum context length of 8,192 tokens.
  • The model is released under the Apache 2.0 license.

Summary of the ArchSpace-Collection/NCP_ArchPreview_dolma3_8.9B_Stage1 model card, 2026-10-01

What it is

Released byArchSpace-Collection
Released2026-08-27
Parameters8.9B
VRAM17.9 GB for the weights

What it runs on

Memory and cards for NCP_ArchPreview_dolma3_8.9B_Stage1 (BF16)

17.9 GBweights, file size
655 MBcache per 1K tokens
689 MBruntime overhead, at least
8,192 tokenscontext max
CardRequests at onceContext maxMemory
8K each
RTX 3060 12 GB … RTX 4060 Ti 16 GB
2 smaller cards
RTX 3090 24 GB7K23.4 GB
RTX 4090 24 GB7K23.4 GB
RTX 5090 32 GB2all 8K31.0 GB
L40S 48 GB4all 8K44.0 GB
A100 80 GB11all 8K78.2 GB
H100 80 GB10all 8K78.1 GB
RTX PRO 6000 Blackwell 96 GB13all 8K93.8 GB
DGX Spark (GB10) 128 GB unified15all 8K107 GB
H200 141 GB21all 8K138 GB
B200 180 GB28all 8K176 GB
2× RTX 4060 Ti 16 GB
tensor parallel
2all 8K15.4 GB a card
2× L40S 48 GB
tensor parallel
12all 8K44.0 GB a card
4× RTX 4090 24 GB
tensor parallel
13all 8K23.4 GB a card
4× RTX 3090 24 GB
tensor parallel
13all 8K23.4 GB a card
4× RTX 5090 32 GB
tensor parallel
19all 8K31.0 GB a card
Memory needed at each load
Requests at once8K tokens each
123.9 GB
545.4 GB
861.5 GB
16104 GB
32190 GB
64362 GB

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

From the model card

What ArchSpace-Collection says about NCP_ArchPreview_dolma3_8.9B_Stage1

Read the model card

Model collection | Technical report (arXiv) | HF Papers | Training code (coming soon) | Evaluation code

NCP-ArchPreview is a latent-space autoregressive language model developed by The NCP Team at Shanghai AI Lab and LUMIA Lab, Shanghai Jiao Tong University. It learns to predict both the next token and the next concept: a representation spanning a short group of tokens in a learned latent space. Concept predictions guide the token decoder, while generation retains the standard next-token interface.

This is the Stage 1 base-model release, following large-scale pretraining on Dolma 3 Mix. The architecture follows the OLMo 3 7B token-level design and adds a Concept Module, a product-quantized concept vocabulary, and hierarchical residual connections, bringing the total parameter count to approximately 8.94B.

Highlights

  • Joint token and concept learning. Next Concept Prediction (NCP) supplies explicit supervision over a latent sequence at one quarter of the token sequence length.
  • Pretraining at scale. The report describes training on 5.73T Dolma-3 tokens. Stage 1 reaches the OLMo-3-7B final training loss using 51.3% of its training tokens, corresponding to 1.95x convergence in token budget.
  • Stronger Stage 1 results. The report's main evaluation gives an Overall AVG of 49.04, compared with 46.59 for OLMo-3-7B, including +5.99 percentage points on GSM8K and +4.28 points on HumanEval.
  • A learned interface for adaptation. Separate experiments adapt the existing concept codebooks and prediction heads, approximately 17M parameters, while keeping the token backbone fixed.

The convergence comparison measures tokens required to reach a reference loss; it does not measure wall-clock training speed or inference throughput.

Architecture

NCP-ArchPreview processes text through three modules:

  1. A 16-layer Token Encoder produces contextual token states. Mean pooling over each group of four states forms a continuous concept representation.
  2. An 8-layer Concept Module predicts the next concept. Product quantization defines the concept vocabulary using 32 codebooks. Predictions are differentiable weighted combinations of codewords.
  3. A 16-layer Token Decoder receives token states and causally aligned concept predictions, then produces the next-token distribution.

Intra-module residual connections mix states across depths. Cross-module residual connections connect Encoder to Concept Module, Encoder to Decoder, and Concept Module to Decoder. Concept feedback is shifted and repeated at token resolution to preserve causality.

tokens -> Token Encoder -> mean pooling -> Concept Module -> concept prediction
                 |                                                |
                 +--------------> Token Decoder <-----------------+
                                       |
                                next-token logits
PropertyConfiguration
Hugging Face architectureNCPOlmo3ForCausalLM
Total parametersApproximately 8.94B
Encoder / Concept Module / Decoder16 / 8 / 16 causal Transformer layers
Hidden size4,096
FFN intermediate size11,008
Attention heads / KV groups32 / 32
Attention head dimension128
Vocabulary size100,278
Maximum training context8,192 tokens
Token-level attention4,096-token local window; full attention every fourth layer
Position encodingRoPE, base 500,000
Activation / normalizationSwiGLU / RMSNorm; layer-wise QK RMSNorm
Concept compression4 token states per concept
Product quantization32 codebooks, each with 128 codewords of dimension 128
Parameter precisionBF16

Training

Stage 1 uses Dolma 3 Mix and the staged pretraining framework described in the report. The reported 5.73T-token budget describes the large-scale training run; intermediate checkpoints have consumed only the tokens preceding their saved step.

The model is optimized jointly with three objectives:

  • NTP: the standard causal next-token cross-entropy loss.
  • NCP: prediction of the next continuous concept through the learned codebooks, with a stop-gradient target.
  • VQ: fitting codebook entries to the encoder's concept representations.

The report uses Moonlight Muon for matrix-valued parameters and AdamW for embeddings, biases, and other non-Muon parameters. Its default learning rate is 6e-5, with the OLMo-3-style cosine schedule.

Evaluation

Results below describe the report's final Stage 1 model. Scores are percentages and higher is better; deltas are absolute percentage points.

MetricOLMo-3-7B Stage 1NCP-ArchPreview Stage 1Delta
Overall AVG46.5949.04+2.45
MMLU62.2264.80+2.58
GSM8K39.2745.26+5.99
MATH-50012.5214.48+1.96
HumanEval27.1031.38+4.28
MBPP34.5335.91+1.38
ARC-Challenge77.9981.57+3.58
PIQA72.2580.85+8.60
Domain averageOLMo-3-7B Stage 1NCP-ArchPreview Stage 1
MMLU family54.5056.73
Mathematics20.7924.54
Code25.1527.79
Multiple-choice STEM84.4786.93
Multiple-choice non-STEM70.0874.71
GenQA54.2954.76

Likelihood is reported separately in bits per UTF-8 byte (BPB), where lower is better.

Likelihood metricOLMo-3-7B Stage 1NCP-ArchPreview Stage 1
BPB AVG0.8240.811

The complete per-benchmark results are available in Table 1.

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