How to Run Muse Glimmer AI Locally on Your Notes

Last verified: August 26, 2026. Running open source Muse Glimmer AI for local notes is workable today, with one naming caveat: Meta calls Muse Glimmer an Apache 2.0 open model, but for setup planning it is safer to call it open-weight rather than fully open source, because the released package does not include the training code or training data. Meta released Muse Glimmer on August 10, 2026 as a 30B local agentic model, and Ollama already exposes a runnable 4-bit path at about 18 GB with 128K context support. That is the tempting number. The number I would plan a real notes workflow around is closer to a 24 GB working envelope, with 32 GB feeling much less brittle once long context, KV cache, vision components, and optional acceleration pieces enter the session. [1][2]

The practical verdict is simple: Muse Glimmer can sit beside an Obsidian vault and answer questions over private markdown notes, but the setup only feels “local-first” instead of “terminal-first” if you clear three known breakpoints before you start indexing: memory headroom, Ollama’s Obsidian CORS setting, and the first embedding pass over the vault. The model pull is not the hard part.

One quick disambiguation before the commands: this is Meta’s Muse Glimmer 30B model. It is not Google’s Muse AI notebook product, not Glimmer.js, and not an unrelated GitHub organization with a similar name. The path below uses Ollama first, then Obsidian plugins. Logseq and plain markdown users can keep the same model/runtime pieces, but the plugin screenshots and settings names will not map one-to-one.

Verified setup frame

If you are choosing Obsidian specifically because it lets you bring your own model, this is the setup path that makes that choice pay off. The same argument comes up in our OneNote-to-Obsidian migration guide: local markdown is not just a storage preference; it is what makes swapping AI runtimes possible later.

Why Muse Glimmer is worth testing on notes at all

The case for Muse Glimmer is not that it magically turns a markdown vault into a perfectly managed second brain. The case is narrower and more useful: it is a 30B-class local model designed for agentic work, with enough file-and-document evidence to justify spending the setup time. LM Studio’s BionicBench v0.1 result has Muse Glimmer completing 83.3% of real document and file tasks, compared with 77.7% for Gemma 4 31B. That is not an Obsidian benchmark, but it is the right kind of signal for note work because the task shape is closer to “inspect these local files and act” than to a trivia leaderboard. [3]

Wavect’s analysis of Meta’s table puts Muse Glimmer at 75.5 on MCP-Atlas and 74.6 on DeepSearch QA in its size class, again with the usual caution that these are not private-vault tests. The more relevant lesson for notes is that Muse Glimmer looks competent enough to be tested as a local retrieval-and-writing assistant, while still needing careful prompts for multi-step work. DataCamp’s hands-on coding tutorial reached a similar operating conclusion: Glimmer was fast, but it behaved better when given explicit step-by-step instructions and was weaker at independent multi-step debugging. For notes, that means prompts should ask it to cite note titles, separate evidence from synthesis, and proceed in stages rather than “organize my whole vault.” [4][5]

Meta also makes DFlash part of the launch story, with reported speedups of 3.1x on RTX 5090, 1.8x on M5 Max, and 1.5x on M4 Max. Keep those numbers attached to that hardware. They are useful because they show why Meta is pushing this as an on-device model; they do not prove that a laptop with tight unified memory will enjoy the same behavior while Obsidian is indexing thousands of markdown files. [1]

Plan memory for the full session, not the model file

The most common bad Muse Glimmer plan is built around one true number used in the wrong place. Ollama lists the 4-bit model at about 18 GB. Unsloth says Muse Glimmer runs on 18 GB RAM or VRAM and gives quantization tiers as low as 12–14 GB for 2-bit, while its 8-bit tier rises to 34 GB and BF16 goes beyond 58 GB. DataCamp measured about 23.8 GB VRAM for the full stack on an RTX 5090 using dynamic quantization, drafter, and vision encoder at 64K context. Meta’s own K-Quant targets point at 24 GB and 32 GB brackets. These are not contradictions so much as different slices of the same run. [2][5][6][1]

There is also a vision-encoder footnote that matters if you are counting every gigabyte. Meta’s launch material describes a 2B vision component, while Hugging Face materials describe the perception encoder at roughly 1.8B. I would not build a hardware decision around the difference; I would treat both as confirmation that the stack is more than a text weight file. [1][7]

