RAG Is Dead, Right? — Kuba Rogut, Turbopuffer

Kuba Rogut (deploy engineer at Turbopuffer, a full-text and vector search database built on object storage) argues that the "RAG is dead" discourse on social media is empirically wrong: Google search volume for RAG hit a new inflection point in mid-2025 and surged, directly contradicting the Twitter narrative. The real problem is a narrow definition of RAG as simple one-shot vector search. Rogut redefines RAG|retrieval-augmented generation as any combination of vector search, BM25|full-text search, grep, glob, regex, and filters used iteratively by an agent—and shows that this richer form is becoming the default for serious agentic search.

Key Takeaways

• "RAG is dead" social media discourse and actual RAG search volume are moving in opposite directions: Google search volume for RAG hit a new inflection point in mid-2025 1:12
• The narrow definition of RAG (one-shot vector search → LLM) is what's dying; retrieval-augmented generation as a broader concept—encompassing BM25, grep, glob, regex, filters—is thriving 1:44
• Cursor (a Turbopuffer customer) achieved a ~24% increase in answer accuracy on their composer model and a 2.6% gain in code retention in large codebases by adding semantic search 5:18
• Claude Code's grep-only approach is not wrong—it's a deliberate tradeoff—but it pays a per-session cost that compounds across many developers and sessions 7:05
• embeddings are cached compute: the decision to index upfront depends on query volume 6:41
• Jeff Dean's framing: "You don't need a trillion at once, you need the right million" 10:19

The RAG-Is-Dead Myth vs. Actual Usage

Rogut opens by displaying a wave of late-2024/early-2025 tweets claiming RAG is dead in favor of agentic file search 0:50. He immediately counters with Google Trends data showing RAG search volume plateaued in 2024, then broke out to a new all-time high in mid-2025 1:12. His stance: the discourse and the usage curve are moving in opposite directions, and practitioners should trust the latter.

Redefining Retrieval

Rogut argues that most critics conflate RAG with its simplest implementation. His definitions:

• RAG (correctly understood): vector search + full-text search (BM25) + grep + glob + regex + filters, feeding results into an LLM 2:00
• Agentic search (commonly misused): just filesystem grep, as exemplified by Claude Code and Codex 2:29
• Agentic search (Rogut's preferred definition): giving agents a set of tools to progressively and iteratively find and reason over context until they reach a satisfactory state 2:46

The key shift is from a single retrieval call to an iterative loop where the agent searches, assesses, and searches again.

Cursor as the Model for Agentic Retrieval

Rogut cites Cursor (one of Turbopuffer's first customers) as the exemplar of agentic retrieval done well 3:19:

• When a user opens a new codebase or branch, Cursor parses, chunks, and embedding|embeds the entire codebase for semantic search 3:40
• To avoid redundant re-embedding across a team, Cursor uses Merkle trees to hash-compare codebases; only changed files are re-chunked and re-embedded 4:18
• Measured outcomes from Cursor's internal benchmarks and an online A/B test: ~24% increase in answer accuracy on their composer model 5:18, 2.6% improvement in code retention in large codebases, and 2.2% decrease in dissatisfied user requests 5:37
• Rogut notes these gains look small but are understated because semantic search does not fire on every query—only queries that benefit from it 5:50

Claude Code vs. Cursor: Embeddings as Cached Compute

Rogut frames the Claude Code / Cursor contrast as a cached compute tradeoff 6:41:

	Claude Code (per-session)	Cursor (upfront-indexed)
Cost structure	Grep → read → assess → repeat every session 7:05	One-time parse/chunk/embed; lightweight query at runtime 7:48
Multi-developer cost	10 agents × 10 days = same expensive steps repeated each time 7:22	Index shared once; all agents query cheaply
Token cost	~6,000 tokens for a single sub-step 7:43	Low-token tool call at runtime 8:07

Rogut is explicit that Claude Code's approach is not wrong—it is a deliberate tradeoff—but notes that Turbopuffer team members who were Claude Code users have switched to Cursor because of speed and semantic quality improvements 8:22.

Toward Iterative, Tool-Rich Retrieval

Rogut's forward-looking claim is that simple RAG (one vector-search call, stuff context, done) worked in 2023–early 2024 but sophisticated users have moved to agentic retrieval: multiple tool calls, semantic and full-text search as needed, fetching only what is required for the specific task 9:03. He invokes Jeff Dean's quote—"you don't need a trillion at once, you need the right million"—made in the context of Gemini's large context windows 9:44, as the underlying principle: staged retrieval is the lightweight mechanism that makes trillion-token corpora usable, and this is what Turbopuffer's customers with trillions of stored tokens rely on to narrow down to the right 10k–1M tokens for any given context window 10:26.