Is vector search's silent failure mode worse than keyword search's loud one?

A keyword search that returns zero results is an obvious failure. The user reformulates, or you log it and add a synonym. Vector search never returns zero results. The nearest neighbor always exists. So when the system fails, it does so by confidently returning incorrect results that look identical to the correct ones at the API level.

A few failure modes I keep running into:

• Exact identifiers get smeared: A query for product SKU "XPS-13-9340" embeds near other XPS models, near other 13-inch laptops, near other Dell products. The retrieval looks confident, but it's wrong. BM25 would have either found the exact SKU or returned nothing, and "nothing" is a useful signal
• Negation embeds identically to its inverse: "Laptops without touchscreen" and "laptops with touchscreen" land in nearly the same region of vector space because embedding models don't represent logical operators. The retrieved set is the same. The user received the opposite of what they requested.
• Numerical constraints don't survive embedding: "Hotels under $200" pulls $400 hotels because embeddings don't preserve numerical ordering. The model knows "$200" and "$400" are both prices in the same domain, which is the wrong invariance for this query.
• Low-frequency domain terms get the worst of it: General-purpose embedding models have weak representations for specialized vocabulary (medical, legal, internal product names), so the queries that most need precise retrieval get the least of it.

The pattern across all of these: the failure is invisible at the system level. Your dashboards show queries served, latency green, and the zero-result rate is near 0%. Quality has degraded, but nothing alerts on it. Compare to a keyword-only system, where vocabulary mismatches show up directly as zero-result rates and reformulation patterns in the logs.

The hybrid retrieval pattern (BM25 + vector with RRF or learned fusion) is the most common answer I've seen in production. Lexical handles the exact-match cases vector can't, vector handles the semantic cases lexical can't, and the fusion step decides which signal to trust per query

Curious what other patterns people are running with?

Especially around:

• Detecting silent failures in production (anything beyond click-through and reformulation rates?)
• Query routing strategies (when do you skip the vector path entirely?)
• Reranker tuning when the candidate set is contaminated by hallucinated similarity matches

Context: I'm writing a book, "Designing Hybrid Search Systems", published on Leanpub (early access, ~600 cited references across 20 chapters). I'll share if anyone is interested.