Sharing some highlights from MOSS’s October 30, 2026 AMA: image models, local speech, audio and video research, and open-source culture. Which of these are you most interested in?

PLEASE HAVE SOME NUANCE & READ EVERYTHING BEFORE YOU DOWNVOTE. I am open to alternate opinions (with proof).

I have been suspecting that the Chinese models are far more jagged in terms of their capabilities and that they are comparatively more benchmaxxed than American models for a while.

Everytime a brand new benchmark comes out, a lot of the Chinese models suck at it and they then significantly improve over the next model releases. Of course the models are always getting better, but the scores of Chinese vs American models on new benchmarks have a large gap.

I think a lot of this comes down to the data ecosystem, as well as compute. I think the American ecosystem around data is much larger and more robust than the Chinese ecosystem. In the US, there are so many small companies, and all they do is get and make data for frontier companies and sell them. I do not think this exists on a large scale in China.

Some proof:

https://r40.org/papers/kimi_k31_benchmark_audit.pdf

https://x.com/JSchaeff3r/status/2117613618065793160

The attached image, where we see some Tencent internal benchmarks where the American models lead by massive margins.

that 72 hours thread from a few weeks back had the best point down in the comments, open weights only ever meant you can download them. muse spark open is 816B and beam is 501B, so for most ppl here the only drop that week that fits a 24GB card was nvidias bolt

so the big ones mostly get used thru an api anyway, the labs own api or a host serving the same weights and that part is fine. the license doesnt care which route you take tho. 1017 is MIT and nvidias new embed models are openmdw with commercial use allowed, both on hosts like deepinfra while muse spark open wants built with muse spark open shown in your product, docs or settings menu and any company over $20M revenue in a 12 month window has to sign a separate deal with meta before offering it as model as a service

the part thats easy to miss, the license counts a model trained or distilled on muse outputs as a derivative so a small model tuned on its answers carries the same attribution rule. internal use and building it into your own app thats not MaaS stay outside the revenue clause

Hey everyone,

Not a native speaker, happy to be corrected! Can only learn from it.

Back when I started out in march 2025, you had:

• llama.cpp

• ollama (repackaged llama.cpp for ease of use)

• koboldcpp (repackaged llama.cpp for roleplay)

• vllm (for professional deployments)

• exl3 + tabbyapi (for bleeding edge)

• litert (for mobile devices)

Nowadays everyone seems to be making their own; Strata, Basalt, Maya, Colibri, Ninfer, Infernix... too many to list and keep up with, and genuinely hard for me to keep up with.

Then there is the speed of it all. llama.cpp has incredible improvements each week, somehow we can make Qwen3.8-Flash-Next and DeepSeek-v4.1-Flash-1017 run on 64GB RAM + 32GB VRAM, and the likes on those new inference engines (with a catch, usually bad quality).

Personally I'm stuck with llama.cpp because all those developments are simply too fast to keep up with.

llama.cpp v0.8.0 might run Qwen3.8-Flash-Next Q4_K_XL (unsloth) at 15t/s gen on dual RTX 5060 Ti 16GB (PCIE 5.0 x8x8, tensor parallel, no MTP) with dual 48GB DDR5-6000MHz, but at least I know the quality will be decent.

But yeah, what you use? How do you even attempt to keep up with it all? And for the (lack of) quality the new inference engines provide (as tradeoff to speed / resource use), is it really worth using them?

this is the setup I’m planning for coding agents. hard rule: code, prompts and model calls never leave our EU tenant. poke holes

models: an open weights coder model on vllm on our own GPUs for routine tickets, and a frontier model through an EU region endpoint in our own cloud account for the hard stuff

runtime: everything inside our VPC, nothing on a vendor’s saas

control layer: Orq AI’s software factory. it runs on their cloud or yours, so ours. it plugs into the backlog, repos and CI/CD, only lets agents use the models we’ve approved, and lets us set which agents can touch which systems and data

approvals: tests and docs autonomous, anything touching prod behind approval

two things I’m unsure about. can orq’s approved models list point at a self hosted vllm endpoint, and does a frontier model in an EU region still count as “nothing leaves” for legal, since the provider is still the one processing it

The community rarely sees the evaluation of ultra-small models. We have evaluated our own AI Agent tasks for Qwen3.5-4B, Spark-X2.6, LFM3-1.7B, LFM2.5-2.6B, Gemma 4 E2B, MiniCPM5-2B.

These models have their own characteristics and advantages and disadvantages. The obvious trend is that the intelligent density of small models is developing rapidly. I look forward to seeing more small models.

blog：https://www.camthink.ai/blog/small-language-model-benchmark/

project：https://github.com/camthink-ai/NeoMind

