Word2Vec produces embeddings, where each token has one fixed vector regardless of surrounding context. SBERT produces embeddings, where the same word can map to different vectors depending on the sentence it appears in.
**The contrast** is static versus contextual.
Static means each word has one vector, period. Word2Vec, GloVe, and FastText all live in this regime. Train the model once, get a lookup table, and at inference time you just look up the word. The vector for 'bank' is identical whether the sentence is about a river or about interest rates.
Contextual means the vector depends on the surrounding words. SBERT and the modern sentence-embedding family (E5, BGE, GTE, Voyage v3) take a whole sentence as input and run it through a transformer. The transformer's attention layers let every word's representation depend on every other word's. The final sentence vector therefore differs when the same word appears in different contexts.
The two blanks in the question are the canonical labels: 'static' (or one of its synonyms: context-free, non-contextual, fixed) and 'contextual' (or context-dependent, context-aware, dynamic).
Why it matters: real language depends on context to mean what it means. 'I deposited my check at the bank' and 'the river flooded the bank' contain the same token but completely different meanings. Static embeddings collapse this; contextual embeddings preserve it. For sentence retrieval and RAG, that difference shows up as large gaps on every benchmark.
**Static** versus **contextual** is the cleanest one-word framing of the architectural split between Word2Vec and SBERT.
A static embedding is a function from a single token to a single vector, learned once and frozen. The function ignores everything outside the token itself. Word2Vec, GloVe, and FastText are all static. The famous demonstration was the linear analogy `king - man + woman \approx queen`: the structure of the static vector space captures co-occurrence regularities but not contextual meaning.
A contextual embedding is a function from a sentence to a vector (or to a set of per-token vectors, one per position). The function processes the whole input together so attention can mix information across positions. SBERT pioneered the recipe of running a pre-trained transformer over the sentence and pooling the contextual hidden states into one sentence vector.
The modern descendants (E5-large, BGE-M3, GTE-Qwen2, Voyage v3, Cohere Embed v4) all share this architecture and dominate every retrieval benchmark.
Three consequences flow from the architectural difference.
Polysemy resolves. The contextual representation of 'bank' near 'river' differs from 'bank' near 'interest'. Static embeddings cannot do this because they have no input to condition on.
Word order matters. The transformer's positional embeddings tie attention to position, so 'dog bites man' and 'man bites dog' produce different sentence vectors. Static embeddings averaged into a sentence vector are bag of words and order-agnostic.
The inference cost shifts. Static is a lookup (essentially free); contextual is a transformer forward pass (milliseconds per sentence). For production RAG the quality gain is worth the cost, which is why contextual sentence embedders are the universal default in 2026.
Quick reference
TL;DR
Word2Vec is static (one vector per token, always the same); SBERT is contextual (one vector per sentence, sensitive to surrounding words).
Picture an old dictionary versus a smart reader. The dictionary lists one definition per word, so the word bank has one entry no matter what sentence it's in. The smart reader, by contrast, reads the entire sentence before deciding what bank means right here. If the sentence mentions a fishing trip, the reader pictures a river. If it mentions interest rates, the reader pictures a building. Word2Vec is the dictionary; SBERT is the smart reader. The two blanks are the labels for these two regimes.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Educational settings where you want to demonstrate the linear-analogy property (king - man + woman ≈ queen). The analogy property is a feature of static co-occurrence based vectors. Contextual embedders don't exhibit the same clean algebra because their geometry is non-linearly tied to sentence structure.
Cold-start recommender systems with no labeled interaction data. Static embeddings on entity co-occurrence (item sequences, user histories) are cheap to train and often outperform contextual approaches that need labeled query-document pairs.
Pipelines where the downstream consumer is a linear model and you want interpretable feature contributions. Static vectors are stable features a linear model can weight cleanly. Contextual sentence vectors entangle every dimension with every input token, which fights downstream interpretability.
Quick scan · 2–4 min
Everything important, quickly.
5 min: name the two regimes (static, contextual), give the polysemy example as the central reason the distinction matters, walk through the mechanism difference (lookup table versus transformer forward pass), and close on where each family still appears in 2026.
Real-world examples
Real products, models, and research that use this idea.
1Word2Vec on Google News (2013): the original static-embedding release that established the regime.
2FastText with character n-grams (Bojanowski et al., 2017): still static per-token but with subword composition for OOV.
3Sentence-BERT (Reimers & Gurevych, 2019): introduced the contextual sentence-embedding pattern that the modern family descends from.
4Voyage v3 and Cohere Embed v4: 2026 production contextual embedders used in enterprise RAG over multilingual corpora.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QAre there contextual representations that are NOT one vector per sentence?
Sign in or go Pro to see the approach for this follow-up.
QWhy does the pooling choice (mean vs CLS vs last-token) matter for contextual sentence embedders?
Sign in or go Pro to see the approach for this follow-up.
QCan a static embedding ever beat a contextual one at retrieval?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Filling the second blank with 'transformer-based' or 'sentence-level': both true but not the contrasting term. The clean opposite of 'static' in embedding terminology is 'contextual'.