r/OpenModels

Edit: (Rewriting this because my first post sounded way too much like a model card lol.)

I've been working on a post-trained version of Qwen3.6-35B-A3B that I mainly use for coding and agent workflows locally. I called it QwiVer3.6-35B-A3B.

Model is here:

https://huggingface.co/BlackRiverAI/QwiVer3.6-35B-A3B-GGUF

This isn't just Qwen with a different name slapped on the GGUF.

I trained a LoRA against the BF16 base, selected the Phase 10.2 adapter, merged it back into the frozen BF16 model, then converted/quantized the merged model to GGUF and checked that the Qwen3.6 architecture + MTP stuff survived the process correctly.

The final training run was:

1,531 examples 3,999,924 training tokens 383 optimizer steps

Base was unsloth/Qwen3.6-35B-A3B.

Architecture is still the original Qwen3.6-35B-A3B setup:

~35B total parameters ~3B active 40 main layers 256 experts 8 routed + 1 shared expert active 262,144 native context vision native MTP

What I was trying to change was mostly behavior rather than architecture.

I wanted it to be more useful when I'm actually sitting in front of a coding agent for hours: following an existing codebase, debugging instead of immediately rewriting everything, using tools properly, staying on task across longer jobs, and generally being less annoying to work with.

That's also why I've been calling it my daily driver rather than trying to claim I invented a new base model.

On my own workloads I prefer it pretty clearly over stock Qwen3.6-35B-A3B. That's subjective, obviously, which is also why I'm running proper benchmarks now instead of asking anyone here to take my word for it.

First ones running are AIME 2026 and GPQA Diamond against the official Qwen3.6 published scores. I'm using the public Q8 GGUF through llama.cpp, saving the raw per-question results/config, and I'll publish those when the runs are finished.

The little smoke test before starting the full run was 2/2 AIME and 2/2 GPQA, but that's four questions so it means absolutely nothing beyond confirming that the harness works 😅

GGUFs currently uploaded:

Q2 ~12.57 GB Q3 ~17.23 GB Q4 ~22.85 GB Q8 ~39.10 GB

Q4 is probably the sensible download for most people. Q8 is what I'm using for the benchmark run.

There's also the BF16 vision projector and the chat template in the repo.

I'm running it on a Ryzen AI Max+ PRO 395 / Radeon 8060S with 128 GB unified memory, Windows, llama.cpp Vulkan.

For normal use I also run the native MTP head, although I've disabled speculative decoding for the quality benchmark so it isn't another variable in the results.

If anyone actually tries the model, I'm especially interested in coding/agent failures compared with stock Qwen3.6. That's more useful to me than "feels smarter" either way.

And yes, benchmarks are coming. I got the message.

Confirmed by the official Qwen account.

Hi r/LocalLLaMA 👋 

Today we’re excited to release Muse Glimmer, a 30B open-weight model built specifically for local agent workflows. We’re releasing the weights to the community under a permissive Apache 2.0 license.

A few specs

• 30B params, dense
• Multimodal: interleaved text + images via a dedicated perception encoder
• Trained on 100+ languages
• Controllable reasoning effort (quality/speed tradeoff)

Memory footprint
At full precision, 30B needs 55+ GB, which is out of reach for consumer hardware. We quantize weights to ~4-bit, bringing the LM under 20 GB. That leaves headroom in a 24 GB or 32 GB envelope for the KV cache, the perception encoder, and the speculative decoding drafter running simultaneously. We validated minimal to no degradation on agentic tasks under compression.

Speculative decoding
Ships with a lightweight DFlash-based drafter that proposes blocks of tokens which the main model verifies in parallel. Significantly faster than token-by-token generation with identical output quality. We're also shipping quantized drafter versions so the memory overhead stays small.

A few capabilities
We trained Muse Glimmer for agentic loop tasks, including:

• End-to-end task completion (strong performance on DeepSearch QA, MCP-Atlas, 𝛕^(3)-Bench, SWE-Bench, and more)
• Function calling with precise schemas across long workflows
• Multi-step reasoning over long horizons
• Failure recovery — when a tool call fails or returns something unexpected, it's trained to diagnose and retry instead of halting. This was a deliberate training target.
• Works with OpenClaw and other agentic scaffolds
• Multimodal understanding and reasoning

Running it
Weights are up on Hugging Face. Coming soon: Ollama, LM Studio, Unsloth and torchtitan, plus optimized integrations for llama.cpp, MLX, and ExecuTorch. vLLM and SGLang for serving. Get started quickly with Together AI, Fireworks AI, and OpenRouter. We're also working with AMD, Arm, Dell, Intel, and NVIDIA on per-device optimization.

We look forward to your feedback and seeing what the community builds with Muse Glimmer.

🔗 Weights: https://huggingface.co/meta-models 
🔗 Research Blog: https://go.meta.me/museglimmer
🔗 Resources: https://developer.meta.com/ai/models/muse-glimmer/