What is Muse Glimmer . How to get started with it in Ollama

Muse Glimmer is a 30-billion-parameter causal language model with a dedicated perception encoder, distilled from Muse Spark and purpose-built for autonomous agentic tasks on consumer hardware. The model integrates multi-step reasoning, reliable tool use, multimodal understanding, and failure recovery into a single model that runs locally without requiring cloud infrastructure or network access.

Get started

To download and run Muse Glimmer with Ollama, use:

ollama run muse-glimmer

Ollama’s MLX engine provides state-of-the-art performance on Apple Silicon, with support for DFlash and image input:

ollama run muse-glimmer:30b-mlx

Model information

End-to-end Agentic Task Completion. Muse Glimmer achieves strong success rates on full-task benchmarks including DeepSearch QA, MCP-Atlas, 𝛕3-Bench and SWE-Bench, which measure its ability to work within scaffolds, write and debug code, and resolve multi-turn requests from start to finish.

Reliable Tool Use. The model handles a wide range of function calls, invoking tools with precise schemas throughout extended workflows.

Multi-Step Reasoning. Muse Glimmer chains reasoning over long horizons, sustaining coherent plans across complex, extended workflows.

Failure Recovery. When a tool call fails or returns an unexpected result, the model diagnoses the error and retries rather than halt.

Multimodal Input and Reasoning. Through a dedicated perception encoder, the model accepts interleaved text and images. This enables agents to interpret screenshots, charts, and documents alongside conversation.

Scaffold Compatibility. Muse Glimmer works across OpenClaw, Hermes Agent, and other agentic orchestration patterns.

Controllable Effort. The model supports different reasoning strengths to select the right balance between quality and speed.

Multilingual. Muse Glimmer is trained on data from more than 100 languages.

What are the major differences between dot product vs Cosine similarity ?

 

Why cosine similarity better than dot product?

 Yes. This is actually an important next step because it lets you explain why a recommendation system often prefers cosine similarity over a raw dot product.

You can add the following section after your dot-product example.

Dot Product vs. Cosine Similarity

The dot product gives us a useful compatibility score, but there is an important limitation.

The dot product depends on both:

1. The direction of the vectors — whether the user and movie have similar preferences.
2. The magnitude (length) of the vectors — how large the numbers are overall.

Cosine similarity, on the other hand, focuses primarily on the direction of the vectors.

$\mathbf a\cdot\mathbf b=a_xb_x+a_yb_y=\lVert\mathbf a\rVert\lVert\mathbf b\rVert\cos\theta$

$\mathbf a\cdot\mathbf b=4(-1)+1(3)=-1$

The angle is obtuse, so the vectors point partly apart and the dot product is negative

Inputs

x, yr, θ

$a_x$

$a_x$

$a_y$

$a_y$

$b_x$

$b_x$

$b_y$

$b_y$

Drag vector a or b

The mathematical relationship

For two vectors $A$ and $B$:

$$A \cdot B = \|A\|\|B\|\cos(\theta)$$

where:

• $A \cdot B$ = dot product
• $\|A\|$ = magnitude of vector $A$
• $\|B\|$ = magnitude of vector $B$
• $\theta$ = angle between the two vectors

Cosine similarity removes the magnitude component:

$$\boxed{ \text{Cosine Similarity}(A,B) = \frac{A\cdot B}{\|A\|\|B\|} }$$

Therefore:

$$\boxed{ \text{Cosine Similarity}(A,B)=\cos(\theta) }$$

For normalized vectors, the dot product and cosine similarity become the same value.

---

Why Does This Matter for Recommendations?

Let's make the difference very concrete.

Suppose we have two users.

User A

This user watches a lot of movies but strongly prefers Action and Sci-Fi:

$$A=[9,1,8]$$

User B

This user watches fewer movies but has almost exactly the same preference pattern:

$$B=[4.5,0.5,4]$$

Notice something interesting.

User B's vector is exactly half of User A:

$$B=0.5A$$

So the two users have the same preference pattern, but User A has larger values.

---

Using Dot Product

Calculate:

$$A\cdot B$$ $$=(9\times4.5)+(1\times0.5)+(8\times4)$$ $$=40.5+0.5+32$$ $$\boxed{73}$$

The dot product is 73.

Now imagine another user:

$$C=[1,1,1]$$

Calculate:

$$A\cdot C$$ $$=(9\times1)+(1\times1)+(8\times1)$$ $$=18$$

So:

$$A\cdot B=73$$

while:

$$A\cdot C=18$$

The dot product strongly favors B.

But there is an important question:

Is B really more similar to A, or does B simply have large numerical values in the same dimensions?

---

Cosine Similarity Removes the Magnitude Problem

First calculate the magnitude of $A$:

$$\|A\|=\sqrt{9^2+1^2+8^2}$$ $$=\sqrt{81+1+64}$$ $$=\sqrt{146}$$ $$\approx12.08$$

For B:

$$\|B\|=\sqrt{4.5^2+0.5^2+4^2}$$ $$=\sqrt{20.25+0.25+16}$$ $$=\sqrt{36.5}$$ $$\approx6.04$$

Now calculate cosine similarity:

$$\text{Cosine}(A,B) = \frac{73}{12.08\times6.04}$$ $$\approx\frac{73}{73}$$ $$\boxed{\text{Cosine}(A,B)\approx1.0}$$

That makes sense.

The two vectors point in exactly the same direction.

Even though their magnitudes are different, their preference patterns are identical.

---

An Even More Important Example

Now consider:

$$D=[90,10,80]$$

This could represent a user who has watched many more movies, but whose relative preferences are the same.

Notice:

$$D=10A$$

Therefore A and D have exactly the same preference pattern.

Their cosine similarity is:

