It's the first time in the history of the world.
The big model speeds up, and there's this road!
Last week, Inferact, which was founded by VLLM's former employee Horse, opened up a set of TPU Megakernels (large-scale calculators).
They wrote the 92 MoE layers of the Kimi K3 into the same program and threw them into 16 Google TPUs running on v7:
With speculative decoding, single-user output speeds of 709 tokens/s; the same 16 GB200, running with vLLM, is 452 tokens/s.
Turn off the speculative decoding, and at the same time as 1 to 8, it's also 1.4 to 2 times GB200.
The most striking feature is that the display bandwidth of TPU v7 is 7380GB/s, which is less than GB200, 8000GB/s, according to the paper parameters.
Hardware is not cheap, and writing is a win-win.
There is also a colorful egg, which is a huge set of calculators compiled from zero in less than 90 seconds. Previously, a large model of the same size was compiled on the TPU, and started working for half an hour.
During the same week, domestic progress was also reported.
At AICC 2026, wave information releases the SD200 Ultra super node AI server, which uses a 128-core native AI chip to run the same K3 and extend the token generation time to 5.85 milliseconds.
Their trick is called "super-calculator".
One with a Google TPU, one with a native AI chip, the same week, the same model, that wall between the calculators.
What's even more interesting is that one of the super-alcoholics of wave information is that K3 writes it himself.
The big model speaks slowly.Where's Karla?
Many people think that a large model speaks slowly because it is not computational enough. In fact, most of the time the chips are stuck waiting for data.
Each time the model generates a token, it moves the used parameters from the HBM.
So the reasoning for the speed of the ceiling is often expressed in terms of the bandwidth.
A lot of times, the problem is with "algorithms". Algorithms can be understood as a small program, do a matrix multiplication, do a unification, and do the same thing.
In a traditional logic framework, a token is generated to initiate a long sequence of arithmetic operations, each of which goes back and forth "to move the data back and forth".
According to statistics, K3 single-step reasoning calls for thousands of algorithms.
To put it another way, it's like riding an old-fashioned green leather train from Beijing to Guangzhou, with hundreds of small stations along the way, with each station parked, unloaded, loaded, restarted, two days and two nights away.
In the minutes that the car was parked, the railway track was empty. Instead of the chip, the storage bandwidth was wasted in the blank files that the calculator switched on.
One empty arch, several thousand of them rising up, is the great crater between theoretical speed and real speed.
In the last few years, the company has also been adding craters, CUDA Graphs, PDL technologies that can make the car stop a bit short.
Then the station was removed, the high-speed rail was changed, and a station was built.
The whole model is an algebra.
Inferact's best practice is that since borders are the source of waste, no borders remain.
92 layers are integrated into a kernel, and the program decides whether to run KDA or MLA using two attention mechanisms (K3).
All the layers are in the same program, the top layer is still counting, and the weight of the next layer is already on the way to transport.
This has been achieved thanks to the design of TPU.
The TPU v7 has a high-speed memory (VMEM) on each core chip of 64 MiB, and the program determines how long the data moves in and out.
The GPU's memory on the chip is divided into more than a hundred computing units, each of which can only store more than two hundred KB.
TPU gave a large warehouse, and the key was given to the person who wrote the program.
As for why compilation is so out of sync, Inferact's explanation is realistic:
It turns out that the compiler has to scroll through hundreds of thousands of operations repeatedly to figure out how to arrange and overlay, and now these live, engineers have done the one-time manual.
Note the word "manual", the four authors, all of whom are top reasoning engineers, wrote a giant calculator like this, whose thresholds were scary.
Inferact also left a statement on its blog: There will be more of these kernels written by coding agents.
Writing math is a skill.AI is taking over
It's not a suitcase.
On September 14, DeepSeek's calculator engineer Zheng Zheng sent a lengthy message saying goodbye to his "time for handwritten calculators".
He wrote the main Attention Calculator for DeepSeek V4.1 and is a real-life screwdriver. He predicts that in six months to a year, AI writers will catch up and even outnumber him.
A year ago, his AI assistant was only able to help him find bugs; now he can read the underlying code of CUDA, PTX, SASS and manually tweak it.
He also wrote a firm statement: The better he writes his own calculus, the faster he can be trained and reasoned on new models, and the faster he can be replaced.
The other side of the ocean is on the same track. In April this year, Cursor and Ingrid worked together to optimize 235 CUDA calculators using a set of multi-smart body systems, running down three weeks at an average speed of 38%.
Why is it that the algorithm was first picked up by AI?
Because it has a standard answer: the result is not right, one run knows; how fast, the second clock says.
AI can write, measure and change day and night, and people can't control it.
The Wave of Information has already applied this to K3.
Let K3 optimize for K3, system-level breakdown
In the face of the same Kimi K3, the domestic wave of information is also being integrated into the calculations, while extending the optimization to the entire super node system.
What the two have in common is clear: combining small particles into large ones, reducing the cost of starting and moving data.
Inferact combines the entire decoding process into an algorithm; the grain size of the wave information is relatively small, merging modules such as KDA, gated MLA, MoE to form super-algorithms.
In other words, the two are reducing mid-range parking, but the merger is different in scope.
In the recent AICC 2026, wave information directly illuminated the brain's SD200 Ultra super node AI server.
Its underlying logic is pragmatic: in an objective environment where single-card storage and manufacturing processes are constrained by reality, it is necessary to innovate at the system level if you want to carry 2.8 trillion parameters.
The SD200 Ultra embraces a 3D Hyper Mesh architecture that combines 128 AI chip organizations as a collaborative whole, providing 8TB of unified addressing storage, and 64TB of memory, providing carrying space for model weight and growing KV Cache.
In this way, the front-end model will be able to make full use of the computational and storage resources of multiple chips, supporting the deployment and operation of 10 trillion parameters on a single machine.
And then they did three very stupid things in this basement:
- It's called symmetric memory, and it's called direct memory.
In traditional clusters, data between GPUs must be communicated by the CPU as an intermediary for reporting, scheduling and layering.
It's like neighbors in the same neighborhood closing their doors to each other, and in the past, they didn't have to run a bunch of properties and make a gateway to a neighboring unit.
The SD200 Ultra, using symmetric memory technology, completely unlocks the middle layer, displays unified memory addresses, GPUs direct point-to-point access to remote storage, equivalent to pushing the door into neighbouring homes.
This trick directly pushes the time of the cross-card communication down to 0.69 microseconds, and AllReduce communication time drops 3.5 times!
- Transnational integration and upgrading of Green Peak cars to high-speed rail
After the data pathway is opened, the next three-step optimization of the supercalculator will take place.
The first step is to turn the small algebra into the large algebra, reducing the central suspension.
Specifically, the method is to combine finite-particle arithmetic in modules such as KDA, gated MLA, MoE into superarithmetic arithmetic. As a result, the number of arithmetic arithmetic is reduced to about one-tenth of its original value.
The key is how the data stays in the hands of the chip after the merger.
According to the storage capacity on the chip, the engineer cuts the data into the right size blocks. The results of the first step are calculated as directly as possible in the register or cache on the chip and handed over to the next step to be used.
Just like several jobs connected, half-finished products passed by hand, saving each process from being sent back to the warehouse and folded out. This reduces both the number of times the kernel starts and the cost of re-writing and reading HBMs of intermediate results.
The second step is to integrate communication and computing so that data is moved in sync with computing.
Within the big algorithm, the team is also "in good order". The teams organize the flow lines according to the data block Tile, through asynchronous transport and multi-buffer mechanisms, so that different data are stored at different processing stages.
The current block is being calculated, the next block is moving in ahead, and the blocks that have been calculated are rewriting the results.
The buffer zone switches on and off, and the chip loses some of the data.
- Optimizing K3 with K3, the birth of a super-arithmetic intelligence
The third step is to get K3 to participate in optimizing K3 and turn the optimization into a continuous iterative loop.
The kernel is a deeply fused, man-made handwritten kernel, so complex that it can be tolerated by non-ordinary humans.
The way to wave information is to get K3 to do it itself. They built a "super-algebraic intelligence body" with K3 to spin it in a closed loop of "generating and verifying hydrogen measurement mutations":
K3 first looks at the running image, which steps are equal to the data, which caches aren't full, and has a number in mind; then suggests how to combine the calculations, how to cut the data blocks, how to drain the flow line, and automatically writes a series of candidate supercalculations.
The candidate version passed the accuracy test, then pulled the running score to the actual load. How much delay, how much read-write, how many resources it took, and these numbers were returned to K3 as the basis for the next round of improvements.
Only the correct and indeed faster version will be deployed online.
In the final stage of the closed-loop transformation, the performance of the algorithm directly enters the vertical loop, and the performance of the hard drive is increased by 50% and the efficiency of integrated reasoning is improved by more than 3 times!
At the end of the reporting period, the Kimi K3 generated 5.85 milliseconds of tokens, breaking 170 tokens per second, five times faster than the industry average.
It's the speed of the Token.
The paper surface parameters of the chip are getting closer and closer, and the software and systems are closing the gap:
The boundaries of arithmetic are disappearing, communication and computation are flowing together, and the writing of arithmetic is increasingly handed over to AI.
This is especially true for the country's GDP calculation.
The SD200 Ultra comes with another solution: using system-level compactness, combined with deep optimization of the algorithm layer, super-nodules based on native AI chips can also run models with 2.8 trillion parameters in milliseconds.
The model does not change a word, only the integration of calculators and memory management can be improved several times, faster and cheaper than the next generation of chips.
More profound changes have occurred in people who can afford to buy.
In the past, most AI servers were purchased by professional users, and the key was how many cards, how many networks, how much storage. Now customers come up and ask: How fast can this model run on your machine?
The agent behind the push is Agent. It doesn't matter if you answer slowly for two seconds while chatting. An agent's task is to go through a hundred rounds of "reasoning, tweaking, re-planning, and re-planning" rounds, each one slowly, and the entire link can be slowed by several minutes.
At this point, how many cards there are, how high the peak computing power is, the average user can't even touch.
How many tokens are thrown per second, how long a token will wait, is directly on the experience.
Wave information calls such a requirement "capacity-driven intelligence": to get the most advanced, largest models up and running, and to get past the unsteady problems.
The SD200 Ultra provides space for models with 10 trillion parameters, and according to Wave Information Chief AI Strategist Jun Jun Jun, the top open-source model will reach this level within a year or two. K3 is only the first model to run fast.
So the next time someone brings you "how many cards, how many PCs" and introduces you to an AI server, they might ask you a question:
How fast is the top-of-the-line model generating tokens?
The SD200 Ultra delivered the answer: K3, 5.85 milliseconds one.
The next stop of AI:Write systems, write AI calculations.
This extreme battle of reasoning around K3 reflects the drastic changes that are taking place in the entire AI computing industry.
The main battlefield has been moved from the chip to the system.
In the past two years, the acceleration of reasoning has largely relied on algorithms: quantification, speculative decoding, and compressed KV Cache.
Inferact's TPU, which had a lower storage bandwidth than GB200, also won the race; the wave information relied on supercalculators that increased K3's reasoning performance by more than three times on the same set of hardware.
The same chip, poorly organized, can send several times as much.
The walls will be torn down one by one.
The reasoning is that it is all about moving data and spending time on various "fronts". There is a wall between the arithmetic and the arithmetic, so there is an arithmetic convergence; there is a wall between computation and communication, so there is an arithmetic convergence; there is a wall between the chip and the chip, so there is a unified addressing and display direct connection.
This technique of writing the calculations is being handed over to Agent.
Inferact's giant calculator is still man-made, but they themselves say it's more likely to be programmed by an intelligent organism.
The wave information is getting closer and closer, and K3 is already writing supercalculators for K3.
Algorithms are given to AI, and the biggest change is that customization is cheaper. Previously, it was too expensive for a model to write a set of algorithms by hand.
According to Liu, the Agents era has given the opposite opportunity: to synchronize with specific models, from chips, systems, communications to calculators, so that the reasoning efficiency of the Kimi K3 model keeps getting closer to the limits of the system.
What's even more interesting is that now, once the new model is released, it can use a smart body to write itself a set of proprietary calculators, run them again, test them again, and change them again.
The stronger the model, the better the written calculus; the faster the reasoning, the faster the next round of iteration.
In the second half of the Big Model era, the puzzle is no longer a two-word surprise conversation, but a real solution to a problem, the execution of a task.
Every time an agent's task is dismantled, every tool's automatic call, every long-range logic's self-correction, the reasoning behind Token is wildly burning.
In this productivity-reconstructed race, delay and absorption are not only a matter of experience, but also a direct determinant of whether Agent can complete the closed loop in the real world.
From Silicon Valley's Megakernels to the supercalculators at China's supernodes, the world's top engineers are on a similar path to solving the same problem: how to make each token generate faster and turn limited computing power into more available intelligence.
The efficiency revolution of reasoning has just begun, and this good play is getting better and better.
RoboInd editorial channelResearch, robotics companies and market intelligence for cross-border sourcing.Explore the channel ↗
Share this
End of editorialExplore more from Global Robotics News ↗