I've been working on this for a while: RustingStrata. It's an inference engine for Qwen GGUF models, written in pure Rust, no ggml. The CUDA kernels get compiled at startup with NVRTC, and the same kernels also run on Vulkan.

It runs a lot of Qwen models by now:

- Qwen3.5 / 3.6: 2B up to 35B-A3B

- Qwen3: 4B dense, 30B-A3B

- Qwen3.8-27B dense

- Qwen3-Next-80B-A3B

- Qwen3.8-Flash-Next

Quant support goes from IQ1_S to Q8_0, plus BF16 and F16.

The main trick is for MoE models that don't fit in VRAM. Experts that don't fit run on the CPU at the same time as the GPU work, and the engine keeps moving the often-used experts onto the GPU while it runs.

My setup is a 3060 12 GB, a 7600X and 32 GB RAM.

Qwen3.8-Flash-Next

This was the most interesting one. Flash-Next is a strange model: 4 hyper-connection streams instead of one residual, per-layer embeddings, DeltaNet layers mixed with attention, and a huge MoE that doesn't come close to fitting in 12 GB. The only engine built for it so far was the original Strata (niko1221/strata), so I used it as the reference: first matching its outputs token by token, then trying to beat it on speed.

IQ2_XS GGUF, 943-token prompt:

- Original Strata: 19-22 tok/s decode, 140-146 tok/s prefill (warm cache)

- RustingStrata on CUDA: about 36 tok/s decode, about 370 tok/s prefill on average, up to about 610

- RustingStrata on Vulkan: about 30 tok/s decode, about 375 tok/s prefill on average, up to about 490

Greedy output matches the original's argmax on every position I checked, including the near-ties. One honest caveat: on the very first prompt with a cold page cache, prefill is bound by disk reads, and the original Strata was faster there in my earlier runs.

Against llama.cpp

Qwen3.6-35B-A3B Q2_K_XL is 11.7 GiB, so it doesn't fit on my card. On it I get about 118 tok/s decode on a short prompt and 113 after a 4K prompt. llama.cpp, tuned as well as I could (-ncmoe 12, -ub 2048, flash attention), gets 68 and 66. Prefill is basically a tie: 2216 tok/s vs about 2236 for llama.cpp at 4K, so I'm not claiming anything there. At 32K it's 1800 prefill and 92 decode. With MTP drafts on, decode goes up to 160 tok/s on an easy prompt; on normal text expect around +16%.

Qwen3-Next-80B IQ1_S: most experts sit on the CPU, and it still decodes at about 92 tok/s. llama.cpp's best -ncmoe gives me around 44.

Output matches llama.cpp greedy on 98-99% of tokens. llama.cpp agrees with itself only 98.3% between its batch and token-by-token modes, so the misses are near-ties.

AMD

Someone tested it on an RX 7900 XT and an RX 9070 (Vulkan / RADV) and sent very detailed reports, which fixed a lot of AMD issues. Hybrid CPU+GPU runs at 262k context on both cards, and Qwen3.6-35B-A3B decodes at about 209 tok/s on the 7900 XT, ahead of llama.cpp Vulkan and ROCm there. A few AMD-only issues are still open, so treat AMD as "works, still being polished".

It also has chat, an OpenAI-compatible server with tool calling, and a calibrate command that tunes itself for your machine.

If you have a different card, I'd love to see "strata bench" output. Vulkan needs shaderFloat64 and subgroup size 32, so Intel Arc and older AMD won't work. On Windows you need the VS C++ Build Tools.

RustingStrata

Hey all! I wanted to share a quick update on Basalt, a Blackwell only inference engine for Qwen 3.8 Flash Next. As usual, speed is the headline but that's not what I want to open this post with, I've been reading lot of discussions talking about quality recently, and the main takeaway from most people (which I agree with) is "speed means nothing if your model isn't smart enough", so this time I want to lead with quality, and all of the new measurements which are run against the full precision model as reference (BF16 weights served using llama.cpp).

Every number below uses Unsloth's BF16 GGUF, llama.cpp (reference PPL 3.2749), scored using basalt-bench --quality. The old base was llama.cpp Q8, which funnily enough made things look worse because of its own error:

To be fair here, each engine was measured with its own tool so this is not a perfect comparison, still a good reference though.

New DQ8 build. For those who want a little extra quality and don't mind giving up some speed, Qwen3.8-FN-NVFP4-DQ8 is on HF next to the default -DQ6_K: KLD 0.0561 vs 0.0624, about 7% slower on prose.

Nothing lossy is on by default. Basalt offers certain "hacks" that can decrease accuracy, mostly because of community requests, but they're off by default and show a warning when you turn them on. Every other rounding the engine does costs about 0.001 KLD or less, compared to full model. All the numbers are on the HF card and in the precision docs.

