Mimo V2.6 Pro & Flash (Fully Tested): This is OPEN WEIGHTS!?

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Mimo V2.6 Pro & Flash (Fully Tested): This is OPEN WEIGHTS!? · Channel: AICodeKing · 11:37 · Watch on YouTube

Topics: AI evaluation and benchmarks, Software engineering with AI, AI models, Local and open-source models

Summary

The video compares Xiaomi’s Mimo V2.6 Pro and Flash on eight KingBench 3 tasks using OpenCode, checking both generated files and their behavior. Flash costs about 68% less for standard input and output tokens and scores slightly higher in the initial benchmark: 58/80 versus Pro’s 55.5/80. Both models perform well on the local fine-tuning task, while each shows weaknesses in tasks such as 3D geometry, state handling, and timekeeping. A separate math retest with a higher output limit raises Flash’s score to 64/80, leading the reviewer to favor Flash as the more interesting value option while advising users to inspect its results.

Key points

Both models have open weights under the MIT license, and the video tests them through OpenCode and OpenRouter on eight tasks.
Flash’s listed input and output prices are about 68% lower than Pro’s at the time of the test.
Flash’s elevator simulation delivered all tested passengers correctly; Pro’s passenger counts and reset behavior were unreliable.
Both models built interactive 3D scenes, but their contact lens cases and folding tables had geometry or animation issues.
Flash’s panda-and-burger SVG was preferred over Pro’s, and Flash completed that agent run much faster in this test.
Both games had a bug where pressing R restarts the game even while entering a player name; Flash’s visible timer was more consistent.
Neither original permutation-counting run produced an answer. With a larger output cap, Flash earned partial credit for a valid counting program but did not run it or provide the final number.
Both models received full marks for generating a panda fact dataset, fine-tuning Gemma 2B, and building a working local webpage.
Pro scored better on the wristwatch task; Flash’s digital times were correct, but its analog hand calculations were not.
The initial totals were 55.5/80 for Pro and 58/80 for Flash; with the separate math retest, Flash reached 64/80.

Chapters

Start	Chapter	Summary
00:02	Models, pricing, and test setup	The reviewer introduces the two models, their listed specifications and prices, and the eight-task OpenCode benchmark setup.
02:07	Elevator, 3D objects, and illustration	The video tests the elevator simulation, contact lens case, folding table, and panda SVG, noting differences in behavior, geometry, and run time.
05:47	Game and permutation-counting task	The models’ bow-and-arrow games are assessed, followed by the failed original math attempts and Flash’s partial-credit retest with a larger output cap.
07:53	Fine-tuning and 3D wristwatch	Both models pass the local fine-tuning task, while the wristwatch comparison reveals visibility and timekeeping problems.
09:28	Scores and final verdict	The reviewer compares the final scores, explains how the math retest changes Flash’s total, and concludes that Flash is the more appealing value option in this test.

Quotes

Both have open weights, and Flash costs about a third of Pro for regular input and output tokens. — 00:02

So, both original attempts get zero for this task. — 06:51

Pro gets 55 and 1/2 out of 80, which is about 6.94 out of 10 overall. — 09:28

Flash gets 58 out of 80, which is 7.25 out of 10. — 09:28

Personally, I’d try Flash first for inexpensive prototypes and inspect the result carefully. — 11:04

Concepts and entities

MiMo-V2.6 Pro, MiMo-V2.6 Flash, Xiaomi, OpenRouter, OpenCode, KingBench 3, Gemma 2B, MIT License

Full transcript (original language)

00:02 [music] >> Hi. Welcome to another video. So, Xiaomi has released Mimo V2.6 Pro and Mimo V2.6 Flash, and the pricing immediately caught my attention. Both are available through OpenRouter. Both have open weights, and Flash costs about a third of Pro for regular input and output tokens. But, I wanted to see what that difference actually gets you when you ask them to build things. For this video, I ran both models through OpenCode on all eight tasks in KingBench 3. We have an elevator simulation,

00:33 interactive 3D object, an SVG illustration, a game, a math problem, an actual local fine-tuning task, and a working 3D wristwatch. I reviewed the generated files, opened the visual projects, and checked the behavior before giving each result a score out of 10. And there are some pretty interesting differences here. Flash handled several of the practical tasks better in this run. Pro sometimes spent much longer and still left basic problems in the result. So, let’s get right into it. First, a little context. OpenRouter lists both models with a September 21 release date. And Xiaomi’s

01:04 announcement was updated on September 22. I’m testing them on September 24th. Pro has about 1.02 trillion total parameters with 42 billion active per token. Flash has 309 billion total with 15 billion active. These are mixture of experts models, so the active count is the portion doing the work for each token. Both have a context window of just over a million tokens. Their listing support text, image, audio, and video input with text output, and the weights are released under the MIT license. That’s good to see. Today’s benchmark focuses on their coding and problem-solving behavior through

