Open Models Almanac
ModelsQwen3.5-397B-A17B

Alibaba (Qwen)

Qwen3.5-397B-A17B

What Qwen3.5-397B-A17B’s own documents say it is built from — every method with the sentence that describes it.

Parameters
397B / 17B active
Context
256K
Attention
linear hybridGated DeltaNet linear layers + gated full GQA layers
Experts
512 routed + 1 shared, top-10
Input
text, image, video
Licence
Apache 2.0
Released
2026-02-16

Against the consensus recipe

Its documents state 7 of the 18 methods the field agrees on.

The recipe from the overview: the methods the most labs adopt, per stage. A missing one is something its documents do not say, not something the model lacks.
  1. Data curation

  2. Training objective

  3. Model architecture

  4. Optimization

  5. Post-training

  6. Inference & serving

Checked in its code

Its code shows 10 of the 19 architecture features checked — 6 of them are not stated in its documents.

Sources say what a lab chose to describe; the modeling code says what the checkpoint runs. Each feature below was put to a code verifier, and only the config values and source lines it cited that were found in the files are shown, linked to the line.

Read from Hugging Face Transformers (modeling_qwen3_5_moe.py, configuration_qwen3_5_moe.py) and config.json at revision 8472618112, by anthropic/claude-sonnet-5 on 2026-11-07.

FeatureCodeIts documentsVerdict
Grouped-query attention code only in its codenot stated

Full-attention layers project 32 query heads down to 2 KV heads, which are repeated via repeat_kv to match the query heads.

show evidencetext_config.num_attention_heads = 32text_config.num_key_value_heads = 2
self.num_key_value_groups = config.num_attention_heads // config.num_key_value_heads
modeling_qwen3_5_moe.py · L739
self.k_proj = nn.Linear(
            config.hidden_size, config.num_key_value_heads * self.head_dim, bias=config.attention_bias
        )
modeling_qwen3_5_moe.py · L746–748
Multi-head latent attention not in its codenot stated

No kv_lora_rank/q_lora_rank-based latent projection exists; attention uses standard per-head q/k/v projections with GQA instead.

Sliding-window attention not in its codenot stated

There is no sliding_window config key or windowed-mask code; attention is either full or linear (recurrent), not local-window.

Interleaved sliding-window and global attention not in its codenot stated

layer_types interleaves full_attention and linear_attention (not sliding-window) layers, so this is a linear/full hybrid, not…

show evidence

layer_types interleaves full_attention and linear_attention (not sliding-window) layers, so this is a linear/full hybrid, not sliding-window/full.