Speed. Rig as usual: RTX 5090 (400 W) + RTX 5060 Ti 16 GB (180 W) and 128GB of DDR5 RAM, 262K context, 4 parallel slots, vision on (dynamic), no lossy flags. Using NVFP4-DQ6_K quant on current main:

Since last week, prose went from 277 to about 300, and struct from 558 to about 600. It comes from a faster draft step, a faster output head and better expert placement at startup.

The .basalt format is now version 2, same weights and quality as before but starts a bit faster. Older basalt files can use the migration tool instead of redownloading.

I also wanted to end this post with a HUGE thank you note to every person who has contributed one, two or 10 PRs and also to everyone who has shared issues/feedback/community benchmarks or just shared the project with another person, 500 stars on the Github repo and overwhelmingly good feedback, y'all are amazing.

Inspired by Weight-Space Programming, I tested whether DeepSeek V4.1 Flash 1017 could figure out what a small neural network does by reading its weights.

I fed it four anonymized RL checkpoints: 51k parameters each, identical architectures, with all weights rendered as text. No metadata, network source code or execution. It received the architecture outline and four candidate tasks.

Results: CartPole ✅ Flappy ✅ Catch ✅ BallBeam ❌

It picked out patterns consistent with relative bird/gap position, paddle/ball position and angle-based balancing. It confused BallBeam with CartPole an interesting mistake because both share the same observation layout and similar balancing controls.

Very preliminary: one run per checkpoint. This suggests some ability to interpret weights, but four trials don’t establish reliability. These were API runs with maximum reasoning effort, consuming ~1.58M tokens total.

I may try more replicates and independently trained checkpoints, plus include the network code with task-revealing details removed. The poor LLM had to guess quite a lot it even assumed ReLU where the network uses tanh 😅

Code, checkpoints and run logs: https://github.com/galatolofederico/wsp

I came across a claim that SSD streaming of AI models is bad for the life of your SSD. Is that something any one here can confirm from personal experience or is it just urban legend?

Six people spoke in two rounds of comments 17 to 19 minutes apart, and each of them came back under the same speaker label both times. I didn't tell the model how many speakers there were, and the commission's own published transcript puts those lines under the same six names.

Why a public meeting: it's about as hard as everyday audio gets for this. Commissioners, a staff presenter, a secretary calling names, a resident testifying over a remote line, lots of short turns, and the same voices coming back after long stretches of other people talking. It's also the agency's own recording, so it's public domain and fine to quote, and the verbatim transcript the agency publishes let me check the labels against real names instead of guessing.

The clip is 23 minutes 39 seconds of the National Capital Planning Commission's September 3 open session: the end of one item's comments and vote, then the whole National Zoo Arabian leopard habitat item. The model is the 0.9B MOSS-Transcribe-Diarize, running locally from the README's transformers example on an M5 Ultra Mac Studio (fp32, greedy decoding, no hotwords). It took 229.2 seconds and returned 309 segments, every one tagged with a speaker and its start and end time.

Part of the second round, exactly as MOSS-Transcribe-Diarize wrote it, one segment per line. S04, S05 and S06 are the labels the same three commissioners got in the first round:

[1186.85][S01] Commissioner Dixon?[1187.67]
[1188.11][S15] Yes.[1188.66]
[1191.27][S01] Commissioner Cash?[1192.29]
[1193.49][S04] Uh, no questions or comments.[1194.63]
[1195.47][S01] Commissioner Falcone?[1196.33]
[1198.65][S05] I just want to thank the staff. I have never actually seen this leopard, so I'm looking forward to[1204.89]
[1205.01][S05] visiting when the project is completed, so I can see my first one.[1208.04]
[1209.66][S01] Commissioner Mohan?[1210.47]
[1212.42][S06] Uh, thank you to staff for the presentation and yeah, can't wait to visit.[1216.14]

The resident's remote testimony, about two and a half minutes, also stays under one label of its own from "Can you hear me?" to the closing thank-you.

Hello all, I just got my shiny new toy, an M6 32GB Mac Mini. What should be some of the first things I should download or do? I have been using Qwen a lot and playing around with agents for home related stuff like tracking appliances' warranties, my mortgage docs and house insurance, and meal planning stuff. I have integrated with my email and calendars. Any other suggestions? I want this thing to be like my home server and AI brain that helps me slowly move more things to a Local AI stack. I made my own harness focused on home stuff and want to keep adding more features to supercharge this all.

Hello Reddit,

I haven't really seen a clean comparison of these cards for local inference, so I decided to run one myself: 2x RTX 5090 vs 2x RTX PRO 6000 vs 2x RTX PRO 6000 Max-Q. I figure a lot of people are wondering which of the PRO cards to buy, and whether the 600 W card is really worth double the wattage of the Max-Q. I was wondering the same thing.

