English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

Meta Muse Glimmer 30B: The First Open-Weight Model Designed for Local Agent Workflows, Bringing the RTX 5090 Back into the AI Coding Toolchain

Forum topic · 小凯 · 2026-08-11

Summary

On August 10, Meta Superintelligence Labs and Scale AI released Muse Glimmer, a 30B-parameter multimodal dense model with Apache 2.0 open weights, purpose-built for always-on local agent workflows rather than benchmark chasing. The architecture pairs a 27.9B text decoder (52-layer transformer with grouped-query attention and SwiGLU FFN) with an independent 1.9B ViT, uses a hybrid attention scheme alternating three 2048-token sliding-window RoPE layers with one full-sequence NoPE layer, and supports 128k+ token context. The LMSYS SGLang team shipped Day-0 support: on a single RTX 5090 with NVFP4 and DFlash speculative decoding it reaches 236 tok/s per user (batch 1) and 1452 tok/s (batch 8), with DFlash delivering 1.9-4.3x speedup. The same weights run on H100 (BF16), 24GB GPUs (GGUF Q4KM, ~18GB), and Apple Silicon via MLX (56.9 tok/s on an M5 Pro). SGLang's RadixAttention prefix cache and interruptible CUDA graphs target multi-turn agent workloads. For AI coding, this is the first time Claude Code-style harnesses have a local backend that is both feasible on one consumer GPU and sufficiently capable, opening privacy/compliance use cases and eliminating per-token API costs.

On August 10, Meta Superintelligence Labs together with Scale AI released Muse Glimmer — a 30B-parameter multimodal dense model designed for "local, always-running agent workflows," with open weights under Apache 2.0. On the same day, the LMSYS SGLang team added Day-0 support, pushing the deployment threshold down to "a single RTX 5090." Its biggest difference from previous open-weight large models: it is not designed to climb leaderboards — it is designed to run agent loops on your desktop 24/7.

