Your agents get the one function,
not the whole file.

Short version: RepoMapper is a ranked repository "map" (great for orientation and "what matters?"), while jCodeMunch is symbol-accurate retrieval (great for "show me the exact code" with tiny token spend). They overlap, but they're optimized for different jobs.

• RepoMapper generates a "repo map" that highlights important files/definitions and relationships using Tree-sitter parsing plus a PageRank-like importance ranking. Best for first-pass orientation: "Which files matter for this task?"
• jCodeMunch is symbol-first, not file-first: agents search and retrieve functions/classes/methods/constants directly via byte-offset seeking in O(1) time. File reads become the exception, not the default.
• Scaling: maps get bigger as repos grow; targeted symbol pulls stay tiny even in massive repos.

They do different jobs, and you can run all of them together. caveman shortens what the model says back and, since 4.0, compresses noisy logs and data on the way in. Ponytail keeps it from writing more code than the task needs. RTK trims what terminal commands print. Headroom compresses everything flowing into the prompt. jCodeMunch covers the code the agent reads.

Real ones. The more code your agent has to wade through, the more jCodeMunch saves on every lookup, and it answers the questions that matter on a big codebase: who uses this, what breaks if I change it, where to start in code you don’t know. On a handful of files your agent’s built-in search is already quick.

jCodeMunch works with any client that supports the Model Context Protocol (MCP), including:

• Claude Code: Anthropic's CLI for Claude, with native MCP support
• Google Antigravity: Google's AI coding agent
• Cursor: AI-native code editor
• Gemini: Google's AI assistant with MCP integration
• Any other MCP-compatible client or custom integration

Antigravity uses a standard MCP config file: setup takes about a minute.

• Install the server: pip install jcodemunch-mcp
• In Antigravity, open the Agent pane → click the ⋮ menu → MCP Servers → Manage MCP Servers
• Click View raw config to open mcp_config.json
• Add the entry below, save, then restart the MCP server from the Manage MCPs pane

{
  "mcpServers": {
    "jcodemunch": {
      "command": "jcodemunch-mcp",
      "env": {
        "GITHUB_TOKEN": "ghp_...",
        "ANTHROPIC_API_KEY": "sk-ant-..."
      }
    }
  }
}

Larger context windows have diminishing returns for code retrieval:

• Cost scales linearly: in the demo above, grep-and-read costs about $0.51 a query and jCodeMunch about $0.017, whatever the window size.
• Signal-to-noise ratio drops: dumping entire files into context means the AI wades through thousands of irrelevant lines to find the one function it needs. Larger windows amplify the noise problem, they don't solve it.
• Latency grows: more input tokens = slower time-to-first-token. Symbol retrieval returns results in milliseconds.
• Attention degrades: research shows LLMs struggle with retrieval accuracy as context length increases. The "lost in the middle" effect. Smaller, precise context performs better.

Absolutely: they're designed as complementary tools. A typical pairing:

• jCodeMunch for code retrieval: functions, classes, constants, methods. Any symbol in your codebase.
• jDocMunch for documentation retrieval: README sections, API docs, specs, architecture guides.

Together, they give AI agents surgical access to both code and docs without reading entire files. When an agent needs to understand how authentication works, it can search code symbols for the implementation and search doc sections for the design rationale: all with minimal token spend.

In benchmarks measured with tiktoken cl100k_base across 15 tasks on 3 real repositories, jCodeMunch retrieved 96.2% fewer tokens on average (26.5x fewer) than a grep-and-read agent: the baseline a competent agent without the tool actually uses.

• fastapi/fastapi benchmark: 85,296 tokens (grep-and-read) → 2,556 tokens (symbol retrieval) = 33.4x. Against reading every file it is 322.9x, but nobody pays that ceiling.
• Results vary by query type: retrieval of a single function body is near-zero cost, while broader searches return more symbols but still far less than full file reads.
• Per-query results range from 7.6x to 77.2x (median 19.1x): no single multiple describes every query.

That’s per lookup, under benchmark conditions. Your mileage depends on your codebase and your work, which is what the 30-day guarantee is for.