GATE's codebase map reads every file, function and import straight out of a GitHub repo or a GATE site, in 11 programming languages, and draws them as one map you can click through, from areas down to the exact lines. Your agent writes a summary of every file and 3 to 5 guided tours, and the map rebuilds itself every night. GATE maps its own code the same way: 12,139 files in 56 areas.
This is GATE's own code, mapped by Atlas and rebuilt every night. Point at an area to see what it is.
A big repo stops being something you search and hope. It becomes a map with its areas, its busiest files and its important paths called out.
Paste a GitHub link or pick a site you host on GATE, and choose the agent that runs the build. Nothing has to be documented first.
Files, classes, functions and the imports between them come out of the code by the same exact step every time, so two builds of the same commit agree.
Files are grouped into areas by how they actually connect, not just by folder. Your agent names each area and writes a summary of every file.
Three to five guided walks of up to ten steps through the paths that matter, like a request from the front door to the database, with every step explained.
Every night by default, or on every push once the repo's webhook is connected, the map rebuilds. Only files whose content changed get a new summary.
Every map says how far behind your code it is, and you choose what rebuilds it.
Set it once per map. A rebuild that is already running is never started twice.
Nightly is the default. On push rebuilds when your main branch moves, once the repo's webhook is connected. Manual waits until you ask.
Built into the pipeline, not left to the agent.
Everything about the code in one place, from the big picture down to the line.
Open an area to see its files, and a file to see what it imports, what imports it and what it holds. On a GitHub repo, jump straight to the lines.
Press / and search every file, function, area and issue by name or path. The map moves to what you pick.
Every file is ranked by how connected it is, so the files that matter most stand out before you change them.
Oversized files and functions, too many parameters, deep nesting, copied blocks, unused exports, files nothing imports and files everything runs through. A fixed snag closes itself.
On a GitHub repo, the 20 newest open issues and the last 30 pull requests sit in the map, linked to the files they name, and a merged pull request shows as merged.
Mark a feature or an idea and link its chats, issues, pull requests, mockups and code to it. Markers survive every rebuild.
Three ways to learn how a codebase fits together, side by side.
| What you compare | Reading the repo by hand | A diagram someone draws | GATE's codebase map |
|---|---|---|---|
| Where the structure comes from | Your own reading, file by file | Whoever drew it, from memory | Extracted from the code the same way on every build |
| Keeping it current | Read it again after every change | Redrawn when someone has time | Rebuilt every night or on push, and it says how far behind it is |
| Finding things | Search and folder trees | Boxes with names on them | Search every file, function, area and issue with / |
| Explanations | Comments, where someone wrote them | Labels on the boxes | A summary of every file and 3 to 5 guided tours |
| Problems in the code | Found when they cause trouble | Not shown | Eight mechanical checks on every build |
When your agent starts coding in a mapped repo, it is told the map is there and how to read it, so it can find where a subject lives before it opens a file. Ask it in chat where something lives, and it can look it up the same way.
AI coding agentsA codebase map shows how a codebase fits together: its files, classes and functions, the imports between them and the areas they group into. GATE builds one from a GitHub repository or a GATE site, adds a summary of every file and guided tours, and rebuilds it every night, so the map keeps up with the code it describes.
Paste a GitHub link or pick a site hosted on GATE, and choose the agent that runs the build. GATE reads code in TypeScript, JavaScript, Python, Go, Rust, Java, C, C++, C#, Ruby and PHP, groups the files into areas by how they connect, and the agent writes the summaries and tours. Nothing has to be documented first.
No. GATE extracts files, classes, functions and imports with the Tree-sitter code parser, the same way on every build, so two builds of the same commit agree. Areas come from community detection on how the files connect, not one area per folder. The agent writes only the parts that need judgement: the file and area summaries and the guided tours.
On a GitHub repository, yes: GATE pulls the 20 newest open issues and the last 30 pull requests into the map, each linked to the files it names. A pull request is its own kind of item, so a merged one shows as merged rather than just closed. A map of a GATE site holds the code without issues or pull requests.
GATE rebuilds a codebase map every night unless the company chooses otherwise. On push rebuilds it when the main branch moves, once the repository's webhook is connected, and manual waits for someone to ask. Only files whose content changed get a new summary, and every map says how far behind it is: in commits for a GitHub repository, or by age otherwise.
Snags are mechanical problems GATE checks on every build, with no model: 5 or more parameters, a 150-line function, a 1,000-line file, nesting 4 levels deep, a near-identical 15-line block in two or more files, unused exports, files nothing imports, and files with 30 or more functions and classes that 20 or more files import. A snag closes itself once a build stops finding it.
Yes. Every GATE codebase map has a link that can be shared outside the company. The shared link shows only the shape of the code: file and function names, line ranges, how they connect, and issue and pull request numbers. Summaries, tours and issue titles stay with the company, and anyone with the link can open it unless a password is set.
GATE's codebase map is a static map of code as written, not a profiler: it shows how the code fits together, not how it behaves while it runs. GATE stores the imports between files, not which function calls which. It maps GitHub repositories and GATE sites, not other code hosts, and between rebuilds it falls behind, which every map shows.
GATE is invite only while GATE Intelligence onboards a small number of businesses at a time, and codebase maps are in early access, switched on per company. After that, a person creates a map from a GitHub link or a GATE site, or asks the company's agent in the chat to make one, and the first build reads, groups, summarizes and draws the whole repository.
Invite only while we onboard a small number of businesses.