A 16 GB machine is therefore not an automatic “never,” but it is the wrong machine for this walkthrough if your expectation is a full, calm vault assistant. You may be able to run aggressive 2-bit or 3-bit variants with short context and no spare room, but that is a constrained experiment, not the setup I would recommend for thousands of notes. If the machine swaps while Obsidian is also embedding files, the private local dream turns into a fan-noise benchmark.

Install Muse Glimmer through Ollama

Start with Ollama because it is the shortest reproducible path and because most Obsidian local-AI plugins already know how to talk to it. The canonical command is the one Ollama publishes for Muse Glimmer: [2]

ollama run muse-glimmer

On Apple Silicon, Ollama also lists an MLX build: [2]

ollama run muse-glimmer:30b-mlx

After the pull finishes, do not jump straight to Obsidian. Confirm that Ollama sees the model and that the local server is responding.

ollama list
curl http://localhost:11434/api/tags

Then run one plain local prompt before involving your vault:

ollama run muse-glimmer "Reply with one sentence confirming you are running locally."

This small check separates model problems from plugin problems. If the terminal works and Obsidian fails later, you can stop blaming the weights.

Fix Obsidian-to-Ollama CORS before installing three more things

The Obsidian Copilot local setup guide documents the failure that wastes the most time: Copilot cannot reach Ollama from Obsidian unless Ollama is started with an origin that allows Obsidian. Without it, requests can fail as silent CORS errors. The setting to add is OLLAMA_ORIGINS=app://obsidian.md*. [8]

On macOS, set it with launchctl, then fully restart Ollama. Quitting only the terminal tab is not enough if Ollama is running as a menu-bar app or background service.

launchctl setenv OLLAMA_ORIGINS "app://obsidian.md*"
# Quit Ollama completely, then reopen it.
# If you run Ollama manually instead:
OLLAMA_ORIGINS="app://obsidian.md*" ollama serve

On Linux, the same principle applies: the environment variable must exist in the process that starts the Ollama server.

OLLAMA_ORIGINS="app://obsidian.md*" ollama serve

On Windows PowerShell, set the variable, then restart Ollama from a fresh process.

setx OLLAMA_ORIGINS "app://obsidian.md*"
# Close and restart Ollama after setting this.

Re-run the terminal model prompt after the restart. If the model still answers locally from the terminal, move to Obsidian. If it does not, fix Ollama first; plugin settings cannot repair a server that is not actually running with the environment you think it has.

Wire Obsidian: chat first, retrieval second

For Obsidian, the cleanest split is Copilot for chat against a local model and Smart Connections for vault retrieval. PromptQuorum’s 2026 Obsidian local-LLM roundup treats that pairing as covering roughly 80% of second-brain use cases, while also noting Local GPT as the stricter no-cloud-providers-by-construction option. That 80% is a workflow synthesis, not a measured universal success rate, but the pairing matches how most markdown vault work actually happens: ask, retrieve, summarize, link, rewrite. [9]

In Obsidian, open Settings, then Community plugins. Install and enable Copilot. In the Copilot settings, choose the local/Ollama provider path, set the Ollama host to your local server, and set the chat model to muse-glimmer. Plugin labels move around across versions, so look for the fields that correspond to these values rather than expecting the exact same UI text:

Ollama lists reasoning strengths for Muse Glimmer as low, medium, high, and xhigh. For local notes, start lower than your ego wants. A long vault prompt plus a high reasoning setting is a good way to discover whether the KV cache, not the model download, is the real limit. [2]

Choose an embedding model and budget the first index

Muse Glimmer is the chat/reasoning model in this setup. Your vault search still needs embeddings unless the plugin is doing a simpler file-context pass. A common local embedding choice in Obsidian/Ollama guides is nomic-embed-text, so pull it before starting the first vault index if your plugin supports it. [9]

ollama pull nomic-embed-text
ollama list

Then open Smart Connections or Copilot’s vault/retrieval settings and point embeddings at the local Ollama embedding model. Start with one folder if your vault is large. A first pass over a clean, known folder gives you a sanity check before the plugin spends an hour chewing through archived web clips, old meeting notes, and imported PDFs converted to markdown.

Those two reports do not reconcile into a neat average, so do not average them. Treat first-index time as a range. The difference between 2,000 short atomic notes and 2,000 huge imported documents matters. So does whether another local model is already occupying memory.

Run prompts that prove it is reading your vault

Once indexing finishes, avoid the useless test prompt: “What is in my vault?” It can produce a confident generic tour without proving retrieval. Use prompts with checks you can verify in seconds:

