GrepSeek: Search Agents That grep the Corpus Instead of a Vector Index

Quick answer

GrepSeek is a search agent that treats the raw text corpus as its environment and finds evidence by running shell commands — grep, pipes, regex — instead of querying a pre-built embedding index. Trained in two stages (a cold-start dataset of verified search trajectories, then GRPO reinforcement learning), it posts the strongest overall token-level F1 and Exact Match across seven open-domain question-answering benchmarks, and a sharded-parallel execution engine speeds the shell-based retrieval by up to 7.6x while staying byte-exact identical to serial execution.

Why “search the corpus directly” is a different idea

Standard retrieval-augmented generation does one thing: embed every document, embed the query, fetch the nearest vectors. That index is a frozen, lossy summary of the corpus — you only ever see what the embedding model decided to encode, and rebuilding it is expensive whenever the data changes. GrepSeek’s direct corpus interaction (DCI) drops the index entirely. The agent interacts with the actual bytes of the corpus the way a developer searches a codebase: issue a literal or regex search, read the hits, refine the pattern, follow leads. There is nothing to pre-index and nothing to go stale.

The honest framing: this is closer to “teach a model to use a search engine’s command line” than to “replace retrieval.” Lexical shell search is exact where embeddings are fuzzy, and fuzzy where embeddings are exact — which is exactly the trade the paper ends up confirming.

How GrepSeek is trained

The pipeline has two stages, and the first one is the clever part.

Cold start with a Tutor and a Planner. To get an initial set of good search trajectories, GrepSeek uses two roles. An answer-aware Tutor knows the gold answer and can therefore steer toward queries that actually find the evidence. An answer-blind Planner does not see the answer and must reason like the deployed agent will. Pairing them produces trajectories that are both effective (the Tutor keeps them on-target) and realistic (the Planner’s moves don’t secretly depend on knowing the answer). Only verified trajectories — ones that actually surface the supporting text — make it into the cold-start dataset.

GRPO refinement. The cold-started policy is then refined with Group Relative Policy Optimization, the same critic-free RL algorithm popularized by DeepSeek-R1: sample a group of trajectories, score them by whether they led to a correct answer, and push the policy toward the relatively better ones. This is where the agent learns task-oriented search behavior — when to broaden a pattern, when to stop, how to chain commands — rather than imitating the cold-start traces.

The execution engine nobody mentions but everybody needs

Running grep over a large corpus on every agent step is slow, and a learning loop issues a lot of steps. GrepSeek’s semantics-preserving sharded-parallel execution engine splits the search across shards and runs them concurrently, delivering up to 7.6x speedup while guaranteeing byte-exact equivalence to the serial result. That last clause matters: a parallel search that quietly reordered or dropped matches would corrupt the training signal. Keeping it byte-identical is what makes the speedup usable for RL rather than just for demos.

Key results

• Best overall token-level F1 and Exact Match across seven open-domain QA benchmarks — GrepSeek leads on the aggregate of both metrics versus the compared retrieval and agent baselines.
• Up to 7.6x faster retrieval from the sharded-parallel engine, with byte-exact equivalence to serial shell execution preserved.
• Index-free operation: no embedding model, no vector store, no re-indexing when the corpus changes — the agent searches the corpus as-is.
• The two-role cold start (answer-aware Tutor + answer-blind Planner) is what yields verified, realistic trajectories before any RL.

Limits and open questions

The paper’s own analysis names the ceiling: purely lexical interaction struggles on queries with substantial surface-form variation — synonyms, paraphrases, morphology, anything where the answer text shares little vocabulary with the question. That is precisely the regime dense retrieval was invented for, and the authors conclude DCI works best alongside embedding-based retrieval, not as a wholesale replacement. So the realistic deployment is hybrid, and the paper does not fully chart where the crossover lies.

Two more open points. The headline result is reported as best aggregate F1/EM rather than a margin-by-margin sweep, so how large the win is on each individual benchmark — and against the strongest agentic-RAG baselines specifically — is worth reading the full tables for. And the 7.6x speedup is an engineering win on shell search latency, not a statement about end-to-end agent cost; the GRPO training loop and multi-step inference remain the expensive parts.

FAQ

How does GrepSeek search without an embedding index?

GrepSeek treats the corpus as a filesystem and issues executable shell commands — grep, regex, pipes — to find matching passages directly in the raw text. There is no vector database; the agent reads the actual bytes, so nothing needs pre-indexing or rebuilding when the data changes.

What is direct corpus interaction (DCI)?

DCI is GrepSeek’s paradigm where the search agent’s environment is the corpus itself rather than a retrieval API. The model finds evidence by running and refining shell searches, the way a programmer greps a codebase, instead of submitting a query to a frozen embedding index.

How is GrepSeek trained?

Two stages. First a cold-start dataset of verified search trajectories built by pairing an answer-aware Tutor with an answer-blind Planner. Then Group Relative Policy Optimization (GRPO) reinforcement learning refines the policy toward task-oriented search behavior.

Does GrepSeek replace RAG and dense retrieval?

No. The authors show purely lexical shell search falls down on queries with heavy surface-form variation (synonyms, paraphrases), where dense retrieval is strong. GrepSeek works best as a complement to embedding-based retrieval, not a full replacement.

One line: train an agent to grep the corpus instead of querying a vector index, and lexical search becomes competitive on open-domain QA — as long as you pair it with dense retrieval for the paraphrase cases. Read the original paper on arXiv.