text_config.layer_types = ["linear_attention", "linear_attention", "linear_attention", "full_attention"…
causal_mask_mapping = {
                "full_attention": create_causal_mask(**mask_kwargs),
                "linear_attention": create_recurrent_attention_mask(**mask_kwargs),
            }
modeling_qwen3_5_moe.py · L1346–1349
Indexer-selected sparse attention (DeepSeek Sparse Attention) documents disagree not in its codeadopted

No index_topk / indexer module is present in the code or config.

Linear-attention or state-space layers alongside full attention code only in its codenot stated

layer_types mixes linear_attention (Gated DeltaNet) layers with full_attention softmax layers in a fixed pattern (every 4th layer is full…

show evidence

layer_types mixes linear_attention (Gated DeltaNet) layers with full_attention softmax layers in a fixed pattern (every 4th layer is full attention).

text_config.layer_types = ["linear_attention", "linear_attention", "linear_attention", "full_attention"…text_config.full_attention_interval = 4
if self.block_type == "linear_attention":
            self.linear_attn = Qwen3_5MoeGatedDeltaNet(config, layer_idx)
        elif self.block_type == "full_attention":
            self.self_attn = Qwen3_5MoeAttention(config, layer_idx)
modeling_qwen3_5_moe.py · L932–935
Gated DeltaNet layers in its codeadopted

Qwen3_5MoeGatedDeltaNet implements the gated delta rule with a decay gate (A_log/dt_bias) and delta-rule state update, used in…

show evidence

Qwen3_5MoeGatedDeltaNet implements the gated delta rule with a decay gate (A_log/dt_bias) and delta-rule state update, used in linear_attention layers.

text_config.linear_num_key_heads = 16text_config.linear_conv_kernel_dim = 4
g = -self.A_log.float().exp() * F.softplus(a.float() + self.dt_bias)
modeling_qwen3_5_moe.py · L602
last_recurrent_state = last_recurrent_state * chunk_decay[:, :, i] + key[:, :, i].transpose(-1, -2) @ v_new
modeling_qwen3_5_moe.py · L406
Mamba-2 layers not in its codenot stated

The linear layers implement Gated DeltaNet, not Mamba-2 SSD blocks; there is no ssm_state_size or mamba_num_heads config, and no…

show the whole verdict

The linear layers implement Gated DeltaNet, not Mamba-2 SSD blocks; there is no ssm_state_size or mamba_num_heads config, and no selective-SSM code.

Learnable attention sink not in its codenot stated

No learned per-head sink logit or extra softmax denominator column appears in the attention code.

Gated attention output in its codeadopted

Attention output is multiplied by a sigmoid gate derived from a chunked q_proj output before the output projection.

show evidencetext_config.attn_output_gate = true
attn_output = attn_output.reshape(*input_shape, -1).contiguous()
        attn_output = attn_output * torch.sigmoid(gate)
modeling_qwen3_5_moe.py · L801–802
QK normalization code only in its codenot stated

Queries and keys in full_attention layers are normalized per head with RMSNorm (q_norm/k_norm) before RoPE and the dot product.

show evidence
self.q_norm = Qwen3_5MoeRMSNorm(self.head_dim, eps=config.rms_norm_eps)  # unlike olmo, only on the head dim!
        self.k_norm = Qwen3_5MoeRMSNorm(
            self.head_dim, eps=config.rms_norm_eps
        )
modeling_qwen3_5_moe.py · L755–758
query_states = self.q_norm(query_states.view(hidden_shape)).transpose(1, 2)
        key_states = self.k_norm(self.k_proj(hidden_states).view(hidden_shape)).transpose(1, 2)
modeling_qwen3_5_moe.py · L776–777
Partial RoPE code only in its codenot stated

partial_rotary_factor of 0.25 restricts RoPE to a quarter of the head dimension, with the remainder passed through unrotated in…

show evidence

partial_rotary_factor of 0.25 restricts RoPE to a quarter of the head dimension, with the remainder passed through unrotated in apply_rotary_pos_emb.

text_config.rope_parameters = {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "defa…
rotary_dim = cos.shape[-1]
    q_rot, q_pass = q[..., :rotary_dim], q[..., rotary_dim:]
    k_rot, k_pass = k[..., :rotary_dim], k[..., rotary_dim:]
modeling_qwen3_5_moe.py · L680–682
YaRN RoPE scaling documents disagree not in its codeadopted

rope_parameters.rope_type is "default", not "yarn", so no YaRN scaling is switched on.

show evidencetext_config.rope_parameters = {"mrope_interleaved": true, "mrope_section": [11, 11, 10], "rope_type": "defa…
Layers without positional encoding (NoPE) not in its codenot stated

All full_attention layers apply rotary embeddings via position_embeddings/apply_rotary_pos_emb; there is no no_rope_layers config or…

show the whole verdict

All full_attention layers apply rotary embeddings via position_embeddings/apply_rotary_pos_emb; there is no no_rope_layers config or per-layer skip of RoPE among attention layers.

Mixture of experts in its codeadopted

Qwen3_5MoeSparseMoeBlock routes tokens to a top-k subset of 512 experts via a learned router (Qwen3_5MoeTopKRouter).

show evidencetext_config.num_experts = 512text_config.num_experts_per_tok = 10
router_top_value, router_indices = torch.topk(router_probs, self.top_k, dim=-1)  # (seq_len, top_k)
modeling_qwen3_5_moe.py · L877
Shared expert code only in its codenot stated

Each MoE block also includes a shared_expert MLP (sized by shared_expert_intermediate_size=1024) applied to every token and gated, added…

show evidence

Each MoE block also includes a shared_expert MLP (sized by shared_expert_intermediate_size=1024) applied to every token and gated, added to the routed-expert output.

text_config.shared_expert_intermediate_size = 1024
self.shared_expert = Qwen3_5MoeMLP(config, intermediate_size=config.shared_expert_intermediate_size)
        self.shared_expert_gate = torch.nn.Linear(config.hidden_size, 1, bias=False)
modeling_qwen3_5_moe.py · L889–890
shared_expert_output = F.sigmoid(self.shared_expert_gate(hidden_states_reshaped)) * shared_expert_output

        expert_output = expert_output + shared_expert_output
modeling_qwen3_5_moe.py · L899–901
Auxiliary-loss-free load balancing (selection bias) not in its codenot stated

The router (Qwen3_5MoeTopKRouter) computes softmax probabilities and top-k directly with no e_score_correction_bias or selection-only bias…

show evidence

The router (Qwen3_5MoeTopKRouter) computes softmax probabilities and top-k directly with no e_score_correction_bias or selection-only bias added to logits.

router_logits = F.linear(hidden_states, self.weight)  # (seq_len, num_experts)
        router_probs = torch.nn.functional.softmax(router_logits, dtype=torch.float, dim=-1)
modeling_qwen3_5_moe.py · L875–876
Multi-token prediction layers in its codeadopted

The text config declares mtp_num_hidden_layers=1, indicating an extra next-next-token prediction module count greater than zero (weights…

show evidence

The text config declares mtp_num_hidden_layers=1, indicating an extra next-next-token prediction module count greater than zero (weights are ignored on load per _keys_to_ignore_on_load_unexpected = [r"^mtp.*"]).

text_config.mtp_num_hidden_layers = 1
_keys_to_ignore_on_load_unexpected = [r"^mtp.*"]
modeling_qwen3_5_moe.py · L994
SwiGLU feed-forward code only in its codenot stated

Both the dense MLP and expert MLPs compute act_fn(gate_proj(x)) * up_proj(x) with hidden_act=silu, i.e. SwiGLU.

show evidencetext_config.hidden_act = "silu"
down_proj = self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
modeling_qwen3_5_moe.py · L820

token mixer 8

softmax attention 2

global attention 1

Full attention with multi-head attention for reliability used

“MiniMax-M2.5 is the only full attention model (see this article) with Multi-Head Attention (MHA) for reliability purposes.”

sliding window attention 1

Dynamic Attention Window Size Training used

“The dynamic attention window size training mechanism is adopted for guaranting balance performance of inference under real-time prefill…”

sparse attention 1

DeepSeek Sparse Attention core

“DeepSeek Sparse Attention”

linear attention & state space 4

Linear attention core

“integrates a linear attention mechanism with a sparse mixture-of-experts model”

gated delta network 3

Gated DeltaNet core

“Gated DeltaNet:- Number of Linear Attention Heads: 64 for V and 16 for QK”

Gated DeltaNet–sparse Mixture-of-Experts hybrid core

“Gated Delta Networks combined with sparse Mixture-of-Experts deliver high-throughput inference with minimal latency and cost overhead.”

Gated attention with reduced KV heads core

“Number of Attention Heads: 32 for Q and 2 for KV”

hybrid layer stacking 1

Gated DeltaNet and full attention core

“Gated Delta Networks combined with sparse Mixture-of-Experts deliver high-throughput inference with minimal latency and cost overhead.”

channel mixer 5

mixture of experts 5

Mixture of experts core

“integrates a linear attention mechanism with a sparse mixture-of-experts model”

Sparse expert activation core

“activates only 17 billion of its 397 billion total parameters per forward pass”

Hybrid Mixture of Experts core

“The overall backbone adopts a Hybrid Mixture-of-Experts (MoE) design, improving scalability while better balancing capacity and efficiency…”

shared experts 2

MoE with 10 routed and 1 shared expert activated per token core

“Number of Activated Experts: 10 Routed + 1 Shared”

MoE with 8 routed and 1 shared expert activated per token core

“Number of Activated Experts: 8 Routed + 1 Shared”

positional encoding 6

Static YaRN used

“All the notable open-source frameworks implement static YaRN, which means the scaling factor remains constant regardless of input length”

YaRN optional

“YaRN is currently supported by several inference frameworks, e.g., transformers, vllm, ktransformers and sglang.”

RoPE scaling optional

“we recommend using RoPE scaling techniques to handle long texts effectively, e.g., YaRN.”

YaRN scaling-factor selection optional

“It is also recommended to modify the factor as needed. For example, if the typical context length for your application is 524,288 tokens…”

RoPE scaling for context extension (YaRN) optional

“we recommend using RoPE scaling techniques to handle long texts effectively”

YaRN configuration optional

“Modifying the model configuration file”

prediction head 2

Multi-Token Prediction used

“MTP: trained with multi-steps”

Multi-Token Prediction module for residual codebooks used

“To model the residual codebooks, it employs a multi-token prediction (MTP) module, which enables fine-grained modeling and control of…”

multimodal architecture 8

Early-fusion multimodal training core

“Early fusion training on multimodal tokens achieves cross-generational parity with Qwen3 and outperforms Qwen3-VL models across reasoning…”

Thinker–Talker architecture core

“Qwen3.5-Omni builds on the Thinker–Talker architecture introduced in Qwen2.5-Omni (Xu et al., 2025a)”

128-channel mel-spectrogram audio front end used

“we resample the waveform to 16 kHz and convert it into a 128-channel mel-spectrogram using a 25 ms window and a 10 ms hop size.”

Audio Transformer (AuT) used

“We use transformer based audio encoder trained from scratch in attention-encoder-decoder model AuT, as is shown in Figure 3.”

Causal streaming ConvNet codec decoder used

“the generated multi-codebook tokens are converted to waveform by a causal and streaming ConvNet codec decoder.”

Explicit text-string timestamps used

“we prepend each video or audio-video temporal patch with an explicit timestamp represented as a formatted text string in seconds, allowing…”

RVQ-based speech representation used

“Qwen3.5-Omni adopts the RVQ-based speech representation introduced in Qwen3-Omni (Xu et al., 2025b), which substantially improves…”

Video preprocessor longest-edge configuration optional

“It is recommended to set the longest_edge parameter in the video_preprocessor_config file to 469,762,048 (corresponding to 224k video…”

Not used 1

Temporal-Modality Rotary Position Embedding not used

positional encoding “we apply TM-RoPE to endow the model with temporal awareness. However, we find that directly encoding absolute time through temporal…”

multi-token prediction objective 1

Multi-Token Prediction used

“MTP: trained with multi-steps”

training parallelism 1

Expert parallelism used

“use --language-model-only to skip loading the vision encoder and free up memory for KV cache, and enable Expert Parallelism.”

data mixture & curriculum 1

Three-stage pre-training curriculum used

“The pre-training of Qwen3.5-Omni is structured into three distinct stages.”

tokenization 1

Byte-level byte-pair encoding used

“we use the Qwen3.5 tokenizer (Team, 2026), which adopts byte-level byte-pair encoding with a vocabulary size of 250k (up from 150k)”

filed at the root 2

Scalable RL at Agent Scale core

“Qwen3.5 was trained with reinforcement learning scaled across what the team describes as "million-agent environments with progressively…”

Three-stage Thinker post-training strategy used

“The post-training phase employs a three-stage strategy for the Thinker, designed to preserve the model’s capabilities across all…”

supervised fine-tuning 1

Lightweight speaker fine-tuning used

“we perform lightweight speaker fine-tuning on top of the base model, enabling Qwen3.5-Omni to faithfully capture target speaker…”

reinforcement learning algorithm 3

GSPO used

“we incorporate rule-based rewards and adopt GSPO (Zheng et al., 2025) to further improve overall capability and training stability across…”

Interaction-Aligned RL used

“we introduce Interaction-Aligned RL, a third-stage reinforcement learning procedure aimed at optimizing the model for interaction quality.”

Progressively complex task distributions used

“progressively complex task distributions for robust real-world adaptability”

preference optimization 1

Direct Preference Optimization (DPO) used

“We further align model behavior with human preferences through Direct Preference Optimization (DPO) (Rafailov et al., 2023).”

policy distillation 2

On-Policy Distillation used

“we introduce a second-stage training procedure based on on-policy distillation (OPD), with the goal of distilling the model’s stronger…”

Specialist Distillation used

“we first train a suite of domain-specialized teacher models via independent Supervised Fine-Tuning (SFT) and reinforcement learning (RL).”

rollout & RL infrastructure 1

Asynchronous RL framework for large-scale agent scaffolds and environment orchestration used

“asynchronous RL frameworks supporting massive-scale agent scaffolds and environment orchestration.”

mid-training & continual pretraining 1

Continued pretraining used

“we perform data quality stratification through a dedicated curation pipeline and conduct continual pre-training (CPT) on high-quality…”

decoding strategy 5

Presence penalty tuning used

“For supported frameworks, you can adjust the presence_penaltyparameter between 0 and 2 to reduce endless repetitions.”

MTP-1 speculative decoding used

“For latency-sensitive workloads at low concurrency, enable MTP-1 speculative decoding and disable prefix caching.”

Multi-Token Prediction optional

“--speculative-algo NEXTN --speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4”

NEXTN speculative decoding optional

“--speculative-algo NEXTN --speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4”

Task-specific sampling-parameter presets optional

“We recommend using the following set of sampling parameters for generation”

reasoning control 5

Thinking mode default

“Qwen3.5 models operate in thinking mode by default, generating thinking content signified by thinking... before producing the final…”

Reasoning enabled by default default

“Qwen3.5 models operate in thinking mode by default, generating thinking content”

Disable reasoning via enable_thinking optional

“Add --reasoning-parser qwen3 --default-chat-template-kwargs '{"enable_thinking": false}'to disable reasoning mode via command-line…”

Task- and mode-specific sampling parameters optional

“We suggest using the following sets of sampling parameters depending on the mode and task type:”

Task-appropriate maximum output length optional

“We recommend using an output length of 32,768 tokens for most queries. For benchmarking on highly complex problems, such as those found in…”

KV cache management 4

Chunked prefill used

“we retain the chunked-prefilling mechanism as implemented in Qwen3-Omni and Qwen2.5-Omni, whose audio and vision encoders are capable of…”

Prompt caching used

“average price customers are actually paying after prompt caching”

Language-model-only serving mode used

“use --language-model-only to skip loading the vision encoder and free up memory for KV cache, and enable Expert Parallelism.”

Prefix caching optional

“enable MTP-1 speculative decoding and disable prefix caching.”

inference quantization 2

FP8 used

“We recommend using the official FP8 checkpoint Qwen/Qwen3.5-397B-A17B-FP8 for optimal serving efficiency.”

NVFP4 quantization used

“We recommend using the NVFP4 checkpoint nvidia/Qwen3.5-397B-A17B-NVFP4 for optimal serving efficiency on GB200 nodes.”

serving parallelism 2

Data-parallel vision encoding used

“For multimodal workloads, use --mm-encoder-tp-mode data for data-parallel vision encoding and --mm-processor-cache-type shm for…”

Tensor parallelism optional

“using tensor parallel on 8 GPUs”

context management 2

Excluding prior thinking from multi-turn history default

“In multi-turn conversations, the historical model output should only include the final output part and does not need to include the…”

Context folding used

“most search agents built on our model adopt a simple context-folding strategy(256k): once the cumulative Tool Response length reaches a…”

agentic scaffolding 3

Talker system prompt for voice characteristics used

“we introduce a dedicated system prompt for Talker that specifies target voice characteristics, thereby enabling both zero-shot voice…”

MCP configuration for tool definition optional

“To define the available tools, you can use the MCP configuration file, use the integrated tool of Qwen-Agent, or integrate other tools by…”

Tool calling with the qwen3_coder parser optional

“To enable tool calling, add --enable-auto-tool-choice --tool-call-parser qwen3_coder to the serve command.”

1 more mentioned or evaluated
Discard-all context management evaluated

context management “using the same discard-all strategy as DeepSeek-V3.2 and Kimi K2.5 achieved 78.6”

Not used 1

Qwen3 soft thinking switch not used

reasoning control “Qwen3.5 does not officially support the soft switch of Qwen3, i.e., /thinkand /nothink.”

inference engine 1

vLLM language-model-only serving mode optional

“--language-model-only”

agent product 1

Qwen-Agent used

“We recommend using Qwen-Agent to quickly build Agent applications with Qwen3.5.”

infrastructure service 1

Automatic provider failover and retry used

“automatically retries on the next-best provider when one returns an error”

filed at the root 1

Prompt-based output standardization used

“We recommend using prompts to standardize model outputs when benchmarking.”

evaluation harness 1

JSON answer-format prompting used

“Please show your choice in the answerfield with only the choice letter”

unfiled 25

Gated Attention core

“Gated Attention:- Number of Attention Heads: 32 for Q and 2 for KV”

Adaptive Rate Interleave Alignment (ARIA) core

“ARIA enforces an adaptive rate constraint: for any prefix of the generated sequence, the cumulative speech-to-text token ratio must not…”

Scalable reinforcement learning across million-agent environments core

“Reinforcement learning scaled across million-agent environments with progressively complex task distributions for robust real-world…”

configurable video frame sampling with fps and do_sample_frames default

“By default, `fps=2` and `do_sample_frames=True`.”

OpenAI-compatible API used

“OpenRouter's API is OpenAI-compatible — most SDKs work by just swapping the base URL.”

Adequate max output length setting (32,768 default; 81,920 for hard benchmarks) used

“We recommend using an output length of 32,768 tokens for most queries.”

adequate output length (32,768 tokens default, 81,920 for hard benchmarks) used

“We recommend using an output length of 32,768 tokens for most queries.”

cross-lingual voice cloning used

“Qwen3.5-Omni also supports cross-lingual voice cloning, where the model is required to preserve speaker identity while generating speech…”

custom-voice speech generation used

“the model is able to transfer the target speaker characteristics to all 29 evaluated languages while maintaining stable generation quality”

four-stage Talker training pipeline used

“We employ a four-stage training pipeline for Talker, enabling Qwen3.5-Omni to generate natural and contextually appropriate spoken…”

Mode- and task-specific sampling parameter configuration used

“We suggest using the following sets of sampling parameters depending on the mode and task type”

multilingual speech generation used

“its multilingual speech generation ability generalizes well beyond the public benchmark languages”

recommended sampling parameters for thinking and non-thinking modes used

“We suggest using Temperature=0.6, TopP=0.95, TopK=20, and MinP=0 for thinking mode”

Scalable RL with progressively complex task distributions in million-agent environments used

“Reinforcement learning scaled across million-agent environments with progressively complex task distributions for robust real-world…”

shared-memory caching of preprocessed multimodal inputs used

“For multimodal workloads, use --mm-encoder-tp-mode data for data-parallel vision encoding and --mm-processor-cache-type shm for…”

Step-by-step reasoning with boxed-answer prompt for math benchmarks used

“Include "Please reason step by step, and put your final answer within \boxed{}." in the prompt.”

Configurable video frame sampling (fps/do_sample_frames) during inference optional

“With `do_sample_frames=True`, you can customize the `fps` value to set your desired video sampling rate.”

Longest_edge video-preprocessing configuration for high frame-rate sampling of hour-scale videos optional

“longest_edgeparameter in the video_preprocessor_config file to 469,762,048”

reducing CUDA graph capture size to fit Mamba cache optional

“Reduce --max-cudagraph-capture-size (default is 512).”

request routing modes optional

“OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto…”

Serving Qwen3.5 with Hugging Face Transformers server optional

“Hugging Face Transformers contains a lightweight server which can be used for quick testing and moderate load deployment.”

Serving Qwen3.5 with SGLang optional

“For production workloads or high-throughput scenarios, dedicated serving engines such as SGLang, KTransformers or vLLM are strongly…”

Serving Qwen3.5 with vLLM optional

“vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs.”

setting video preprocessor longest_edge to 469,762,048 for hour-scale video understanding optional

“It is recommended to set the longest_edge parameter in the video_preprocessor_config file to 469,762,048”

1 more mentioned or evaluated
Serving Qwen3.5 with KTransformers mentioned

“KTransformers is a flexible framework for experiencing cutting-edge LLM inference optimizations with CPU-GPU heterogeneous computing.”

Further reading

Picked by hand, not extracted: where to read more, not evidence for anything on this page.

Sources

The curated source list for this model. "not fetched" means the URL is recorded but its text was not read in the current run.

SourceKindPublisherStatus
qwen.ai/blog?id=qwen3.5official blogQwennot fetched
huggingface.co/Qwen/Qwen3.5-397B-A17Bmodel cardQwenread
arxiv.org/abs/2604.15804technical reportQwen Teamread
huggingface.co/Qwen/Qwen3.5-122B-A10Bmodel cardQwenread
huggingface.co/Qwen/Qwen3.5-35B-A3Bmodel cardQwenread
github.com/QwenLM/Qwen3.5code repoQwennot fetched
recipes.vllm.ai/Qwen/Qwen3.5-397B-A17Bvendor docsvLLMread
openrouter.ai/qwen/qwen3.5-397b-a17bvendor docsOpenRouterread
huggingface.co/blog/mlabonne/qwen35third party analysisHugging Face community (mlabonne)read
deeplearning.ai/the-batch/qwen-announces-new-open-weights-flagship-upda…newsThe Batch (DeepLearning.AI)read
lmsys.org/blog/2026-06-15-next-generation-speculative-decoding-dflash-v2vendor docsLMSYSnot fetched
lmsys.org/blog/2026-09-16-nvfp4-kv-cachevendor docsLMSYSnot fetched
↑