$$\boxed{\text{Cosine}(A,D)=1}$$

because they point in exactly the same direction.

But look at the dot product:

$$A\cdot D$$ $$=(9\times90)+(1\times10)+(8\times80)$$ $$=810+10+640$$ $$=\boxed{1460}$$

So we have:

Comparison	Dot Product	Cosine Similarity
A vs B	73	1.00
A vs D	1460	1.00

This is the key difference.

A and B are just as similar as A and D in terms of preference pattern, but the dot product gives D a dramatically larger score because D has a much larger magnitude.

Cosine similarity correctly recognizes that:

"The two users have the same preference direction, regardless of how large their individual values are."

---

Visual Intuition: Direction vs. Length

Think of each vector as an arrow.

The length of the arrow represents magnitude.

The direction of the arrow represents the pattern of preferences.

Two users could have:

User A:  ───────────────►
User B:  ───────►

They have different magnitudes, but they point in the same direction.

Therefore:

$$\theta=0^\circ$$

and:

$$\cos(0^\circ)=1$$

So their cosine similarity is:

$$\boxed{1}$$

This means maximum similarity.

---

Why Cosine Similarity Is Often Better for Recommendation

Suppose two users have the following preferences:

User 1

$$[9,1,8,0,1]$$

User 2

$$[0.9,0.1,0.8,0,0.1]$$

Their values are very different in magnitude.

But their preference pattern is identical.

Both users essentially say:

"I strongly prefer Action and Sci-Fi, have very little interest in Comedy and Romance."

Cosine similarity identifies this immediately.

The dot product, however, is influenced by the absolute magnitude of the vectors.

This can be problematic when the magnitude represents something unrelated to the actual similarity we want to measure.

For example, magnitude might be affected by:

• number of movies watched
• number of ratings given
• amount of interaction
• frequency of activity
• length of a document
• number of words in a document

In these situations, we often care more about the pattern of preferences than the absolute amount of activity.

That is where cosine similarity becomes particularly useful.

---

But Is Cosine Similarity Always Better?

No.

This is an important point for a machine-learning explanation.

Cosine similarity isn't universally better than dot product.

They answer slightly different questions.

Dot Product asks:

"How strong is the overall interaction between these two vectors?"

It considers both:

$$\text{alignment} + \text{magnitude}$$

Cosine Similarity asks:

"How similar is the direction or pattern of these two vectors?"

It primarily considers:

$$\text{alignment}$$

So the choice depends on what the numbers represent.

---

A Simple Real-World Analogy

Imagine two customers buying products.

Customer A

Buys:

• 10 Action movies
• 2 Comedy movies
• 8 Sci-Fi movies

$$A=[10,2,8]$$

Customer B

Buys:

• 1 Action movie
• 0.2 Comedy movies
• 0.8 Sci-Fi movies

$$B=[1,0.2,0.8]$$

Customer B has the same preference pattern, but much less activity.

Cosine similarity says:

"Their interests are almost identical."

Dot product says:

"Customer A has a much stronger overall interaction."

Both statements can be useful.

If we're trying to identify similar users based on taste, cosine similarity may be more appropriate.

If we're trying to predict strength of interaction or preference, the magnitude may actually contain valuable information, so a dot product can be preferable.

---

The Connection to Machine Learning

This distinction becomes even more important when we move from our simple genre example to embeddings.

Suppose a movie is represented by a 768-dimensional embedding:

$$Movie=[m_1,m_2,\ldots,m_{768}]$$

and a user is represented by:

$$User=[u_1,u_2,\ldots,u_{768}]$$

The dot product is:

$$User\cdot Movie = \sum_{i=1}^{768}u_i m_i$$

Cosine similarity is:

$$\boxed{ \frac{ \sum_{i=1}^{768}u_i m_i }{ \sqrt{\sum_{i=1}^{768}u_i^2} \sqrt{\sum_{i=1}^{768}m_i^2} } }$$

Now the difference becomes very important.

For embedding-based systems such as:

• semantic search
• RAG
• document retrieval
• recommendation systems
• image similarity
• text similarity

we frequently care about whether two embeddings point in similar directions, rather than simply whether their raw values are large.

That's why cosine similarity is so common in embedding-based retrieval.

---

One Very Important Exception

There is an interesting mathematical shortcut.

If we normalize every vector to length 1, then:

$$\|A\|=1$$

and:

$$\|B\|=1$$

Therefore:

$$\text{Cosine Similarity}(A,B) = \frac{A\cdot B}{1\times1}$$

which gives:

$$\boxed{ \text{Cosine Similarity}(A,B)=A\cdot B }$$

So after L2 normalization:

Cosine similarity is simply the dot product of the normalized vectors.

This is an extremely useful connection when you later discuss vector databases and embedding search.

---

The Final Takeaway

You can summarize the entire concept with this comparison:

Property	Dot Product	Cosine Similarity
Measures alignment	✅	✅
Considers magnitude	✅	❌
Measures angle/direction	Indirectly	✅
Sensitive to vector length	✅	❌
Range	Depends on vectors	-1 to 1
Good for preference strength	✅	Sometimes
Good for pattern similarity	Sometimes	✅
Common for embeddings	✅	✅
Same after normalization	—	Yes

The conceptual difference can therefore be stated very simply:

$$\boxed{ \text{Dot Product} = \text{Similarity of direction} \times \text{Magnitude} }$$

while:

$$\boxed{ \text{Cosine Similarity} = \text{Similarity of direction only} }$$

And for your recommendation-engine example, this gives you a natural progression:

User preferences → Movie features → Dot Product → Problem with magnitude → Cosine Similarity → Normalized embeddings → Vector/embedding search.

That progression will make the mathematics connect nicely to modern recommendation systems, RAG and vector databases.