01:35 OpenCode and OpenRouter. Now, the pricing is pretty aggressive. At the time of this test, OpenRouter lists Pro at 43.5 cents per million input tokens and 87 cents per million output tokens. Flash is 14 cents for input and 28 cents for output. Cached input has a separate lower rate. So, for ordinary input and output, Flash is about 68% cheaper. Your final bill still depends on how much the agent thinks, how many tool calls it makes, and how much context gets reused. For the testing setup, I used Open Code version

02:07 1.18.32 with Open Router as the provider. Each task had its own fresh session and folder. Both models received the same prompt with reasoning enabled. Each task gets a score out of 10. I’ll also show a separate math retest with a larger output budget because that made a difference to Flash’s result. The first task is the elevator simulation. We need three elevators, each taking only one person. You should be able to spawn people on different floors, have them wait for the next available elevator, and see their destination in a tooltip. Pro gives us a recognizable simulation

02:38 with the right basic controls and animated elevators. But, once I started testing the passenger counts, it broke down. In one run, 16 people had been created, yet the completed counter eventually reached 21. The dispatch code treats a reservation for elevator zero as if there is no reservation, which allows duplicate handling of the same passenger. Reset also has a problem. A trip that was already running could finish after the reset and add a passenger to the cleared counter. So, the interface looks like it is working, but the underlying state isn’t reliable. I’m giving Pro seven out of 10 here.

03:09 Flash does much better. I cleared the initial passengers, spawned 12, and all 12 were delivered. I also queued five people on the same floor, and they waited and got picked up properly. The destination tooltip works, too. There are still delayed callbacks that aren’t fully canceled when clearing the simulation, so I wouldn’t call it completely robust, but the main behavior I tested works, and Flash gets nine out of 10. Now, the second task is a 3.js contact lens case with clear left and right labels and caps that open when you

03:40 click them. Both models create interactive 3D scenes, and both let you open the caps independently. But, this is where looking at an object from different angles makes a difference. Pro’s closed caps are positioned partly inside the body, so the closed state doesn’t really look sealed. The labels and the shape are also less convincing than they should be. It gets seven out of 10. Flash has a slightly better interaction, but the geometry underneath is still wrong. There’s solid material where the lens wells should be, and the letters are partly buried in the caps. Opening a cap should reveal a usable

04:12 little container, and that illusion doesn’t hold up here. Flash gets seven and a half out of 10. The third task is a folding table in 3 JS. Move the slider right and it should unfold. Move it left and it should fold with smooth movement through the whole range. Both models get the main interaction working. I check the end points and several positions in between, then move the slider back again. The table changes smoothly, and you can rotate the view to inspect it, but both have mechanical problems in the middle of the animation. Pro’s legs pass through the floor as the table folds. Flash’s inner legs intersect, and the

04:44 table doesn’t stay convincingly supported. So, you can demonstrate the idea, but the motion needs work before it looks physically believable. I’m giving both eight out of 10. Next is the SVG of a panda eating a burger. This sounds simple, but it checks whether the model understands the relationship between the objects, rather than just putting a panda and a burger in the same picture. Flash makes a clean recognizable illustration. The panda and burger both look good, but the burger sits beside the mouth with a visible gap. It looks more like holding food than

05:15 taking a bite. That’s eight out of 10. Pro adds more shading and detail, but the burger becomes an oversized stack with floating gaps between the ingredients. It also hides the mouth, which weakens the eating pose. I prefer Flash’s result here. Pro gets seven out of 10. A static SVG could have earned full marks. Animation wasn’t required. There’s also a big timing difference on this particular task. Flash finished in about 34 seconds, while Pro took about 10 minutes. That’s the total time for those agent runs, including their work and tool use. It isn’t a measurement of raw token speed, and I wouldn’t assume

05:47 the same gap will happen on every prompt. The fifth task is the bow and arrow game. There should be four targets, and completing the challenge faster should move you higher on the leaderboard. Both models produce playable-looking games with aiming, arrows, targets, and a timer. Flash responds to a browser drag, fires an arrow, and registers a target hit. Pro has a more elaborate presentation, although its header timer can freeze while the timer drawn inside the game keeps moving. I also checked the original game logic with control simulations. Those checks completed all four targets, tested misses and repeated hits, and verified that lower completion

