The Genome - a live structural map of your codebase

You drop a coding agent into your repo and ask for a small change. Before it edits anything, it spends a dozen tool calls grepping for where things are defined and what uses them. You pay for every one.

Empryo's agent starts with a map instead. Here's a slice of what it sees before you've typed a word. The file and names are an illustrative example:

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

Three lines, and the agent already knows that getCwd is defined on line 17, that more than 110 places call it, and that 92 files depend on this file. Nobody searched for anything. The session hasn't made a single tool call yet.

That map is the Genome: your whole codebase parsed into a ranked summary of files, symbols and dependencies, available to the agent from the first message. Disclosure: I build Empryo, alone and unfunded, and the Genome is its foundation. Most other features build on it.

The cost it removesLink to this section

Without a map, every question about structure 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 costs a tool call, a few seconds and a chunk of the context window. Agents ask these questions constantly, because finding their way around is most of the work in unfamiliar code.

The Genome answers them up front:

• *Where is X?* The file and line are on the map.
• *What does Y export?* It's listed under the file, with signatures.
• *What depends on Z?* The (→N) count shows how many files depend on it, and the callers are listed.

The map is ranked by how much the code is used. When it has to be shortened to fit, the files that matter most stay and one-off scripts drop off the bottom. A 2,000-file repo shrinks to the slice that an engineer who'd worked there for a year would call essential.

Updated after every editLink to this section

A map you can't trust is worse than no map. So the Genome updates after every edit. Rename a symbol or move a function, and the next thing the agent sees reflects the change, including the dependencies. It never reasons about an old version of a file it just rewrote.

Know the impact before the editLink to this section

Each file carries that (→N) number: how many files depend on it, directly or indirectly. Before it changes something 40 other files rely on, the agent knows to check which files usually change with it and to update the ones that depend on it. The build that would have broken three files away doesn't break, because the agent saw the dependency before it made the edit.

A map is not a search resultLink to this section

Search tells you where a string appears. The map tells you what the code *is*: its symbols, their signatures, how they connect, and which ones matter most. Pair it with symbol-level editing, and the agent stops acting like a script piping grep into sed. It starts acting like an engineer who has already read the codebase.

This post covers the static version: the map built by parsing your code. What happened when I let it learn from git history and the agent's own behavior is a separate story. A formatter that ranked #1 in my repo fell to #103, and the number of files the map knew change together grew 37×.