Release guide · August 11, 2026

Meta's Muse Glimmer: a 30B open-weight agent model that runs on one GPU

Choose a Muse Glimmer checkpoint for local inference, check memory and tool-call support, and compare completed agent tasks against your hosted baseline.

Reading time
9 min
Checked
Nov 17, 2026
Paper-cutout illustration of a small figure carrying folders and a toolbox across an upright graphics card used as a stage
A local model earns its place by finishing the workflow, not merely fitting on the GPU
Bottom line

Muse Glimmer is worth a controlled local-agent pilot if you already have suitable hardware. Choose the quantized artifact and runtime together, then measure completed tasks, memory and recovery from tool errors. Downloadable weights alone do not establish savings, privacy or reliable automation.

A model that fits on your GPU can still be a poor agent. Muse Glimmer’s useful promise is that you can test a local execution model against your own work: the files it reads, the tool errors it recovers from, and the output you can actually use.

Meta introduced Glimmer on August 10, 2026 as a 30B model for local agent workflows. The launch announcement positioned it for consumer hardware. The practical question now is which released build to run, and what would count as a successful pilot.

Checked November 17, 2026: this refresh verifies Meta’s documentation and model card. It is not a hands-on benchmark. The exercises below are proposed tests, with no measured speed, savings or success rate claimed here.

What shipped

Meta’s Glimmer overview describes a dense, decoder-only model with text and image input, text output, and a default 128K-token context. Its weights use Apache 2.0. The official model card gives approximately 29.6B parameters including the perception encoder and describes distillation from Muse Spark.

The card lists tool use, multi-step reasoning, failure recovery and compatibility with agent scaffolds including Hermes Agent as intended capabilities. These are Meta’s descriptions, not evidence that a particular Hermes configuration or workflow will succeed. A model produces responses and tool requests; the surrounding harness must validate those requests, execute permitted actions and return results.

That separation matters more than the launch rhetoric. You can own the weights and still have an agent that calls the wrong tool, drops an argument or claims to have read a file it never opened.

Pick the artifact before choosing hardware

The official download guide separates the builds by runtime:

ArtifactPublished contentsStarting point
meta-models/Muse-Glimmer-30BBF16 weights, tokenizer, chat template and processor configuration; around 60GBvLLM or SGLang
meta-models/Muse-Glimmer-30B-GGUFQuantized text checkpoints, vision projector and optional draft modelA compatible GGUF runtime such as llama.cpp
meta-models/Muse-Glimmer-30B-ExecuTorch-PTEPrebuilt ExecuTorch exportsThe documented ExecuTorch deployment path

Do not download the BF16 checkpoint expecting the consumer-card memory claim to apply to it. Meta’s deployment guide budgets about 72GB of VRAM for BF16 serving. That is more than the weight download alone.

For GGUF, Meta’s quantization guide lists a 16.8GB K-Quant-17GB text artifact and a 19.7GB dynamic alternative. Image input adds a 1.4GB projector; the optional DFlash drafter adds another 1.6GB download. Those are file sizes, not universal peak-memory measurements.

The same guide requires llama.cpp b10353 or newer and says to select the text checkpoint explicitly with --hf-file: several files share a quantization tag, so a repository name alone can select ambiguously. It also documents -c for context allocation and -np for slots. Start with one request and a modest context, then increase to your actual workload while watching memory.

My buying rule: test on hardware you already own or can borrow before purchasing a GPU for this model. A successful load proves less than a completed workday’s task queue.

The economics: where a local model fits

A useful candidate is repetitive execution work: read a known file format, extract fields, call a small set of tools and save a checked result. Keep a stronger hosted model as the comparison if that is what currently completes the job.

The cost question is not just electricity per token. Include hardware allocation or rental, power, setup and maintenance time, retries, manual repairs, and any external APIs the agent still calls. Local serving also has capacity limits: queued jobs and slow recovery can consume the time you hoped to save.

Use this accounting rule for a pilot:

Cost per accepted task =
  total cost of the evaluation window / tasks that passed acceptance checks

Total cost includes failed attempts and manual correction.
Record the hardware allocation and labour-rate assumptions separately.
If no tasks pass, report zero accepted tasks rather than a cost ratio.

This is a proposed accounting method, not a savings claim. Compare both systems on the same fixtures and completion criteria. A faster first token does not compensate for an incorrect output file.

The skeptic’s check

First, local inference is only one part of privacy. Inspect the full route: tools, search providers, logs, telemetry, backups and any fallback model. A local server does not make a web-search tool local. Begin with synthetic files, keep the server bound to loopback for a same-machine pilot, and verify destinations before using confidential material.

Second, benchmarks describe a configuration. Meta’s model card publishes evaluation results and quantized deployment measurements. Treat them as vendor results. Your runtime, context length, tool schema and recovery rules can change the outcome; preserve those settings when comparing runs.

