By Yishui, from Aofeisi
QbitAI | Official Account QbitAI
I took a walk around iFlytek's annual Global 1024 Developer Festival, and my one takeaway was:
It's bustling — really bustling。
Just look at the pictures to know how hard it was to move two steps forward in the crowd —
Crowds streamed in waves in front of the booths; some people tried things hands-on, others gathered to talk tech and ask about details, and AI showcases and immersive interactions came one after another — the hardcore tech content was maxed out.
However, more worth seeing than the bustle is what these AI products can actually do.
Education, healthcare, finance, translation… iFlytek brought a batch of industry AI products to its booths; how domestic large models enter specific scenarios, adapt to different industries, and actually get used — all of it can be seen concretely here.
Among them, the Spark-X2.5 series of open-source models released this September (the 9th month) has surpassed 2,560,000 cumulative downloads across all channels (entering the global top four in on-device model downloads), and the 4B version once topped Hugging Face's 7-day Trending chart.
"2.56 million downloads, first place on the charts" — the results are indeed impressive, but what I really set my sights on this time is something else:
iFlytek is still taking a path quite different from most players.
Full-stack autonomy and control.
From model training to inference, and then to on-device deployment, iFlytek has been using domestic computing power to support its entire large model system.
How hard this path is, those who know, know...
So the question is:
Without relying on NVIDIA GPUs, how far has this fully domestic system brought Chinese models?
As it happens, iFlytek has just unveiled Spark-X2.6.
So what are we waiting for — let's crank up the intensity! (hehehe.jpg)
Fully domestic, not just about training the model
Before the formal hands-on test, one thing needs to be clarified first:
Although everyone talks about "domestic large models," the domestic computing-power routes involved are actually not quite the same.
Several concepts are often confused together, so this time I simply sorted them out:
△ Image generated by AI
Clearly, iFlytek has chosen the last, harder path:
From model training, reinforcement learning, and continuous iteration to inference and deployment, the entire chain runs on domestic computing platforms.
The core chain contains 0 NVIDIA content — how to put it? It certainly sounds satisfying.
But dig deeper and you'll realize how difficult this really is.
Over the past few years, when the industry discussed fully domestic large models, the first question usually asked was:
Can domestic chips actually train a model at all?
This is indeed the most intuitive part, but once large-scale training actually begins, the difficulties start to emerge.
NVIDIA's advantage lies not only in GPUs, but also in the software ecosystem accumulated over years around CUDA; switching to domestic chips means re-adapting everything from operators and frameworks to multi-card communication.
Once the scale reaches thousands or tens of thousands of cards, training efficiency and cluster stability become new challenges.
A lot of work is hidden behind the models—invisible to ordinary users, yet the most time-consuming and resource-draining.
△ Image generated by AI
I then went through iFlytek's timeline over the past few years and found that its understanding of full-domestic-production has indeed gone several steps beyond "training a model on domestic cards."
This may be related to iFlytek's long-term deep involvement in industry scenarios.
Once a model enters the various hardware devices in hospitals, schools, and enterprise systems, computing power supply, data security, and deployment costs become unavoidable issues, which pushed it onto the full-stack domestic production route earlier than others.
In 2023, iFlytek partnered with Huawei to launch "Feixing-1" (Flying Star One), first building a large-scale domestic computing power foundation.
Later came the hundred-billion-parameter model Spark-V3.5 on domestic computing power, and the deep reasoning model Spark-X1.
This year, Spark-X2.5 open-sourced 4B and 1.7B edge-side models and began drilling into more terminal devices.
By the time it chewed its way to Spark-X2.6, the problem had moved from training to deployment:
Where exactly should the model run?
Recently I happened to read Every's piece "How Codex Happened" and found that OpenAI had also paid tuition on this very question.
OpenAI initially put Codex entirely in the cloud, but ran into walls because of cumbersome environment configuration and the difficulty of intervening in tasks at any time; it later turned to local execution and gradually bridged the two sides.
Why did it end up needing both sides anyway? One look at this table makes it clear:
△ Image generated by AI
The cloud excels in capability, while the edge excels in offline responsiveness, cost, and privacy; in real business, it's hard to bet on only one side.
A more practical solution is to hand the choice over to enterprises:
Which tasks stay local, which go to the cloud, which data can be uploaded, and how many Tokens one is willing to spend per call.
What Spark-X2.6 does is precisely to let the edge and the cloud divide the work on demand:
The task is first judged by the edge-side model, which then selects an appropriate execution path, forming three collaboration modes:。
Simple tasks are completed directly locally; this is"pure edge-side execution";。
Tasks requiring cloud capability are first desensitized on the edge, then handed to the cloud for processing; this is"pure cloud-side execution";。
Tasks requiring cooperation between both sides are desensitized on the edge and then enter"cloud + edge execution"—the cloud can provide guidance while the edge completes the operation, or the edge and the cloud can divide the labor and collaborate to complete the task together.
The idea sounds smooth, but can it really save Tokens and protect privacy?
Well then, let's test it.
Hands-on with Spark-X2.6
Spark-X2.6 is now availableiFlytek Spark Xingchen MaaS platform, using a MoE architecture, with 293B total parameters, about 30B activated per inference, and support for 1M context.
The current API price is at a 40% discount, at 0.9 yuan per million input tokens and 3.6 yuan per million output tokens (about 10% cheaper than Da Fei Yu Gu's price).
Compared with X2.5 released in September, this generation mainly advances three steps forward:
Stronger working capability: X2.6's code and agent capabilities improved overall by about 8 points respectively, and the model's overall strength ranks in the industry's first tier;
Smoother running on domestic computing power: through training and inference architecture optimization, the model's efficiency on domestic training platforms improved 4-fold, and the four-layer KV Cache hit rate reached 95%;
More economical to use: In high-frequency application scenarios, about 60% of tasks saw a reduction in Token consumption.
To sum up, these upgrades still point to that familiar theme:
getting work done.
Since we're testing the ability to get work done, just asking a few questions in a chat box clearly isn't enough.
So this time, I connected Spark-X2.6's API into DeepSeek Harness, letting it directly read and write files, run code, and debug errors based on the run results.
No more preamble—let's first see how big the gap is between it and the current top-tier models.
Recently, whenever Silicon Valley's leading models are released, visual coding has almost become a fixed program—the pelican riding a bicycle and 3D interactive scenes have been repeatedly brought out for demonstration.
Although such tasks can't replace Benchmarks, they have the advantage of being intuitive enough, so for the first challenge, I also arranged the "top-model same test" for Spark-X2.6.
The "top-model same test": testing how strong the model itself is
First, a pelican riding a bicycle.
The prompt uses the minimalist style common in Silicon Valley tests, with no specification of art style, composition, or implementation—just one sentence for the model:
Create an SVG of a pelican riding a bicycle. Save it as pelican.svg in the current directory and preview the result. Do not use external image assets. (Create an SVG of a pelican riding a bicycle, save it to a pelican.svg file in the current directory, preview the result, and do not use external image resources.)
The fewer the requirements, the harder it is to hide the model's own fundamental coding skills and aesthetics.
The image below is the result ofthe model's single-shot output; at first glance, the completeness is indeed not low:
The bicycle structure is complete, and both the foreground and background were filled in.
While the momentum was hot, I added another task:3×3 Rubik's Cube simulator。
This time it's not just about drawing the cube with pure CSS 3D—the six faces have to actually turn, with scrambling and reset functions also included.
The final version was quite hassle-free: no dependencies needed, it runs by opening a single file, you can change the viewing angle by dragging the mouse, and twist it however you like.
If the cube can be twisted, then there has to be a boss-level ultimate challenge:
Building a freely explorable 3D Forbidden City with code。
I threw over an AI-generated prompt, then went to grab a meal while Spark-X2.6 ran in the background.
Unexpectedly, when I came back, it had already delivered a complete website consisting of index.html, style.css, and main.js.
Opening the local server, the red walls and golden tiles spread out along the central axis, and the mouse could freely rotate, zoom, and move the view.
Honestly, it was more complete than I expected.
After this small trial, Spark-X2.6 can't nail every detail in one guess, but it responds quickly to feedback.
This point is actually quite important for Coding Agents.
Anyone who has played with Vibe Coding knows that even with the flagship models of the "OA" two companies, it's unrealistic for a single generation to fully meet expectations.
So for me, what truly affects the experience is whether the model can understand human language and make changes quickly and accurately.
Of course, drawing pictures and building web pages was just a warm-up; next we need to assign it some real work to do.
Putting the 4B model onto your computer — first, let it work on its own
This time, the protagonist has changed toThe just-open-sourced Spark-X2.6-4B。
Don't be fooled by its small 4B parameter count—it supports up to 1M context and more than 200 languages, and is also adapted for Ollama, LM Studio, and others.local running tools, as well as mainstream inference frameworks such as llama.cpp and vLLMmainstream inference frameworks。
To squeeze out as much capability as possible from the 4B model, iFlytek added acapability-awareness mechanismin the post-training stage, letting the model identify its own weak points and then learn in a targeted way from different teacher models.
According to iFlytek's internal evaluation, same-size edge models could independently complete about12.8%of Agent tasks, while Spark-X2.6-4B raised that figure to41.9%。
Whatever—let's see what this mule can really do.
Since my computer only has an AMD integrated GPU with no discrete graphics card, the model relied entirely on CPU inference, so I deployed the Q4 quantized version of Spark-X2.6-4B via Ollama and called the local API from the terminal.
After the model was running successfully, I disconnected the network directly, ensuring that material reading, analysis, and result output all stayed on this computer.
The task I assigned it was to complete a weekly business review for a fictional robotics company.。
Sales weekly reports, customer emails, production schedules, and supply chain records were scattered across different files, with some information even contradicting each other; it needed to cross-check data across files, identify revenue changes, customer conflicts, and delivery risks, and finally list the items awaiting management decisions.
In the end,the model took 6.8 minutes and delivered a complete business review report.。
It distinguished between 25.5 million yuan in sales-caliber revenue and 23.7 million yuan in financially recognized revenue, and identified two key business opportunities and three types of supply chain gaps, with the main conclusions all noting their information sources.
Judging across five dimensions—numerical accuracy, cross-file correlation, risk identification, source tracing, and report completeness—the completion of this task was roughly ninety percent.
To nitpick, it classified an order already in hand as a potential business opportunity, which isn't rigorous enough; however, the relevant facts and amounts were all correct, and after simple human review, it could already serve as reference material for management discussion.
For a 4B model that is fully offline and runs entirely on CPU, this is a pretty solid performance.
Leave complex tasks involving sensitive information to cloud relay
However, edge models ultimately have their limits; for more complex tasks, the cloud still has to step in.
So which tasks stay local, and which tasks are worth sending to the cloud?
To this end, iFlytek introduced acritic-model-based edge-cloud routing collaborative training mechanism。
. Simply put, the same task is run multiple times on both the edge and the cloud, then a critic model compares the results and gives feedback, and through alternating training, the routing decisions are continuously optimized, so the system knows better whether a task should go to the edge, the cloud, or both together.
According to iFlytek's internal evaluation, this mechanism raised the edge-cloud task routing accuracy from81.2%to96.1%。
At 96.1%, for this round of testing I decided to give it a more sensitive material with more complex relationships:
reviewing an industrial visual inspection equipment procurement contract.
The contract was still fictional, but the company name, contact person, phone number, bank account, and contract amount were all included, and multiple linked risks were hidden among the payment, acceptance, data upload, intellectual property, and breach-of-liability clauses.
I first had the local 4B model handle the desensitization.
In 4.3 minutes, all 26 sensitive items in the contract were replaced with placeholders, and the check showed no residual original information.
Only after confirming everything was clean did I reconnect to the network and hand the desensitized contract to the cloud X2.6.
After 70.8 seconds and consuming 7,368 Tokens, it delivered a complete review report, identifying 18 risks and 8 groups of clause conflicts.
Issues like contradictory acceptance criteria, and allowing data to be uploaded directly to the cloud while requiring the supplier to bear unlimited liability—these problems hidden in different clauses were also ferreted out by following the thread.
Afterwards, I disconnected from the internet again, restored the contract information locally, and generated a Word file with item-by-item revision suggestions.
To avoid grading my own work, I threw the full set of materials to Codex for another round of review.
The results showed that the contract received in the cloud contained no original sensitive information, no placeholders were left behind after local restoration, and the contract body and tables were likewise fully preserved.
Only at this point did the entire workflow truly run through:
sensitive information stays local, complex analysis is handed off to the cloud, and after processing it returns to local restoration.
It should be noted that this time I only did a minimal viability verification.
To make the data flow of each step visible, I kept the manual assignment stage in place,while the complete solution supports automatic routing.。
Once it truly enters an enterprise environment, the system can automatically allocate device and cloud tasks based on task difficulty and security requirements, turning this technical solution into a business process that can keep running continuously.
After the training is done, the real test is only beginning.
After a full round of testing, what impressed me most about Spark-X2.6 was the room for choice it leaves for enterprises.
When large models first became hot, enterprises basically used AI by connecting to a cloud API—simple and direct.
But once AI actually entered business operations, things quickly got complicated.
Contracts and customer data are inconvenient to upload, high-frequency calls continuously generate Token costs, and putting everything on-device may fall short on capability for complex tasks.
The value of device-cloud collaboration lies in letting enterprises freely adjust their deployment approach according to their own business.
The Stanford 2026 AI Index shows that 88% of surveyed enterprises worldwide are already using AI, yet the large-scale deployment rate of Agents remains in the single digits across almost all business functions.
This shows that AI has entered enterprises, but core business still has not truly been handed over to Agents.
If we want Agents to move further into core business, beyond model capability, deployment methods also need to change with the scenario.
Hospitals, schools and offices face different constraints, so how to split work between device and cloud naturally has no single answer.
What makes iFlytek interesting is that it has been pondering this question for several years.
From the very start, iFlytek invested enormous time in grinding away at a domestic computing power foundation.
Keep in mind that merely getting a model to run on domestic computing power, solving a series of inference adaptation problems, is already an exhausting ordeal.
But what's even more impressive is that iFlytek not only got it running, but also completed the full training pipeline for large models on this foundation, directly training a large model whose strength benchmarks against international first-tier models.
From "running" to "trained," it's only a few words apart, but the engineering difficulty behind them is on completely different levels.
Looking around, there are really few companies willing to keep filling in the gaps along this full pipeline for the long term.
And the pitfalls iFlytek has stepped into and the experience it has accumulated over the years have now all become its hardest trump cards for building on-device models and device-cloud collaboration.
Of course, starting early is only the beginning; what truly determines how far this route can go is its performance in scaled deployment.
Similar long-term tests are not rare in China's technology industry.
BeiDou took 26 years from project initiation in 1994 to completing its global network in 2020.
The C919 took 16 years from project initiation in 2007 to its first commercial flight in 2023.
From technological breakthrough to actual deployment, there is still a long road in between.
The path toward domestication of Chinese models must likewise pass through this hurdle.
New models and benchmark results are more easily seen, while system adaptation, project delivery and long-term operation rarely enter the discussion in ordinary times.
Model capability can catch up through iteration after iteration, but this kind of inconspicuous accumulation is hard to make up overnight.
The advantage of iFlytek's few years' head start is already showing.
P.S. You can now claim a free allowance of 1 billion Spark-X2.6 Tokens on the Xingchen MaaS platform~
Portal:
https://maas.xfyun.cn/modelService
https://huggingface.co/collections/XHToken/spark-x26
https://github.com/XHToken/Spark-X2.6
https://www.modelscope.cn/collections/XHToken/Spark-X26