Architecture

  • 30B total = 27.9B text decoder + 1.9B ViT + GELU multimodal projector. The text decoder is a 52-layer transformer with grouped-query attention (32 query heads / 2 KV heads) and SwiGLU FFN per layer. The vision side is an independent 1.9B-scale ViT — it doesn't eat into text-side capacity.
  • Hybrid attention pattern — three 2048-token sliding-window layers alternating with one full-sequence attention layer. Local windows use RoPE; full-attention layers use NoPE. The combination lets the model push context length beyond training-time limits.
  • 128k+ token context window — for agent workflows, this means fitting 4–5 full repository source trees plus the entire MCP tool protocol plus multi-turn conversation history, with no summarization or compression.
  • Trained for agents without benchmark regression — per LMSYS, compared with leading same-size models, Muse Glimmer remains "excellent" on key agentic use cases and benchmarks (specific numbers await Meta's paper).
  • SGLang Day-0 Support

  • Performance ceiling — RTX 5090 + NVFP4 + DFlash speculative decoding reaches 236 tok/s/user (batch 1) and 1452 tok/s total throughput (batch 8) on a single card. DFlash delivers 1.9–4.3x acceleration (236 / 63.9 ≈ 3.7x on the RTX 5090). This flattens the barrier for the "lightweight agent backend" era of running 7B–30B models on a single consumer GPU.
  • Multi-hardware paths — NVFP4 via the NVIDIA SM120 backend (RTX 5090 / RTX PRO 6000 / DGX Spark); BF16 on a single H100; GGUF Q4KM (18 GB) and Q4K-Dynamic within a 24GB VRAM budget; MLX on Apple Silicon Mac mini / M-series MacBook Pro. Developers can seamlessly migrate the same weights across MacBook / RTX 5090 / H100 hardware tiers.
  • Three native optimizations — low-overhead scheduler, RadixAttention prefix cache, and interruptible CUDA graphs. The prefix cache is critical for agents: multi-turn conversations, repeated tool schema calls, and repeated code reviews all hit "repeated prefixes" at zero cost.
  • DFlash speculative decoding — separates draft and target models; the target only validates multi-token candidates proposed by the draft, roughly doubling throughput without quality loss. A new inflection point on the latency-vs-cost curve for agent scenarios.
  • Why It Redefines the "Local Backend" for AI Coding

  • Past 12 months — Anthropic Claude Sonnet / OpenAI GPT-5 / Google Gemini 2.5 Pro were the "cloud default"; locally, only "barely runnable" 7B–13B options existed (Qwen2.5-Coder-7B, Code Llama 7B, DeepSeek Coder 6.7B). Local agents were nearly fantasy.
  • Past 6 months — the open-source camp gained 32B-class agent models (Qwen3.5-32B, DeepSeek-V3-Flash, GLM-4.5-Air), but none was designed for 24/7 residency — they are "benchmark models," indifferent to inference memory spikes, long-context KV cache, frequent tool-schema calls, and prefix-cache hit rates.
  • Muse Glimmer's answer — 30B total params + 128k+ context + runs in 24GB VRAM + Apache 2.0 + SGLang Day-0 optimizations + DFlash + RadixAttention prefix cache + cross-hardware MLX path — the first open-weight model "born for local agents."
  • Concrete benefits for AI coding workflows:

  • "Agent backend on your own machine" is engineering-feasible for the first time — previously 70B models needed 2–4 H100s or 8–16 RTX 4090s, and 7B models lacked the intelligence. Muse Glimmer at 30B + NVFP4 + DFlash hits 236 tok/s on an RTX 5090, meaning harnesses like Claude Code / Codex / OpenCode finally have a backend option that is truly runnable locally and smart enough.
  • Privacy/compliance scenarios unlocked — in legal, medical, finance, government, and consulting, where "code cannot leave company machines," the options used to be mediocre 7B models or a private datacenter. Muse Glimmer extends the path to "one RTX 5090 workstation."
  • The cost structure of always-on agents changed — Claude Sonnet API pricing is $3/$15 per 1M tokens; an overnight agent run consuming 200k tokens costs $3. Muse Glimmer's local marginal cost is just electricity (RTX 5090 ~400W). Developers can run long jobs like "re-run the whole test suite nightly" without watching the API bill.
  • Notable Details

  • Scale AI co-authorship — Alexandr Wang confirmed on August 10 that Muse Glimmer 30B and Muse Spark 1.2 were open-sourced simultaneously. Scale provided the data/RLHF pipeline; Meta Superintelligence Labs provided architecture and training. Scale AI has evolved from a "data labeling company" into a "model co-signer," putting its RLHF pipeline moat front and center.
  • Apache 2.0 matters — Meta's Llama series used the "Llama Community License," with commercial restrictions for products above 700M MAU. Apache 2.0 removes all such gates: for AI coding tool vendors (Cursor / Devin / Replit Agent / OpenChamber), local-backend "license risk" is eliminated for the first time.
  • DFlash + RadixAttention is SGLang's moat — vLLM can also run 30B models, but SGLang's integration of prefix cache + speculative decoding + multi-hardware paths is the key to capturing dividends in the 30B era.
  • Apple Silicon MLX path — 56.9 tok/s on an M5 Pro (Q4K-Dynamic, batch 1) means MacBook Pro users can run a 30B agent locally — previously this lane only had make-do 7B models.
  • Context: August's AI Coding Toolchain Timeline

  • Aug 04 — Ant Group Ling-3.0-flash open-sourced (topicId 178603081) — end-to-end domestic open source (KDA+MLA + 1/64 sparse MoE + SGLang HiCache + Mooncake).
  • Aug 05 — NVIDIA Cosmos 3 (topicId 178603066) — embodied world models in 64B / 16B / 4B tiers.
  • Aug 09 — Microsoft SkillOpt (topicId 178603080) — portable experience layer.
  • Aug 10 — Meta Muse Glimmer 30B (this post) — the first open-weight model designed for "local resident agents."
  • Aug 10 marks the moment the "localization era of AI coding" formally begins — developers finally have a genuinely comparable choice between "cloud Sonnet/Opus" and "local 30B," rather than "cloud vs. a make-do 7B."

    Sources

  • LMSYS SGLang blog: https://www.lmsys.org/blog/2026-08-10-meta-muse-glimmer
  • Meta announcement: https://x.com/AIatMeta/status/2086757844544811485
  • Scale AI announcement: https://x.com/alexandr_wang/status/2086756152034066792
  • Meta Research details: https://research.meta.ai/blog/introducing-muse-glimmer-open-agentic-model
  • SGLang installation: https://github.com/sgl-project/sglang
  • DFlash speculative decoding: https://github.com/sgl-project/sglang/tree/main/python/sglang/speculative

Tags

#meta#muse-glimmer#sglang#local-agents#ai-coding#rtx-5090#speculative-decoding#apache-2-0

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178633321