Third, open weights do not remove operational responsibility. Someone still owns runtime updates, access controls, disk space, task supervision and failed jobs. For a broader comparison, use the open-weight landscape lesson and the hosting decision lesson. Judge Glimmer against the model that solves your work today, rather than a general claim that one country’s labs lead another’s.

Who should pilot it, and how

A pilot makes sense when you have repeated work, suitable hardware and a clear acceptance check. Skip the hardware purchase if your demand is occasional or you cannot spare time to operate inference.

Use this authored local-file exercise to test the whole loop. It has not been executed for this article.

  1. Create disposable fixtures. Put two short text files in a fresh test directory. Give each a fictional project name and deadline. Write the expected filename, project and deadline rows yourself in a separate answer key.
  2. Choose and record one deployment. Follow Meta’s runtime-specific instructions linked above. Save the checkpoint revision, exact filename, runtime version, context cap, reasoning setting and hardware. Run a plain text request first, without agent tools.
  3. Connect a restricted harness. Expose only directory listing and file reading inside the fixture directory, plus writing one result file. Configure your agent’s provider endpoint and model name to match the local server. Confirm from the server log that requests reach that model, with no hosted fallback.
  4. Request a checked artifact. Ask the agent to read both files and write a CSV with columns filename,project,deadline. Require a source filename for every row and an explicit report for unreadable inputs. Do not put the answer key in the agent’s accessible directory.
  5. Inspect the tool trace. Verify that calls arrive as structured function names and arguments, that the harness actually reads both files, and that the resulting CSV matches the answer key. Prose saying “I read the files” is not evidence of a read.
  6. Introduce one failure. In a fresh run, make one fixture temporarily unavailable through the test harness. Check whether the agent reports the missing input rather than inventing its contents. Restore it and retry; inspect whether the final output contains each expected row once.
  7. Repeat the same cases against your baseline. Use synthetic data for the hosted comparison. Keep the fixture set and acceptance checks fixed, record every attempt and count corrections as work.

Keep the evidence in a small run sheet:

Date / hardware / runtime version:
Model repository / revision / artifact:
Endpoint / model name / context / reasoning setting:
Fixture case / expected rows:
Actual tool calls / tool errors / retries:
Output path / comparison with answer key:
Peak memory / elapsed task time:
Manual correction time / accepted or failed:
Cost assumptions / observed charges, if any:

Passing this exercise establishes a narrow result on disposable files. It does not establish reliable browser control, production scheduling or unrestricted file access. Expand the task set only after the trace and output agree.

When the pilot fails

Meta’s runtime guide documents different tool and reasoning parsers for different engines. For vLLM the parser name is muse_glimmer; SGLang uses muse. A working chat response does not establish working function calling.

SymptomNext check
Unknown model architecture at load timeCheck the runtime version against the quantization guide before changing hardware.
Tool request appears as ordinary textCheck the runtime’s tool parser and the harness’s structured-call handling.
Startup succeeds but a longer job runs out of memoryReduce context or concurrency, then repeat the same input and record peak usage.
Agent says it finished but rows are missingCompare output with the answer key and inspect the actual read calls. Mark the run failed.
Retry produces duplicate rowsRestart with a clean output artifact and inspect how the harness resumes work.

Change one variable at a time. Otherwise you will not know whether the fix came from the model, the runtime or the task instructions.

What to watch next

The earlier version of this article treated Spark’s open release as a future event. Muse Spark Open is now documented and downloadable. Meta lists 816B total parameters with 42B active, BF16 and NVFP4 checkpoints, and the Muse Model License plus an acceptable-use policy. It is a different deployment and licensing decision from Apache-licensed Glimmer; do not carry over the single-consumer-GPU assumption. See the Spark Open overview.

For Glimmer, the next useful evidence is a saved task trace from your own workload. Keep the local model if it passes your acceptance checks at a worthwhile total cost. Keep the hosted baseline if it does the job better.

Sources

Primary sources checked November 17, 2026. Launch date comes from Meta’s indexed announcement; its full page did not load during this refresh. Technical guidance above was checked against the accessible documentation and model card.

Put this to work

Separate downloadable weights, runtime compatibility and an agent harness that can actually execute tools.

Try

Choose a documented artifact/runtime pair and run the small local-file pilot below on disposable fixtures.

Prove it worked

Save the configuration, tool trace and checked output; compare completed tasks and total operating cost against your hosted baseline.

Keep in view

  • Muse Glimmer is a dense 30B multimodal model with Apache 2.0 weights and a default 128K context.
  • Meta publishes separate BF16, GGUF and ExecuTorch artifacts; the 24-32GB pitch depends on quantization and runtime settings.
  • Test structured tool calls and error recovery before connecting private files or unattended jobs.
  • Muse Spark Open is now available, with a different license and a much larger hardware footprint.
Learn the workflow: the open-weight model landscape