Parse the user prompt before the model ever sees it

Someone files a bug against your agent and it reads like this: "The POST /api/v2/refunds endpoint throws DecimalConversionError in billing/processors.py after #4821 merged." That string holds an API route, an exception class, a file path, and an issue reference. Four retrieval keys, sitting in plain sight. Most agent stacks hand the raw string to the model and let it decide what to search for.

Deterministic extraction is a solved problem#

Long before you need a language model, thirty lines of parsing gets you:

• File paths: anything matching path grammar, validated against the actual file tree, with near misses fuzzy-matched.
• Symbols and signatures: CamelCase and snake_case identifiers, module.func() call syntax, function signatures, validated against your symbol index (part 4).
• Stack traces: a pasted traceback has a rigid grammar in every language. Parse it fully rather than summarizing it.
• Issue and PR references: #4821, JIRA-123, resolved through an API into titles, diffs, and linked commits.
• URLs and API endpoints: a route pattern maps straight onto a router definition in the codebase.
• Version and config literals: package names, versions, environment variable names, feature flags.

Every extracted entity is a verified anchor. It either resolves against your index or it does not. That check is binary, and it is the check a generative approach cannot give you, so an invented file path or a misremembered function name survives into the next call instead of being dropped at the door.

# Thirty lines, no model, runs before the first call.
PATH   = re.compile(r"\b[\w./]+\.(py|ts|go|rs|java)\b")
SYMBOL = re.compile(r"\b([A-Z][A-Za-z0-9]+|[a-z_][a-z0-9_]{2,})\(?\)?")
ISSUE  = re.compile(r"#(\d+)|\b([A-Z]{2,}\-\d+)\b")

def anchors(prompt, index):
    found, dropped = [], 0
    for raw in PATH.findall(prompt) + SYMBOL.findall(prompt):
        hit = index.resolve(raw)   # None when the tree has no such path or symbol
        if hit:
            found.append(hit)
        else:
            dropped += 1
    metrics.record("anchor_resolution_rate", len(found), dropped)
    return found

From entities to a retrieval plan#

The output of parsing is not decoration. It is an execution plan that runs before inference begins:

plan = build_retrieval_plan(prompt)
# {
#   anchors:   [File("billing/processors.py"), Symbol("DecimalConversionError"),
#               Route("POST /api/v2/refunds"), Issue(4821)]
#   expand:    graph_neighbors(anchors, hops=1)      ← Part 4
#   tests:     tests_covering(anchors)               ← Part 10
#   schema:    tables_touched(anchors)               ← Part 8
#   budget:    8_000 tokens, ranked by relevance
# }

The model's first call now holds the right file, its direct dependencies, the covering tests, and the issue diff, assembled by code, ranked by graph centrality, and cut to budget. Compare that to the common pattern, where the model spends its first five calls, each carrying a growing history, rediscovering what a regex had at millisecond zero.