Beyond Reactive RAG: Compiling Unstructured Corpora into Agentic Workspaces

Production AI agents face an architectural bottleneck when reasoning across hundreds of long documents. While context windows have expanded, downstream reasoning degradation remains an empirical reality. When an agent is handed twenty 100k-token documents, latency spikes, costs balloon, and retrieval accuracy drops sharply.

Historically, teams default to two patterns: reactive Vector RAG or precomputed GraphRAG. Both exhibit critical failure modes in autonomous engineering environments.

Canonical analysis published at bohdanhordii.dev.

The Breakdown of Standard Retrieval Stacks

Failure Mode 1: Reactive Inference Overhead

Vector RAG retrieves disconnected chunks. The answering agent must synthesize disjoint fragments at inference time, executing complex cross-document deduplication while burning production context tokens on administrative reasoning.

Failure Mode 2: Rigid Knowledge Graph Schemas

GraphRAG attempts precomputation via entity-relationship extraction. However, real-world engineering corpora resist rigid triple extraction (Entity)-[Predicate]->(Entity). Maintaining heuristic ontology extractors creates brittle data pipelines that fail when document formats shift.

Traditional Reactive RAG:
Raw Docs ---> Chunking ---> Vector Store ---> Reactive Fetch ---> Inference Bottleneck

Librarian Agent Paradigm:
Raw Docs ---> RL Builder Agent ---> Synthesized Hierarchical Workspace ---> Deterministic POSIX Traversal

The Librarian Architecture: Anticipatory Directed Curation

The breakthrough lies in treating corpus indexing as an agentic Markov Decision Process (MDP). Rather than parsing raw text into chunks or static graphs, an RL-trained Builder Agent transforms raw corpora into an active filesystem workspace.

This workspace consists of:

1. Curated primary sources: Normalized, partitioned documents.
2. Synthetic index files: Cross-document tables of contents and thematic maps.
3. Deterministic reference links: Symlinks and structured relative paths.

The builder policy is optimized directly against the accuracy of a downstream Consumer Agent using reinforcement learning.

Architectural Blueprint (Python Skeleton)

from dataclasses import dataclass
from pathlib import Path
from typing import Protocol

@dataclass(frozen=True)
class WorkspaceAction:
    action_type: str  # 'MKDIR', 'WRITE_SYNTHETIC', 'LINK', 'INDEX'
    target_path: Path
    content: str | None = None
    source_path: Path | None = None

class WorkspaceEnvironment(Protocol):
    def execute(self, action: WorkspaceAction) -> bool: ...
    def snapshot_state(self) -> dict: ...

class LibrarianBuilder:
    def __init__(self, policy_model, env: WorkspaceEnvironment):
        self.policy = policy_model
        self.env = env

    def compile_workspace(self, raw_documents: list[Path]) -> Path:
        """
        Executes MDP rollout to construct a structured workspace
        optimized for downstream agent discovery.
        """
        state = self.env.snapshot_state()
        terminated = False

        while not terminated:
            action = self.policy.predict_next_action(state, raw_documents)
            if action.action_type == "TERMINATE":
                break
            self.env.execute(action)
            state = self.env.snapshot_state()

        return Path("/workspace/curated")

Production Benchmarks and Cost Amortization

Evaluating this architecture on complex multi-hop benchmarks demonstrates why workspace compilation outperforms chunk retrieval:

• Accuracy Uplift: Achieves a +33 percentage point improvement on BrowseComp-Plus compared to state-of-the-art vector and heuristic graph baselines.
• Zero-Shot Generalization: Delivers a +31 point gain on the BRIGHT benchmark across unseen technical domains.
• Amortized Unit Economics: While upfront compilation consumes more tokens during the Builder phase, the per-query cost drops exponentially for subsequent queries. By query 5, the cumulative token expenditure falls below that of standard reactive agentic search.

Engineering Best Practices for Agent Infrastructure

1. Leverage Existing POSIX Tooling: Equip downstream answering agents with battle-tested CLI utilities (grep, find, head, jq) instead of bespoke vector client libraries. Standard filesystems are the most battle-tested retrieval interface ever built.
2. Decouple Builder and Consumer Policies: Use an asymmetric model harness. A reasoning-heavy model acts as the Librarian to build the filesystem; a smaller, latency-optimized model acts as the downstream task worker.
3. Isolate Workspaces in Ephemeral Containers: Run curated workspaces within isolated Docker volumes. This guarantees reproducibility, zero-trust perimeter control, and instant distribution across multi-agent swarms.

Proactive workspace compilation shifts intelligence from frantic runtime retrieval to deterministic structural preparation.

Author: Bohdan Hordii | Website: bohdanhordii.dev | Contact: @bohdan_hordii