Spark-X2.6-4B-FP8

Spark-X2.6-4B-FP8

Compact 4.1B-parameter text model in FP8 form for on-device use, with three thinking levels (none, low, high) and English and Chinese support. Aimed at coding and agent work on small hardware.

Made by XHToken on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Spark-X2.6-4B-FP8 is an FP8 copy of Spark-X2.6-4B, a compact general-purpose language model from XHToken meant to run on a device. It has 4.1B parameters and about 4.1 GB of weights. The card says it improves on Spark-X2.5-4B in coding, agent work, long context and reasoning through better post-training.

Who it suits: Developers who want a small model for coding helpers, tool-using agents or chat on limited hardware, in English or Chinese. The card also compares it against other small on-device models such as Qwen3.5-4B and Gemma-E4B.

Title: Who uses it, and how
Industry | Who uses it | How they use it | Example
Software | Developers | Run a coding or tool-using helper on their own machine | Ask it to plan a small code change in several steps
On-device apps | App builders | Ship a compact model with an app and tune how much it reasons | Set a low thinking level for quick replies
Multilingual products | Teams serving English and Chinese users | Answer questions in either language | Ask a factual question in Chinese and read the reply
Research | Model evaluators | Compare a 4B model against larger ones on agent and code tasks | Check how the thinking levels change score and length

Skip it if you need the largest models, since the card's comparisons are with models of similar size and some about 9B.

Where to use it:

• Python with the transformers library
• Windows, macOS or Linux, where the download command works
• A machine with a GPU, since the quickstart lets the library place the model on available devices

Use case | Who | What they get back
Coding help | Developers | Code suggestions and multi-step plans
Agent tasks | Agent builders | Tool-use decisions from a small local model
Quick chat | App builders | Short replies when thinking is set low or off

How to set it up: You need Python and pip. The card asks for one specific transformers version.

• Python and pip
• About 4.1 GB of disk space for the FP8 weights
• The transformers version the card names

1. Install the transformers version the card requires.
2. Download this repository with the Hugging Face tools.
3. Load the model and tokenizer in Python.

pip install transformers==4.57.1
pip install -U huggingface_hub
hf download XHToken/Spark-X2.6-4B-FP8

from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "XHToken/Spark-X2.6-4B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    torch_dtype="auto",
    device_map="auto",
)

How to use it: The card's quickstart names the base repository, so swap in this repository's own name to load the FP8 copy. Then build a chat message and pass it through the chat template, which takes an enable_thinking setting.

Tool | What it does
AutoTokenizer | Loads the tokenizer for the model
AutoModelForCausalLM | Loads the model and places it on available devices
apply_chat_template | Turns a chat message into model input, with the thinking setting
thinking levels | Three settings, none, low and high, trading reasoning for speed and cost

Example: You send the card's own sample question, "What is the capital of Anhui Province?", with thinking turned on. The model reasons first, then returns its answer as text. Turning thinking down gives a shorter reply.

For newcomers and experts: If you are new, this is a small chat model you can run yourself, and the three thinking levels let you choose between quick and careful answers. Start with the quickstart code and one question.

For people in the field, the card says the architecture matches Spark-X2.5-4B and the gains come from post-training. In its own test, going from high to low reasoning cost 1.7 average score points and cut output length by 22.0 percent for the 4B model. The 1.7B model lost 4.0 points and 37.3 percent of length.

Send a chat message
Choose a thinking level
Model reasons, or skips it
Read the text answer

Good to know:

Title: Average output length drop going from high to low reasoning
Spark-X2.6-1.7B: 37.3%
Spark-X2.6-4B: 22%

• License: Apache 2.0
• Cost to run: none named, you use your own hardware
• Data it reaches: it downloads files from Hugging Face, and the quickstart allows the repository's own code to run
• Not for: none named, though the card's results come from its own tests
• The card's benchmark charts are images that this page cannot repeat

On Hugging Face, 14 November 2026

• Task: text generation
• Library: transformers
• Parameters: 4.1B
• Weights: about 4.1 GB in F8_E4M3; about 2.1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 2,048
• Likes: 39
• License: apache-2.0
• Languages: en, zh
• Based on: XHToken/Spark-X2.6-4B
• Fine-tunes: 1
• Tags: transformers, safetensors, spark2_5, text-generation, sparkx2_5, conversational, compressed-tensors

Links

• Model: https://huggingface.co/XHToken/Spark-X2.6-4B-FP8
• Files: https://huggingface.co/XHToken/Spark-X2.6-4B-FP8/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download XHToken/Spark-X2.6-4B-FP8

Then follow the usage in its model card. Nothing in this kit runs by itself.