06:21 times rank above higher ones. The more serious problem is one both models share. The R key restarts the game even when you’re typing a player name, so entering a name with that letter can throw away a finished run before you save it. It’s a small piece of code with a pretty annoying effect for the person playing. I’m giving Pro eight and a half out of 10, and Flash nine out of 10. Both have a solid core here with a fixable input handling bug. Flash also keeps the visible timer behaving more consistently in the version I tested. Now, the sixth task is the permutation

06:51 counting problem. The correct answer is 20,460, and I independently checked that with an exhaustive program. Neither model received the answer or the checking code. The first runs didn’t deliver an answer. Flash used almost 32,000 reasoning tokens and stopped because it hit the output limit. Pro reached the 20-minute time limit without returning a usable response. So, both original attempts get zero for this task. That means no delivered answer under these conditions, rather than a specific wrong number. There is an important setup detail here. Open code had a default

07:23 output cap of 32,000 tokens, even though these models advertise support for up to 131,072 output tokens. I therefore gave both models one fresh retest with that larger cap, the same prompt, and the same 20-minute time limit. I kept those results separate, so we’re not quietly replacing a failed attempt with a better-looking one. In that retest, Pro still delivered nothing before timeout. Flash wrote a valid counting program and checks on smaller versions support its method, but it never ran the program or gave the final number. That earns six out of 10 in partial

07:53 credit on the retest. Its original attempt remains zero, and I’ll show the effect of replacing that score separately. The seventh task is the local fine-tuning task. Generate a panda fact dataset, fine-tune Gemma 2B, and build a local webpage that generates a panda fact whenever you refresh it. I’ve tried both implementations, and they work flawlessly. Both handle the fine-tuning workflow and deliver the local fact generation app the prompt asks for. Refresh the page and you get a panda fact from the model. So, this is a full pass for both. Pro gets 10 out of 10, and Flash gets 10 out of 10. This is a good result because the task

08:27 goes beyond making an interface. It includes preparing the data, training the model, and connecting it to a working local app. Both models get the job done here. Finally, we have the working 3D wrist watch with smooth hands and two time zones. Pro’s watch opens and runs. The time zone values are correct, the hands show the right time, and you can swap the zones. It also models the case, strap, and a wrist. Unfortunately, the dial markings are hidden under solid case geometry. You can see the hands moving over what looks like a blank metal face. The second hand sweeps

08:58 smoothly, but the minute and hour hands advance in small steps. Pro gets eight out of 10. Flash initially looks more complete with a detailed face and a second zone subdial. But, the digital readouts and analog hands don’t agree. Its code already includes fractional minutes and hours, then adds those fractions again when positioning the hands. The hour hand runs visibly ahead, and the formulas also produce backward jumps at time boundaries. The digital zones themselves are correct, and the second hand moves smoothly, but accurate hands are central to a working watch, and part

09:28 of the lower strap also disappears through the floor. Flash gets six and a half out of 10. This is a good example of why I check the behavior after the first screenshot. So, this is the updated final chart. Pro gets 55 and 1/2 out of 80, which is about 6.94 out of 10 overall. Flash gets 58 out of 80, which is 7.25 out of 10. If we use this separately labeled larger budget math retest, Pro stays at about 6.94, while Flash rises to 64 out of 80 or 8 out of 10. Both totals include full marks for the fine-tuning task. Now, in percentage

10:01 terms, Mimo V2.6 Pro scores 69.38% and Flash scores 72.5% ahead of GPT-5.6, Soul and Muse Spark 1.3 at 71.25% but below GLM-5.2 at 75% With the larger budget math retest, Flash reaches 80%. That matches the previous Opus-4.8 score, puts it above GLM-5.3, Flash at 78.75% and leaves it just below DeepSeek V4.1,

10:33 Flash at 81.25%. So, Flash’s retest result moves it into a much stronger part of the table, while Pro remains at 69.38%. Combined with Flash’s lower pricing, that makes it the more interesting result for me here. Both models earn full marks on local fine-tuning. Flash takes the overall lead through its stronger elevator simulation, illustration, and game, while Pro does better on the watch. If you ask me, Flash is the more interesting value option from these results. It has much lower token prices and I preferred its elevator simulation, panda

11:04 illustration, and game. Pro did better on the watch’s timekeeping, so there are real differences rather than one model winning every task. Personally, I’d try Flash first for inexpensive prototypes and inspect the result carefully. This run doesn’t give me a strong reason to pay extra for Pro by default. Both can produce useful starting points, but the geometry bugs, state bugs, and math results still need attention. Overall, it’s pretty cool. Anyway, let me know your thoughts in the comments. If you like [music] this video, consider donating through the Super Thanks option or becoming a member

11:37 by clicking the join button. Also, [music] give this video a thumbs up and subscribe to my channel. I’ll see you in the next one. Until then, bye. >> [music]