What are Librarian Agents?

A framework in which a **builder model** turns a raw document collection into a filesystem of synthetic files and reference links before any query arrives, and a separate answering agent then navigates that workspace to answer questions.

How is a precomputed workspace different from RAG?

Standard RAG searches the raw documents for **each** query, so cross-document reasoning is repeated. A precomputed workspace does that reasoning once and reuses it, trading an upfront construction cost for cheaper repeated queries.

How does the builder learn what to build?

It is trained with GRPO to maximize a frozen answering agent's accuracy on hidden training queries. The reward combines accuracy changes probed every eight builder turns with a terminal correctness score.

What happens if the synthetic files miss a needed detail?

Each synthetic file keeps reference links to its raw sources and raw documents are never deleted, so the answering agent can follow a link or read the original document instead.

Agent· 2026-10-18

Librarian Agents train builders to curate reusable workspaces — Precomputed agent workspace vs reactive retrieval — What does it mean?

Jargon

RAG: Retrieval-augmented generation: search a document collection for passages, then have the model answer from them. See Retrieve-Then-Generate.
Anticipatory workspace: The paper's name for a filesystem of files and folders built before future queries are seen, so a later agent can find evidence with short, legible paths.
MDP: Markov decision process: a setup where an agent picks an action in a state, the state changes, and a reward arrives. Here the state is the current filesystem and the actions are file edits.
GRPO: Group Relative Policy Optimization, a reinforcement-learning method that updates a language model by comparing several sampled attempts at the same task.
BrowseComp-Plus: A benchmark of deep-research web questions with a fixed document corpus, used here for training (680 tasks) and held-out evaluation (50 tasks).
Provenance link: A stored reference from a synthetic file back to the raw documents it was built from, so a reader can verify a claim or bypass the summary.
Amortization: Spreading a one-time cost over many uses: a workspace that costs tokens to build is cheaper per query the more queries reuse it.

The news. On October 15, 2026, Anikait Singh, Teresa Zhang, Yoonho Lee, Roshen Sanjay Nair, Aviral Kumar and Chelsea Finn published Librarian Agents on arXiv. On BrowseComp-Plus it reports 0.75 accuracy against 0.42 for an embedding baseline with a frozen Qwen3.5-4B answering agent, and 0.77 with a frozen Gemini 3.1 Flash Lite answering agent. Read the paper →

Picture a library whose basement holds thousands of unsorted boxes. A reactive retrieval system is a clerk who walks down to the basement for every visitor and searches the boxes from scratch. Librarian Agents hire a librarian who works before the doors open. In the paper, a builder model edits a filesystem with four actions: CreateFile writes a synthetic file that consolidates some raw documents and keeps reference links to them, MergeFiles rolls related synthetic files into a higher-level summary that adds hierarchy, Delete removes synthetic files that did not help, and Stop ends construction. Delete never touches a raw document, so every original box stays reachable.

A frozen answering agent then moves through the workspace with ordinary file-listing and file-reading actions. Where a standard retrieve-then-generate pipeline searches an index for each query, this workspace is built once and read many times. It is also context engineering moved ahead of time: instead of loading raw material into a scarce context window at query time, the heavy cross-document work happens once, in advance.

The hard part is teaching the librarian what a good shelf looks like without showing it any future question. The authors train a Qwen3.5-4B builder with GRPO and score each finished workspace by how well a frozen answering agent does on queries the builder never sees. To give early edits credit, they probe the answering agent every eight builder turns and reward the change in accuracy, plus a terminal reward for final correctness. Without this training the builder produced a fragmented shelf: on BRIGHT, a benchmark of unseen StackExchange, LeetCode and math domains used to test zero-shot transfer, the untrained builder averaged 4.8 synthetic files, 4.2 clusters and 0.6 merges, while the trained builder averaged 53.4 files, 45.4 clusters and 8.0 merged artifacts.

Two design choices keep the shelf honest. Every synthetic file keeps a provenance link, so when the summary layer omits a detail the answering agent can follow the link to the raw source; the paper shows a case of exactly this recovery. And placement matters, not only content: in an ablation, flattening the same memories kept accuracy comparable but raised navigation cost, while shuffling where files sit lowered accuracy without lowering navigation cost.

On BrowseComp-Plus, Table 1 of the paper compares accuracy and the one-time construction cost in tokens for the precomputing methods; its Librarian Agents accuracy of 0.77 matches the paper's Gemini 3.1 Flash Lite result.

Method	What it precomputes	Accuracy	Construction cost (tokens)
GraphRAG	knowledge graph with a fixed schema	0.36	11,923
AutoCompaction	periodic summaries of past work	0.04	501,637
Builder without RL	synthetic-file workspace, untrained	0.28	127,683
Librarian Agents	synthetic-file workspace, RL-trained	0.77	178,926

Hold three figures fixed from the paper: a one-time construction cost of 178,926 tokens, an answering cost of 9,346 tokens per query on the trained builder's workspace, and the paper's own illustration of 20 queries per document set. Spreading construction over 20 queries gives 178,926 / 20 ≈ 8,946 tokens each, and adding the 9,346 answering tokens gives 18,292, so about 18,300 tokens per query all-in (computed from the paper's figures, which the paper rounds to roughly 18K). With a single query the same workspace would cost 178,926 + 9,346 = 188,272 tokens, so reuse is what pays for construction. The cost is not hidden either: the trained builder's answering agent reads 26.9 files per query against 2.72 for the untrained builder, which is why its raw per-query tokens are higher (9,346 versus 1,238). The paper's reuse analysis reports 33.8% fewer recorded tokens per expected correct answer at ten questions per corpus, because accuracy rises from 0.242 to 0.637 on the amortized set.

Keep the limits in view. The BrowseComp-Plus result rests on 50 held-out tasks, and the BRIGHT transfer test uses 150 questions across three domains with one filesystem per domain. The answering agents are Qwen3.5-4B and Gemini 3.1 Flash Lite, so how the gain looks with larger answering agents is not shown. A workspace can also lose a detail that was needed in hindsight; the provenance links are the paper's mitigation, not a guarantee.

Goes deeper in: AI Agents → Retrieval & RAG → Retrieve-Then-Generate

Related explainers

Evolving procedural memory with a matched-replay gate — a different take on agent memory, where stored skills are rewritten from traffic and gated before they replace the old version.

Frequently Asked Questions

Check what you knowMap your AI & GPU knowledge across every track — free, role-based