Spark-X2.6-4B is a new 4-billion-parameter open-weight model from the SparkLLM Team that runs on your own machine, takes up to 1,048,576 tokens of context, and, according to its model card, beats several 9B and 12B models on agent and coding benchmarks. It's Apache 2.0, it's on Hugging Face and Ollama, and you can have it running in one command.
📺 Watch: NEW Spark-X2.6-4B Just Dropped!
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
I covered it in my latest video. This page is the written version: what it is, what the numbers say, where it fits in a business, where it falls short, and how to run it today.
What Spark-X2.6-4B actually is
The SparkLLM Team publishes its models on Hugging Face under the XHToken organisation. Spark-X2.6-4B is the follow-up to Spark-X2.5-4B, and the team says it shipped "a little over a month" after the previous version.
Here's the interesting part. The model card says Spark-X2.6-4B keeps exactly the same architecture as Spark-X2.5-4B. All the gains came from better post-training. Same engine, better tuning.
The headline specs from the card and config file:
- Size: 4B parameters, BF16 weights.
- Licence: Apache 2.0, so you can use it commercially.
- Languages: English and Chinese.
- Context: up to 1,048,576 tokens.
- Attention: a hybrid design, with three sliding-window layers for every one full-attention layer across 36 layers.
- Thinking control: three levels, none, low and high, so you trade quality against speed and cost per request.
- Base model: a separate Spark-X2.6-4B-Base checkpoint is published if you want to fine-tune from scratch.
If you want to plug models like this into a working setup without the trial and error, that's what we do inside the AI Profit Boardroom. You get my Agent OS, a 30-day AI agent roadmap, and daily tutorials as new models like this drop.
Spark-X2.6-4B benchmarks
The model card publishes a full benchmark chart. Everything was run in thinking mode, with Spark-X2.6-4B set to the high thinking level. Some competitor numbers are taken from those models' own published cards, which the SparkLLM Team marks with an asterisk.
| Benchmark | Spark-X2.6-4B | Spark-X2.5-4B | Qwen3.5-9B | Qwen3.5-4B | Gemma4-12B |
|---|---|---|---|---|---|
| Average (all tests) | 63.3 | 52.1 | 49.1 | 43.2 | 47.0 |
| BFCL-V4 (function calling) | 71.8 | 65.1 | 66.1 | 50.3 | 37.4 |
| MCP-Atlas (MCP tool use) | 62.4 | 54.6 | 47.4 | 40.8 | 30.5 |
| BrowseComp (web browsing) | 53.1 | 40.9 | 8.3 | 14.3 | 10.0 |
| SWE Verified (coding) | 62.8 | 41.6 | 53.1 | 38.8 | 44.2 |
| AIME 2026 (maths) | 91.2 | 90.7 | 88.2 | 83.0 | 82.1 |
| AA-LCR v1.1 (long context) | 67.3 | 64.7 | 70.0 | 63.0 | 63.7 |
| MRCR v2, 512k to 1M | 26.0 | 2.9 | 34.3 | 12.2 | not reported |
| GPQA Diamond (science) | 77.1 | 73.7 | 81.7 | 76.2 | 78.8 |
Two things jump out.
First, the agent scores. Function calling, MCP tool use and web browsing are where Spark-X2.6-4B pulls clearly ahead, even against Qwen3.5-9B, a model more than twice its size. For anyone building agents, that's the category that matters most.
Second, the jump from 2.5 to 2.6 on long context. On the hardest 1M-token test in the chart, MRCR v2 at 512k to 1M, the old model scored 2.9. The new one scores 26.0. Same architecture, roughly nine times better at actually using that window.
But look at the rows where it loses. Qwen3.5-9B still wins on AA-LCR, MRCR v2 at the 1M range, and GPQA Diamond. So "beats 9B models" is true on several tests, not all of them. That's exactly what the card says too: "matching or exceeding" larger models "on several benchmarks".
If you want a more practical way to test models on real business tasks rather than lab tests, check out Goldie Bench.
📺 Watch: New Google Gemini Spark is INSANE!
The 1 million token context, explained simply
A token is roughly a chunk of a word. A 1,048,576-token window means you can hand the model a huge pile of text in one go: long contracts, full course transcripts, months of support tickets, entire handbooks.
The catch is memory. The model card says its server examples are configured for the full 1,048,576 tokens, but that setting "requires sufficient device memory", and you should reduce the context length when you need to. So the 1M ceiling is real, but whether you can use all of it depends on your hardware.
The hybrid attention design is what makes this practical. Three out of every four layers only look at a sliding window of nearby text, and one in four looks at everything. That keeps memory use lower than a model where every layer reads the full context.
📺 Watch: New Gemini Spark Update Is INSANE!
Business workflows that make sense
In the video I showed two simple ones.
Use case 1: onboarding new members
Load your welcome docs, FAQs, course outline and community rules into the context. Then let the model answer new member questions, write personalised welcome messages, and point people to the right starting lesson.
Because it runs locally, you're not paying per token every time someone joins. And because of the long context, you can give it the whole onboarding pack, not a trimmed summary.
Use case 2: summarising long documents
Drop in a 200-page report, a full call transcript or a stack of contracts. Ask for a one-page summary, the action items, or the risks buried on page 140.
This is where the long-context improvement from 2.5 to 2.6 really shows up. Older small models would forget the start of the document by the time they reached the end.
Turn the thinking level down to "none" for quick summaries and up to "high" when you need it to reason through something tricky. That one setting does a lot for speed.
Want help mapping workflows like these onto your own business? Book a free AI strategy session and we'll look at where a local model saves you the most time.
I run Hermes daily inside my Agent OS with a separate profile per model, and small local models like this slot in nicely for the cheap, high-volume jobs. If you're setting that up, my Hermes Agent Step 5 walkthrough and the Agent OS guide show how the pieces connect.
Limits and benchmark caveats
- Self-reported scores. Every number in the table comes from the SparkLLM Team's own model card. Independent testing will tell the full story.
- Two in-house benchmarks. SWebBench and PAgentBench are internal tests the team built. The card says they'll be open-sourced "soon". Until then, nobody else can rerun them.
- Thinking on high. All scores were measured at the high thinking level. If you run it at "none" for speed, expect lower results.
- Not top on everything. Qwen3.5-9B still wins on some long-context and science tests.
- Two languages. The card lists English and Chinese only.
- Memory for full context. No minimum hardware spec is listed, and the full 1M window needs plenty of device memory.
- Custom code. The Transformers route needs trust_remote_code set to True, because it uses its own model code.
On hardware, the card's speed charts were measured on an RTX 4090 and on a Mac M5 Pro with a 16-core GPU, at context lengths from 4K up to 256K. The team says inference efficiency is on par with or better than Qwen3.5-4B and Gemma-E4B. Supported targets include NVIDIA GPUs, Ascend NPUs, Apple silicon and Linux CPUs.
If coding is your main use case, compare it against a dedicated option too. I covered one in my Flint local coding model breakdown.
How to run Spark-X2.6-4B
The easiest route is Ollama. You need Ollama v0.34.1 or later. Then run:
ollama run SparkLLM/Spark-X2.6-4B
Other options listed on the model card:
- Hugging Face Transformers: install with pip install transformers==4.57.1, then load XHToken/Spark-X2.6-4B with trust_remote_code set to True.
- llama.cpp: build b10828 or later has native support. Run llama serve -m /path/to/Spark-X2.6-4B-GGUF for an OpenAI-compatible server.
- LM Studio: version 0.4.0 or later. Search "Spark-X2.6", download, and chat, or use lms chat spark-x2.6 from the command line.
- SGLang and vLLM: for serving at scale, with the full 1,048,576-token context option. vLLM uses the Spark plugin from the XHToken GitHub.
- Apple silicon: the team's Spark-MLX-LLM repo on GitHub runs it with MLX.
- Fine-tuning: the team recommends its LlamaFactory fork on GitHub.
The card recommends temperature 1.0 and top_p 0.95. Thinking is switched on by default. To turn it off for a single request, set enable_thinking to false in the chat template arguments.
Not sure which route fits your setup? Grab a free AI strategy session and we'll work it out together.
Why small models keep getting smarter
Spark-X2.6-4B is a good example of where things are heading. The team didn't make the model bigger. They kept the same architecture and improved the training, and the average score went from 52.1 to 63.3 in about a month.
The people who win aren't the ones chasing the biggest model. They're the ones who plug the right model into the right workflow fastest.
If you want to get ahead of that, join the AI Profit Boardroom for $69/mo. 3,400+ members, 4 coaching calls a week, a prompt library, and the full Agent OS.
FAQ
Who made Spark-X2.6-4B?
The SparkLLM Team. The model is published on Hugging Face under the XHToken organisation, and the team posts updates on X as @sparkllm.
Is Spark-X2.6-4B free for commercial use?
Yes. The Spark-X2.6 model series is released under the Apache 2.0 licence, which allows commercial use.
Can I really use the full 1 million token context?
The model supports up to 1,048,576 tokens, but the card says you need enough device memory for it and should lower the context length if you don't have it. For most laptops, a smaller window is the practical choice.
How is it different from Spark-X2.5-4B?
Same architecture, better post-training. Per the model card, it improves coding, agent, long-context, multilingual and reasoning results, with the biggest jumps on tool use, browsing and very long context tests.
Want a plan for putting local models to work in your business? Book a free AI strategy session.
