Meta's Muse Glimmer fits on a 24GB GPU. Your personal AI bill is still yours.

"Always-on local agent workflows." 1

Meta released Muse Glimmer on August 10 as an open-weight model for agents that run on a Mac or PC instead of a cloud server. That sounds like personal AI with the leash removed. The less romantic version is a 30-billion-parameter model compressed until it fits inside a serious consumer GPU, then handed to developers who still have to build the agent, wire up the tools, and own the failures. 2

The pitch is personal superintelligence. The product is a compact engine for someone else's agent project.

Muse Glimmer is a 30-billion-parameter model. At full precision, Meta says it would need more than 55GB of memory, which is not a casual laptop accessory. The company quantized the weights to roughly 4-bit precision, bringing the language model below 20GB and leaving room for the model's working memory, image encoder, and speculative-decoding helper. Meta says the resulting package fits a 24GB or 32GB hardware envelope. 1

This is real engineering. A model that needs 55GB is a server-room guest; one that can run in a 24GB envelope at acceptable speed can at least become a developer's project. Quantization is not a magic shrink ray. It trades numerical precision for a smaller memory footprint, and Meta's own table shows that the trade is measurable even when the reported degradation is small. 1

Meta also pairs the model with DFlash speculative decoding. A smaller drafter proposes blocks of tokens, then the main model checks them in parallel. Meta reports a 3.1x decode-speed increase on an RTX 5090, 1.8x on an M5 Max, and 1.5x on an M4 Max in its own measurements. The footnote matters: the Mac figures used ExecuTorch, while the RTX figure used llama.cpp. 1

That distinction is the whole roast in miniature. Token speed is a property of the engine. A useful agent is a chain of model calls, tool calls, permissions, retries, and waiting. Meta has improved the first part. The rest is still somebody's weekend.

The model can accept screenshots and images, call functions, sustain a plan across multiple steps, and retry when a tool returns an error. Those capabilities make it suitable for an agent scaffold. They do not make it a finished assistant. 1

A weight file does not contain a Gmail token, a calendar connection, or a trustworthy file index. It cannot decide whether a draft message should be sent, whether a spreadsheet is safe to upload, or whether a screenshot contains a secret. The surrounding application supplies those tools and decides what the model can see and do. That is an architectural consequence of releasing a model rather than a complete service, not a hidden permission claim about Meta.

Meta's own examples make the dependency obvious. It says an agent that manages schedules, drafts messages, organizes files, and learns how someone works needs deep access to personal context. 1 The local part keeps that context on the device while the agent runs. It does not remove the need to grant the agent access in the first place.

This is where the marketing changes jobs. The cloud assistant's central question is, "What does the vendor retain and do with my data?" The local agent's question becomes, "Which developer gave this model access to my data, where do its logs go, and what happens when it retries the wrong action?"

Those are not the same privacy promise. Meta's launch page explains the model's local deployment and capabilities. It does not provide one retention, deletion, audit, or revocation policy for every application that will wrap the weights. 1 The privacy advantage is real at the network boundary. The policy burden moves down the stack.

Apache 2.0 is a permissive license, and Meta says the weights are available now through Hugging Face. The company also names developer documentation, Ollama, LM Studio, llama.cpp, ExecuTorch, MLX, vLLM, SGLang, and hosted providers including Together AI, Fireworks AI, and OpenRouter as routes into the model. 1

That is a good distribution strategy because it covers both kinds of customer. One customer has a 24GB or 32GB GPU and wants local control. The other wants to call an API and let someone else pay for the hardware. The second route is convenient, but it turns an open-weight release into another hosted model endpoint. The first route preserves local ownership, but asks the buyer to be a systems administrator.

The release is therefore not a single product with a single price. It is a fork in the road:

Meta does not publish a consumer plan that bundles those pieces together. 1 Calling the weights free is technically fair and practically incomplete. The download is free in the way a recipe is free when the kitchen is not.

Meta compares Muse Glimmer with Gemma4-31B and Qwen3.6-27B across agentic, coding, multimodal, safety, and general-capability benchmarks, and says it performs strongly for its size class. It is useful evidence about what Meta tested, but it does not tell a developer how quickly a full local agent will search a folder, call five tools, recover from a failure, and answer a user. 1

The missing test is not another leaderboard. It is the messy middle between a benchmark and a person's life: ambiguous instructions, stale files, revoked permissions, half-failed API calls, sensitive screenshots, and a user who assumes the agent did more than it actually did. Muse Glimmer has been trained for failure recovery and long-horizon workflows, according to Meta. 1 The developer still has to test whether those behaviors survive the particular scaffold, tools, and data sources they attach.

The idea itself is not new. Local inference already has runners and edge frameworks, and Meta lists several of them as part of Glimmer's path to adoption. 1 Glimmer's fresh contribution is the attempt to package local execution, multimodal input, tool use, and longer agent workflows into a model small enough for consumer hardware. That is a narrower claim than "everyone gets personal superintelligence," but it is the one the hardware can actually support.

Muse Glimmer is a credible open-weight model release with a smart compression story and a useful target: local agents that can see images, call tools, and keep working without a cloud connection. The problem is that Meta's personal-AI fantasy arrives as a developer kit. A 24GB or 32GB GPU gets you a place to run the model, not a safe assistant, a finished integration, or a privacy policy. The local deployment removes one vendor from the data path while handing the rest of the responsibility to whoever builds the wrapper. Use Glimmer if you want to own the runtime and are willing to operate the runtime. If you want an assistant that simply manages your calendar, the open weights are not the product you were promised. They are the parts bin, and the parts bin still needs a mechanic.