• “Find notes that mention [a project name I know exists]. Return note titles first, then a two-sentence synthesis.”
• “Compare my notes on [topic A] and [topic B]. Quote or name the source note for each claim.”
• “List unresolved decisions from my recent meeting notes. Do not infer decisions unless a note explicitly says they are pending.”
• “Suggest five internal links for this note, but explain why each link belongs before I accept it.”
• “Draft a summary of this folder. Separate direct evidence from your own synthesis.”

The point is not to catch the model making one mistake and declare the setup dead. The point is to verify the pipeline: Obsidian can reach Ollama, embeddings point at the right vault, retrieval returns real note context, and Muse Glimmer can follow a constrained instruction over that context. If you are comparing this with cloud agents, our profiles of frontier AI models for Obsidian notes and Claude organizing Obsidian notes are the contrast case: stronger remote reasoning, but with a different privacy and dependency model.

What broke, and the fix that prevents it

The CORS item is the one to fix before you even open the plugin settings. The memory item is the one to fix before you buy into a 128K-context fantasy on a tight machine. The indexing item is the one to fix before starting the full vault five minutes before a meeting.

A minimal end-to-end runbook

1. Confirm you have realistic memory headroom: 24 GB as the practical floor, 32 GB preferred.
2. Install or update Ollama.
3. Run ollama run muse-glimmer, or ollama run muse-glimmer:30b-mlx on the Apple Silicon MLX path.
4. Confirm the model answers from the terminal.
5. Set OLLAMA_ORIGINS=app://obsidian.md* in the process that starts Ollama.
6. Fully restart Ollama and re-test the terminal path.
7. Install Copilot in Obsidian and point it at http://localhost:11434 with muse-glimmer as the chat model.
8. Pull a local embedding model such as nomic-embed-text if your plugin retrieval path supports it.
9. Index one folder first, then the full vault.
10. Run note-grounded prompts that require titles, quoted evidence, or explicit source-note references.

Escape hatches if Ollama is not your runner

Ollama is the path I would use first for Obsidian because the plugin ecosystem already expects it. If you prefer an app-managed runtime, LM Studio’s Bionic path runs Muse Glimmer locally and exposes a localhost server at port 1234. That can be useful if your plugin supports OpenAI-compatible local endpoints and you prefer model management through LM Studio. [3]

If you need a specific quantization file or want to inspect available GGUF variants directly, Hugging Face hosts Meta’s Muse Glimmer 30B GGUF materials. That is a better escape hatch for people already comfortable choosing quant files; it is not the friendlier first setup for an Obsidian vault. [7]

If what you actually want is the highest reasoning quality and you can tolerate cloud processing, a cloud setup may still be the better fit. Our Gemini Gems and Obsidian workflow is the opposite trade: less local control, more remote model strength. For sensitive vaults, the privacy/security decision is the first fork; the comparison framework is in our AI note-taking app security comparison.

Fit / no-fit verdict

Use Muse Glimmer locally for notes if you already keep your knowledge base in markdown, can budget the full memory envelope, and are willing to spend setup time on plugin wiring rather than paying ongoing token rent. It is especially attractive if your work involves private research notes, meeting notes, project journals, or drafts that you want queried without sending the vault to a hosted model.

Skip it or wait if you are on a constrained 16 GB machine, need frontier-cloud reasoning quality, or cannot tolerate Obsidian plugin troubleshooting. The model can run; the useful question is whether the whole notes workflow can run. With the CORS fix applied, memory planned honestly, and indexing treated as a real job instead of an afterthought, Muse Glimmer is one of the first local models I would seriously test beside a private vault.

References

1. Introducing Muse Glimmer: An Open Agentic Model That Runs on Your Device, Meta AI, August 10, 2026
2. muse-glimmer - Ollama, Ollama
3. Run Muse Glimmer locally, LM Studio
4. Muse Glimmer 30B: is Meta's local agent model production-ready?, Wavect
5. How to Run Muse Glimmer 30B Locally for AI Coding, DataCamp
6. Muse Glimmer - How to Run Locally | Unsloth Documentation, Unsloth Documentation
7. Muse Glimmer, Hugging Face
8. Local Copilot Setup Guide, GitHub
9. Obsidian + Ollama: 5 Local LLM Plugins for Your Vault (2026), PromptQuorum
10. Obsidian Local AI 2026: Connect Ollama with 3 Plugins, LocalAIMaster
11. Running a Local AI Inside Obsidian with Ollama, OpenResource