command-a-plus-05-2026-w4a4

Model Summary

Command A+ is an open source model with 25 billion active parameters and 218B total parameters model optimized for agentic, multilingual, and reasoning-heavy tasks with a focus on enterprise performance, while also providing support for vision inputs for processing image inputs.

Developed by: Cohere and Cohere Labs

• Point of Contact: Cohere Labs
• License: Apache 2.0
• Model: command-a-plus-05-2026
• Model Size: 25B active parameters, 218B total parameters
• Context length: 128K input

For more details about this model, please check out our blog post.

You can try out Command A+ before downloading the weights in our hosted Hugging Face Space.

Available quantizations

The following quantizations are available with example minimum GPU requirements

All three quantizations show negligible differences in benchmark quality and performance. Our recommended quantization for most uses is W4A4 which boasts superior speed and latency characteristics alongside a smaller hardware footprint.

For more details, please check out our blog post.

Usage

Transformers

Please install transformers from the source repository that includes the necessary changes for this model.

# pip install transformers
from transformers import AutoTokenizer, AutoModelForImageTextToText

model_id = "CohereLabs/command-a-plus-05-2026-w4a4"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(model_id)

# Format message with the command-a-plus-05-2026-w4a4 chat template
messages = [{"role": "user", "content": "What has keys but can't open locks?"}]
input_ids = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
)

gen_tokens = model.generate(
    input_ids,
    max_new_tokens=4096,
    do_sample=True,
    temperature=0.6,
    top_p=0.95
)

gen_text = tokenizer.decode(gen_tokens[0])
print(gen_text)

As a result, you should get an output that looks like this, where the thinking is generated between the and:

You can also use the model directly using transformers pipeline abstraction:

from transformers import pipeline
import torch

model_id = "CohereLabs/command-a-plus-05-2026-w4a4"
tokenizer = AutoTokenizer.from_pretrained(model_id)

pipe = pipeline(
    "text-generation",
    model=model_id,
    dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "user", "content": "Explain the Transformer architecture"},
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)

outputs = pipe(
    messages,
    max_new_tokens=300,
)
print(outputs[0]["generated_text"][-1])

vLLM -- Special instructions for W4A4

Command A+ w4a4 can only run on vLLM >=0.25.0. W4A4 and accurate response parsing also requires installing Cohere’s melody library.

uv pip install vllm>=0.25.0
uv pip install transformers
uv pip install cohere_melody>=0.9.0

Then the vllm server can be started with the following command:

# This is for B200, adjust tp for your device
vllm serve CohereLabs/command-a-plus-05-2026-w4a4 -tp 1 --tool-call-parser cohere_command4 --reasoning-parser cohere_command4 --enable-auto-tool-choice

We recommend using the following set of sampling parameters for generation: temperature=0.9, top_p=0.95, repetition_penalty=1.04.

Quantization Methodology: Reasoning models pay an outsized quantization tax: long decoding traces compound per-token errors, so naive low-bit conversion typically shows up as visible regressions on hard benchmarks. To mitigate this, we quantize selectively and use distillation to close the residual quality gap. We apply NVFP4 W4A4 quantization (4-bit weights and activations, with two-level scaling) to the MoE experts only. The attention path, i.e., Q/K/V/O projections, the KV cache, and attention compute, is kept at full precision. MoE experts dominate total parameter count, so quantizing them to 4 bits brings the model within the memory budget of a single B200 and accelerates the expert GEMMs that bottleneck short-to-medium-context decode. Furthermore, we use Quantization-Aware Distillation (QAD) in the post-training phase: the quantized student is trained to match the full-precision teacher's output distribution, with fake quantization operators in the forward pass and straight-through estimators on the backward.

Model Details

Input: Text and images.

Output: Model generates text.

Model Architecture: Command A+ is a decoder-only Sparse Mixture-of-Experts Transformer Model. With 25B active parameters and 218B total parameters, it has 128 experts, out of which 8 are active per token, and a single shared expert is applied to all tokens. The attention layers interleave sliding-window attention layers with Rotational Positional Embeddings and global attention layers without positional embeddings in a 3:1 ratio, as first introduced in Command A. The sparse MoE layer is trained in a fully dropless manner and uses a token-choice router. We use additive-bias-based load balancing to encourage balanced token load across all experts, and swap out the softmax router activation function with a normalized sigm