Here's a slice of what Empryo's agent sees before you've typed a word:

packages/base/src/cwd.ts: (→92)
  +function getCwd(): string :17  [createModel, handleCommand, +110↑]
  +function setCwd(dir: string): string :31

One file, three lines, and the agent already knows: getCwd lives at line 17, 110+ call sites use it, and 92 files break if this file changes. Nobody grepped anything. The session is zero tool calls old.

That block is the Genome — the whole codebase parsed into a ranked structural map and held in context from the first message. Disclosure, as always: I build Empryo, alone and unfunded, and the Genome is its foundation. Every other feature stands on this one.

The tax it removes

Drop an agent into a repo without a map and every structural question costs a round-trip. Where is validateToken defined? One grep. What depends on this file? Another. What does this module export? Read the file. Each answer burns a tool call, a few seconds, and a slab of context window — and the agent asks these questions constantly, because orientation is most of what an agent does in unfamiliar code.

The Genome answers them for free:

*Where is X?* → file and line, straight off the map.
*What does Y export?* → listed under the file, with signatures.
*What depends on Z?* → the (→N) blast-radius count plus the importers.

The map is ranked by usage, so the files that matter most survive truncation and the one-off scripts fall off the bottom. A 2,000-file repo compresses to the slice an engineer who'd worked there a year would call load-bearing.

Rebuilt after every edit

A map you can't trust is worse than no map. So the Genome regenerates after every edit: rename a symbol, move a function, and the next thing the agent sees reflects the change, dependency edges included. It never reasons against a stale snapshot of a file it just rewrote.

Blast radius before the blast

Each file carries that (→N) number — how many files import it, directly or transitively. Before touching something 40 others depend on, the agent knows to check the co-change graph and sweep the dependents. The build that would have broken three files over doesn't break, because the agent saw the edge before it made the edit.

A map is not a search result

Search tells you where a string appears. The map tells you what the code *is* — symbols, shapes, relationships, and which of them carry weight. Pair it with symbol-level editing and the agent stops behaving like a script piping grep into sed and starts behaving like the engineer who already read the codebase.

The map described here is the static version — the parse. What happened when I let it learn from git history and the agent's own behavior is its own story: a formatter ranked #1 in my repo fell to #103, and the co-change graph grew 37×.