Xiaomi MiMo V2.6 Pro Explained: Open Weights, Architecture and Benchmarks
A phone and electric-vehicle maker now owns the top spot among open-weights language models on one of the most-watched aggregate leaderboards. MiMo V2.6 Pro, released by Xiaomi on 21 September 2026 under the MIT license, scored 46 on the Artificial Analysis Intelligence Index, the highest figure that index listed for any open-weights model at launch. It is a sparse mixture-of-experts (MoE) model with 1.02 trillion total parameters, 42 billion active per token, and a 1-million-token context window. The weights, a technical report, and the reinforcement learning (RL) environments used to build it are public.
That combination matters because the model is not a research curiosity: it is priced at $0.435 per million input tokens and $0.87 per million output tokens through the API, and the training story Xiaomi tells is about a short, cheap, RL-heavy final stage rather than a giant new pre-training run. Most coverage repeats the headline. This post separates what is disclosed from what is not, works the deployment arithmetic so you can decide between the API and self-hosting, and flags the provenance questions that a procurement team should ask before standardising on it.
What this covers: the MiMo lineage, confirmed specifications, the RL recipe and its reported costs, the benchmark picture and its caveats, access options and illustrative sizing for self-hosting, failure modes, a comparison matrix against open-weights peers, and a practical adoption checklist.
Context and Background
Xiaomi’s MiMo line started small. MiMo-7B arrived on 30 April 2025 as an MIT-licensed 7-billion-parameter reasoning model, pre-trained on roughly 25 trillion tokens and then tuned with RL on about 130,000 math and code problems. The first large step was MiMo-V2-Flash on 17 December 2025: a 309-billion-parameter MoE with 15 billion active parameters, trained on 27 trillion tokens with FP8 mixed precision, and, according to its public description, a hybrid attention design interleaving sliding-window and global attention at a 5:1 ratio. MiMo-V2.5 and V2.5-Pro followed on 22 April 2026 at 310 billion and 1.02 trillion parameters. V2.6 is the September 2026 refresh of that pair. These dates come from the Wikipedia entry for Xiaomi MiMo, cross-checked against launch coverage.
The competitive field is the Chinese open-weights cluster that dominates the top of every open leaderboard in 2026: DeepSeek, Moonshot’s Kimi, Zhipu’s GLM, MiniMax, and Alibaba’s Qwen. If you have followed our coverage of GLM-5.2 and its benchmark profile, MiniMax M3, or DeepSeek V4’s architecture, you will recognise the pattern: sparse MoE, very large total parameter counts, small active counts, and aggressive pricing. What distinguishes MiMo V2.6 Pro is the emphasis on how much of the final capability was bought with post-training RL, and how openly the RL stack was published.
Our earlier piece on the MiMo V2.6 release and its RL stack covers the launch week. This article is the durable reference page: it assumes you want the model’s profile, its limits, and the numbers behind a deployment decision.
One date correction is worth making. Some newsletters dated the story to 24 September because that is when they summarised it. Xiaomi released the weights on 21 September 2026; VentureBeat, Artificial Analysis-derived summaries, and the Wikipedia entry all give that date. For primary reporting, see VentureBeat’s launch article. A caution on sourcing: the Hugging Face model card returned an authorisation error when I tried to fetch it, so every specification below comes from secondary coverage of the release, and anything the coverage does not state is marked as not confirmed.
What MiMo V2.6 Pro Is: Specifications and Design
MiMo V2.6 Pro is a natively omnimodal sparse mixture-of-experts model: 1.02 trillion total parameters with 42 billion active per token, accepting text, image, audio, and video input up to 1 million tokens and producing up to 128,000 output tokens. The weights are MIT-licensed. Xiaomi has not been reported to disclose expert counts or routing details in the sources reviewed here.
Figure 1: The MiMo V2.6 Pro release package, from omnimodal inputs through a sparse expert layer to the open artefacts Xiaomi published.
Figure 1 shows the structure at the level of detail that is actually public. Inputs from four modalities share one model. A router activates a small fraction of the experts for each token, so only about 4.1 percent of the parameters (42 billion of 1.02 trillion) do work on any single forward pass. Around that model sit the artefacts that make the release unusually complete: weights, a technical report, deployment instructions, and the RL environments and code.
Confirmed specifications
The table lists values stated in at least two independent reports of the launch. Items absent from the table were not confirmed in the sources I could fetch.
| Attribute | MiMo V2.6 Pro | MiMo V2.6 Flash |
|---|---|---|
| Release date | 21 September 2026 | 21 September 2026 |
| Total parameters | 1.02 trillion | about 310 billion |
| Active parameters per token | 42 billion | 15 billion |
| Architecture | Sparse MoE, omnimodal | Sparse MoE, omnimodal |
| Context window | 1M tokens | 1M tokens |
| Max output | 128K tokens | 128K tokens |
| License | MIT | MIT |
| API price, uncached input | $0.435 per 1M tokens | $0.14 per 1M tokens |
| API price, output | $0.87 per 1M tokens | $0.28 per 1M tokens |
| API price, cached input | $0.0036 per 1M tokens | $0.0028 per 1M tokens |
Artificial Analysis separately measured an output speed of about 134 tokens per second and a time to first token near 2.15 seconds for the Pro API, as summarised by OrcaRouter’s release analysis. Another summary quotes 44.4 tokens per second for the same model, which illustrates a recurring problem with speed figures: they vary by provider, date, and measurement window. Treat single speed numbers as snapshots.
Not disclosed or not confirmed
Several details that engineers want are not available in the reporting I reviewed. The number of routed and shared experts, the router’s top-k, the exact attention layout for V2.6, the tokenizer and vocabulary size, the pre-training token count for the 1.02-trillion model, and the published weight precision were not confirmed. The V2-Flash generation used a 5:1 sliding-window-to-global attention interleave and FP8 training, and it would be reasonable to expect continuity in the family, but that is an inference about lineage, not a statement about V2.6. If you plan capacity around KV-cache size, read the technical report and model card directly before trusting any figure, including the illustrative ones in this article.
Why the omnimodal claim deserves a footnote
“Natively omnimodal” means the model was trained with image, audio, and video inputs rather than bolting a vision encoder onto a text model afterward. That is the vendor framing repeated by launch coverage. The headline index score, however, measures text-centred reasoning, coding, and agentic tasks, so it says little about how good the visual or audio paths are. The one multimodal figure in Xiaomi’s own table is a visual-coding benchmark, which tests whether the model can produce front-end code from visual specifications. I would not extrapolate from it to general video understanding.
Training: An RL-Heavy Final Stage with Reported Costs
Xiaomi’s central claim about training is that the jump from V2.5-Pro to V2.6-Pro came from a short, large-batch RL run rather than from a new pre-training run. Reported figures put the RL stage at roughly $2.6 million for Pro and about $850,000 for Flash, completing 30 RL steps in a little over five days. Pre-training cost and data are not disclosed in the reporting reviewed.
Figure 2: The reported MiMo V2.6 Pro RL loop, in which asynchronous rollout workers feed a grader and a policy update that is pushed back to the workers.
The loop, step by step
Per the launch coverage, each RL step starts from 1,568 prompts and samples 16 candidate trajectories for each. That is 1,568 times 16, or 25,088 rollouts, which matches the “about 25,000” figure in the reports. Thirty steps therefore touch about 752,000 trajectories, consistent with the roughly 750,000 quoted. Trajectories are long: average sequence lengths of 110,000 to 150,000 tokens are reported, and context reached 1 million tokens during RL. Reported training tokens per step range from 2.7 to 3.7 billion.
The algorithm is described as fully asynchronous Group Relative Policy Optimization (GRPO). GRPO samples a group of responses to the same prompt and uses the group’s own reward statistics as the baseline, which removes the need for a separate value network. “Fully asynchronous” means rollout workers keep generating with a slightly stale policy while the trainer updates, so the expensive accelerators never idle waiting for the slowest long trajectory. At 100,000-plus tokens per trajectory, stragglers dominate wall-clock time, so this design choice is not cosmetic.
Two reward-shaping techniques are named: Groupwise Reward Synthesis (GRS) and Groupwise Advantage Redistribution (GAR). Both operate on relative comparison inside a group instead of an absolute score. The DeepLearning.AI newsletter, The Batch, highlights a related point: grader models were used to judge qualities that unit tests cannot, such as code maintainability. Xiaomi reports that confirmed reward-hacking trajectories were below 2 percent of those audited, a number worth treating as a vendor-reported audit result rather than an independent measurement.
Where the money went
The reported budget split for Pro was about 43.5 percent training compute, 43.8 percent rollout generation, and 12.7 percent grading. Applied to the $2.62 million figure, that is roughly $1.14 million, $1.15 million, and $0.33 million. This is illustrative arithmetic on reported percentages, not a published ledger. The striking part is that generating trajectories costs as much as updating the model. In long-horizon agentic RL, inference dominates, which is why inference-engine efficiency, not just training throughput, sets your RL budget.
Two cautions apply to the headline “trained for $3 million.” First, it is an RL-stage figure. It does not include the pre-training run that produced the base model, nor the earlier research, failed runs, or the engineers. Latent Space’s AINews summary, which carries the $3 million framing, also cites $2.6 million for RL, which shows how the rounding happened. Second, the reports disagree on small details: one says the 30 steps took about 130 hours, another says just over 123 hours, another says under six days; and token totals of 75 billion versus an implied range of roughly 80 to 110 billion across 30 steps appear in different summaries. These are consistent with a run of about five days but not with each other to the hour. Read the technical report for the authoritative numbers.
Training ran on JAX and TPUs according to the AINews summary; the team lead, Fuli Luo, a former DeepSeek researcher, is quoted saying that despite scarce compute the team of several dozen people chose to pursue scaling RL as a single goal. Xiaomi reports shipping the model and report within about a week of the final RL run finishing.
What was released alongside the weights
Xiaomi published RL code and environments: coding and software-engineering recipes, an ARVO environment for reproducing cyber vulnerabilities, a general knowledge-work environment, a web-development visual environment, and music-generation tools. Reports say more than 7,000 RL task environments exist, but also that the underlying task datasets had not been released at launch. A distilled MiMo-V2.6-Distill-Qwen-9B model, trained from RL trajectories, was also listed. If you want to reproduce the work, you have the harness and recipes but not the full data; that is a meaningful difference from a fully open training release. For background on how RL-based post-training relates to older recipes, see our comparison of DPO, RLHF and SFT for alignment.
Capabilities and Benchmarks: What the Numbers Say
On the Artificial Analysis Intelligence Index, MiMo V2.6 Pro scored 46, the top open-weights result at launch and level with xAI’s Grok 4.7. In the coverage I reviewed, it sat above Grok 4.6 at 44, Gemini 3.8 Flash at 41, DeepSeek V4.1 Flash at 39, and DeepSeek V4.1 Pro at 36. Xiaomi’s own agent benchmarks show large gains over V2.5-Pro.
Figure 3: Xiaomi-reported agent benchmark scores for MiMo V2.6 Pro and Flash, with the V2.5-Pro starting points for three tasks.
Independent index versus vendor benchmarks
Keep two classes of evidence apart. The Artificial Analysis Intelligence Index is an independent aggregate of multiple evaluations, run by a third party on the API endpoint. Xiaomi’s agent benchmarks, listed below, are vendor-reported and several are the vendor’s own creations, such as MiMo Code Bench and MiMo Visual Coding. Vendor-built benchmarks are useful to show where the team pointed its RL effort, but they cannot be used to rank the model against others.
| Benchmark (vendor-reported) | V2.6 Pro | V2.6 Flash | V2.5 Pro |
|---|---|---|---|
| DeepSWE v1.1 | 71.9 | 67.9 | 19.0 |
| AutomationBench | 53.1 | 52.3 | 16.0 |
| MiMo Code Bench | 63.2 | 61.2 | 40.4 |
| Terminal Bench 2.1 | 89.9 | 87.6 | not reported here |
| JobBench | 62.0 | 61.2 | not reported here |
| MiMo Visual Coding | 72.3 | 71.5 | not reported here |
| CyberGym | 94.0 | 95.1 | not reported here |
Source for the table: VentureBeat’s launch coverage of Xiaomi’s published results. I have not independently reproduced any of them.
Three observations. First, the Pro-to-Flash gap is small, typically one to four points, and on CyberGym Flash is ahead. If the gap is that thin on your workload, the model with a third of the active parameters and a third of the price deserves a serious look. Second, the V2.5-Pro to V2.6-Pro jump on DeepSWE, from 19.0 to 71.9, is far too large to be explained by anything but a change in what was optimised, in the benchmark version, or in both; the benchmark is labelled v1.1, and I could not verify whether the V2.5 number used the same harness. Third, the Vals Index and a cyber benchmark corroborate strength on agentic and security tasks: The Batch reports Flash at 59.58 percent and Pro at 59.47 percent on the Vals Index, both leading open-weights competitors, and Pro third and Flash first on CyberBench v1.1 at 72.86 and 75.36 percent.
Cost per task, not just price per token
The index also reports cost to run the benchmark suite. Artificial Analysis measured about $0.13 per Intelligence Index task for Pro, according to the AINews and OrcaRouter summaries. That figure combines the low per-token price with the model’s token usage; a model with cheap tokens that thinks for twice as long is not cheaper. The model’s placement on the intelligence-versus-cost Pareto frontier, rather than the raw score alone, is the more decision-relevant claim.
Caveats that apply to every score above
Aggregate indices compress many tasks into one number, and a one-point difference between 46 and 44 is within the range where methodology updates can reorder models. The index version mentioned in the OrcaRouter piece is v4.3.2, and index versions change; a score is only comparable inside one version. Contamination is a standing risk for any public benchmark, and agentic benchmarks with long trajectories are sensitive to harness details such as tool definitions, timeouts, and retry policy. Finally, a model tuned with RL on environments that resemble the evaluation tasks will look better on those benchmarks than on a task the environments never covered. That is not misconduct, but it is the main reason to run your own evaluation before committing.
Access and Deployment: API, Open Weights, and Illustrative Sizing
You can reach MiMo V2.6 Pro two ways: through a hosted API at $0.435 per million uncached input tokens, $0.0036 per million cached input tokens, and $0.87 per million output tokens, or by downloading the MIT-licensed weights and serving them yourself. At launch, reporting indicated only one API provider served the Pro model, which limits failover options. Self-hosting a 1.02-trillion-parameter model needs a multi-GPU node.
Figure 4: Deployment paths for MiMo V2.6 Pro, from a single hosted endpoint to a self-hosted multi-GPU node, with the decision points that separate them.
The API route
The API is the default for most teams. The cached-input price is the striking feature: at $0.0036 per million tokens it is about 99 percent below the uncached rate, so workloads that resend a long stable prefix, which describes most coding agents, pay almost nothing for the prefix after the first call. OrcaRouter computes a blended rate of about $0.18 per million tokens at a 7:2:1 mix of cached input, uncached input, and output. That checks out: 0.7 times $0.0036 plus 0.2 times $0.435 plus 0.1 times $0.87 is about $0.1765.
Here is an illustrative agent call, with numbers I chose rather than measured ones. Suppose a coding step sends 200,000 input tokens, of which 180,000 hit the cache, and generates 5,000 output tokens. Cost: 20,000 uncached tokens at $0.435 per million is $0.0087; 180,000 cached tokens at $0.0036 per million is about $0.00065; 5,000 output tokens at $0.87 per million is $0.00435. Total is about $0.0137 per step, so a 50-step task lands near 70 cents before retries. Without caching the same step would cost about $0.0959 for input alone, which is why cache hit rate dominates your bill.
The single-provider caveat is the operational risk. OrcaRouter’s analysis puts it bluntly: the open-weights model with the best score is also the one with the thinnest route to it. An MIT license means anyone may host it, and more providers will likely appear, but at launch an outage at one vendor was an outage for the model. If you build on it, put a fallback model behind your gateway.
Self-hosting: illustrative sizing
The sizing below is back-of-envelope arithmetic. It assumes nothing about Xiaomi’s published checkpoint precision, which I could not confirm, and it ignores activation memory and framework overhead, so treat it as a floor.
Weight memory is parameters times bytes per parameter. For 1.02 trillion parameters: about 2.04 TB at 16-bit, about 1.02 TB at 8-bit, and about 0.51 TB at 4-bit, plus a few percent for quantisation scales. An eight-GPU node with 141 GB per GPU holds 1,128 GB. An 8-bit copy of the weights would leave only roughly 108 GB across the node for KV cache and activations, which is thin for a model advertising 1 million tokens of context. A 4-bit copy leaves over 500 GB. A node of eight 180 GB GPUs offers 1,440 GB and is more comfortable.
For the 310-billion-parameter Flash model, the figures are about 310 GB at 8-bit and about 155 GB at 4-bit, so a four-GPU or eight-GPU 80 GB node is plausible. If Flash is within a few points of Pro on your workload, the hardware bill falls by roughly a factor of three.
Decode speed is bounded by memory bandwidth, not by the 1.02 trillion headline. At batch size one, each generated token must read the active experts: about 42 GB at 8-bit. If each of eight GPUs streams 4.8 TB per second, aggregate bandwidth is 38.4 TB per second and the single-stream ceiling is near 900 tokens per second. Real systems land well below that because of all-to-all communication for expert parallelism, attention reads of the KV cache, and kernel overhead. Under heavy batching, different tokens activate different experts, so a larger fraction of the total weights is read per step, and throughput per GPU rises while per-request latency worsens.
API versus self-hosting economics
Suppose, illustratively, that an eight-GPU node costs $3 per GPU-hour, or $24 per hour. To match the API’s $0.87 per million output tokens on output alone, you would need to sustain about 27.6 million tokens per hour, which is roughly 7,700 tokens per second across all requests, continuously. A lightly used internal deployment will not get near that, so the API wins on cost unless utilisation is high. Self-hosting is justified by data residency, air-gapped operation, fine-tuning on private data, or predictable latency, not by token price.
Serving stacks and quantisation
Xiaomi’s release included deployment instructions, and the V2-Flash generation was supported by common open-source inference engines. I could not confirm which engines support V2.6 Pro at the time of writing, nor which quantised variants exist. Expect community 4-bit builds to appear for a model this popular, and test them on long-context agent traces before trusting them; quantisation error compounds across 100,000-token trajectories in ways that short-prompt benchmarks never reveal.
Limitations, Provenance, and Failure Modes
The credible limits on MiMo V2.6 Pro are thin hosting at launch, vendor-reported agent benchmarks, undisclosed pre-training data, unverified multimodal strength, and unresolved questions about whether Chinese labs used Anthropic’s Claude outputs to generate training data. Each deserves a specific response rather than a shrug.
Provenance questions
In September 2026, Anthropic published findings that named seven Chinese labs, including Xiaomi, as having harvested Claude responses through fraudulent accounts and proxies. According to Memeburn’s summary of the report, Xiaomi was associated with more than 400,000 requests, far fewer than Alibaba at more than 151 million or Moonshot at 23 million. The same report says the harshest allegation, routing real customer requests through Claude without users’ knowledge, was aimed at Moonshot and DeepSeek. The Batch notes that Xiaomi had not publicly responded. China’s Foreign Ministry dismissed the broader claims. I cannot verify any of this independently. For an enterprise, the practical relevance is that the training data lineage of the model is not auditable, so legal and compliance teams should decide whether an MIT-licensed model with undisclosed data provenance fits your risk posture.
Technical failure modes
Long-horizon agents trained with RL tend to fail in characteristic ways. They can over-persist on a failing approach because RL rewarded eventual success on long trajectories, and they may game proxy metrics when a grader is imperfect. Xiaomi’s under-2-percent reward-hacking audit applies to its training environments, not to your tools. A 1-million-token context window is a capacity figure, not a quality guarantee: retrieval accuracy and instruction-following typically degrade well before the limit, and no independent long-context evaluation of V2.6 Pro appeared in the sources I reviewed. Hallucination rates were not reported either.
Mixture-of-experts serving adds its own risks. Expert load imbalance causes tail latency spikes, a single slow GPU stalls every request in an expert-parallel group, and routing is sensitive to quantisation. An unconfirmed discrepancy is also worth knowing about: the Wikipedia entry describes the Pro model as a proprietary API product with a planned open variant, while launch coverage says the weights shipped under MIT. Verify on the official Hugging Face repository yourself before you plan around a download.
How It Compares
The comparison below is qualitative and based on the index and reported specifications. I have deliberately not invented benchmark scores for peers that I did not verify.
| Use case | MiMo V2.6 Pro | MiMo V2.6 Flash | Other open-weights peers |
|---|---|---|---|
| Autonomous coding agents | Strong vendor-reported scores, cheap cached prefix | Within a few points at one-third the price | Check GLM-5.2 and Kimi K3 on your own tasks |
| Cost-sensitive high volume | Good cost per index task at about $0.13 | Best price in the family | MiniMax M3 is the other low-cost candidate |
| Self-hosted, regulated data | Needs a large multi-GPU node, MIT license | Feasible on smaller nodes | Smaller dense models fit single-GPU hosts |
| Multimodal input | Omnimodal, but evidence is thin | Omnimodal, same caveat | Compare against dedicated vision-language models |
Practical Recommendations
Start with the API, because it removes the hardware question and lets you measure the model on your own workload within a day. Pick a representative set of 50 to 100 real tasks from your own repositories or tickets, run Pro and Flash on identical harnesses, and record pass rate, tokens per task, and dollars per task. If Flash lands within your tolerance, choose it; the thin Pro-to-Flash gap in Xiaomi’s own results suggests that is a real possibility.
Design for caching. Structure prompts so the long, stable parts, such as system instructions, tool schemas, and repository context, come first and never change mid-session, since a hit on the cached prefix is priced about 99 percent lower. Put a second provider or a fallback model behind your gateway while hosting remains thin. Gate self-hosting on a clear requirement, such as data residency, and not on token price.
- Confirm the weights and license on the official Hugging Face repository and read the technical report.
- Run your own evaluation before trusting any aggregate score; keep the harness fixed across models.
- Measure cache hit rate and cost per completed task, not cost per token.
- Test long-context behaviour at 128K, 256K and beyond with your own documents.
- Ask legal and compliance to review training-data provenance and the September allegations.
- Plan failover, because a single-provider route is a single point of failure.
- Re-test when index versions change, since scores are only comparable within a version.
- For agent orchestration choices around the model, see our agent framework benchmark.
Frequently Asked Questions
Is MiMo V2.6 Pro really open weights?
Launch coverage from VentureBeat, OrcaRouter and others says Xiaomi released the weights under the MIT license, along with a technical report, deployment instructions, and RL environments. One encyclopedia entry describes the Pro model as an API product with a planned open variant, so verify on the official repository. MIT is permissive: commercial use, modification and redistribution are allowed with attribution. Open weights do not mean open data, because the pre-training corpus is not disclosed.
What does the score of 46 on the Artificial Analysis index mean?
It is an aggregate of several third-party evaluations, version 4.3.2 at launch per OrcaRouter, and 46 was the highest open-weights result, tied with Grok 4.7 and ahead of Grok 4.6 at 44. It does not mean 46 percent accuracy; it is an index. Scores are comparable only within a version, and a few points can reorder models, so use it to shortlist candidates and then test on your own tasks.
How many GPUs do I need to run MiMo V2.6 Pro locally?
As illustrative arithmetic: 1.02 trillion parameters need about 1.02 TB at 8-bit or about 0.51 TB at 4-bit for weights alone, before KV cache. An eight-GPU node with 141 GB per card holds 1,128 GB, so 4-bit fits comfortably and 8-bit is tight. The Flash model at about 310 billion parameters needs roughly a third of that. Check the model card for the actual checkpoint precision.
Is MiMo V2.6 Pro cheaper than Claude or GPT models?
Its API price of $0.435 input and $0.87 output per million tokens is far below the rates The Batch cites for Claude Opus. Cost per task is the fairer measure: Artificial Analysis measured about $0.13 per index task. Cheaper tokens do not guarantee cheaper outcomes if a model needs more attempts, so compare dollars per completed task on your own workload, and include the cached-input discount in the comparison.
What is the difference between MiMo V2.6 Pro and Flash?
Pro has 1.02 trillion total and 42 billion active parameters; Flash has about 310 billion total and 15 billion active. Both offer a 1M-token context window, 128K output, and MIT licensing. In Xiaomi’s reported benchmarks the gap is one to four points, and Flash leads on CyberGym, at roughly one-third the API price. Flash is the sensible default until your own tests show Pro’s extra capability pays for itself.
Was MiMo V2.6 Pro trained on Claude outputs?
I cannot confirm that. Anthropic’s September 2026 report named Xiaomi among seven labs it says harvested Claude responses, citing more than 400,000 requests for Xiaomi, per Memeburn’s coverage, and Xiaomi had not publicly responded in the sources I reviewed. These are allegations by one party. Xiaomi’s technical report would be the place to look for a statement on data sources, and compliance teams should ask directly.
Further Reading
- Xiaomi MiMo V2.6 release and RL stack explained, our launch-week coverage
- GLM-5.2 open-weight LLM benchmark analysis
- MiniMax M3 open-weight LLM benchmark analysis
- AI agent frameworks benchmark: LangGraph, OpenAI, Google ADK
- DPO vs RLHF vs SFT for LLM alignment
- External: VentureBeat launch report, The Batch analysis of the RL run, Latent Space AINews summary
By Riju — about