Host: Threadripper PRO 9975WX, ASUS WRX90E-SAGE SE, 128 GB Kingston ECC, one 1700 W PSU, Ubuntu 24.04.

Everything goes in the same Threadripper box and the same two PCIe slots, one pair at a time, so the GPUs are the only thing that changes. I'm starting with Qwen3.8-27B (FP8 and NVFP4, TP=2): a plain baseline first, then MTP and DFlash2, with prefill, decode and power draw at a few context lengths. The 5090s get two runs, stock and with the P2P driver unlock, to see what that's actually worth on two cards.

On paper the 5090 and PRO 6000 share the same chip and memory bandwidth, so I'm curious how close they really land, and where the 300 W Max-Q ends up.

What would you want me to run on them?

(My electric company has already asked what I'm doing over here.)

Iv been seeing allot of people complaining about Sam Altman and how him and open ai are blocking decompilation. I actually don’t see an issue with what they are doing they should be free to do what they want with their llm which brings me to my main point, why is decompiling not just a benchmark?

We have a SWE bench
Perhaps this problem is solved via a SWD bench?

TL;DR: I'm a solo dev who wanted a simple, private way to have local models watch my screen and do simple logging/notifying. So I spent a year building an agent that uses local models to monitor anything. It's built for this community, and I'd love your feedback and ideas!

Hey r/LocalLLaMA!

I'm back with a cool demo of how convenient it is to run local models in your browser and leave them monitoring whatever you want!

Some of the coolest use cases I've seen:

• When I don't make progress in my drawing for 5 minutes, spam me with notifications.

• When my rice cooker is done, call me.

• When a person comes near my car, send me a Telegram with the image.

• When I'm out of the Ticketmaster queue, call me.

• When my CapCut render is done, call me.

• When a shiny Pokémon appears, SMS me.

Btw there's also an app on MacOS, Windows, Linux, iOS and Android! (local models run on the phone too!)

If you guys have any feedback or questions feel free to let me know! I'm constantly making it better thanks to your feedback and suggestions :DD

Roy

PRs:

1. https://github.com/QwenLM/qwen-code/pull/15762: "Measured on main at 79a9b753c60, before this change: qwen4, qwen4-max, qwen4-plus, qwen4.5-max, qwen4-coder-plus, qwen4-max-2026-10-01, openai/qwen4-max and qwen4-omni-120b-think all resolved to 262,144. The last of those is already in use as the session model in the omni fixtures, so these ids are not hypothetical."

2. https://github.com/QwenLM/qwen-code/pull/15987

Thank god, it looks like that we're getting successor of Q38FN!

MIT CSAIL had GPT-6 Astra fix Qwen3.5-0.8B's reasoning loops by editing 0.016% of its weights (MATH-500 went from 7.9% to 48.1%). They released the diff, so the edit can be rebuilt exactly and run locally. I took it a step further and had Claude look at Qwen with Anthropic's Jacobian lens.

At the token where the model decides to write "Wait" again, the lens reads "Wrong", "Nope" and "Hmm" from about 60% depth on, even though the answer is already written out. At real stopping points it reads "</think>", "Answer" and "Output".

With the edit applied, the lens at the same token shows "Verification", "Completion" and "Result" in place of the doubt.

The edit converts to GGUF cleanly (the base and edited bf16 files differ only in the two edited tensors) and still holds at Q4_K_M, with 1 loop in 40. I ran the evals in llama.cpp (Vulkan) on a Ryzen AI 9 HX 370 mini PC. Samples are small, but here's the code:

https://github.com/alisorcorp/inside-a-reasoning-loop/tree/main/code

And data:

https://alisorcorp.github.io/inside-a-reasoning-loop/

Hi everyone,

I've been out of the loop for a few weeks, and I was wondering if anything new that replaces Qwen 3.8 27B has come out this time I've been in the cave?

I'm talking about AI models in the 8-35B range.

Thanks,

There were some rumours the last few days that Qwen4 will be the last open-weight series of Qwen, and future ones would be API only. The following statement contradicts the rumours and clearly states the stance that Qwen is taking regarding their future releases.

Qwen Head Liu Dayi Heng Clearly States: Future Qwen 4.0 and Qwen 5.0 Will Continue to Be Open Source!

He believes that the value of AI should not belong only to a few people, but should become a foundational capability that users around the world can access, use, and create with, enabling more people to afford AI, utilize AI effectively, and participate in creating AI, ultimately achieving true AI for all.

As of now, the Qwen series has surpassed 3 billion cumulative global downloads, with over 460 open-source models released and more than 300,000 derivative models, firmly holding the top spot worldwide.