Write way more code on the same quota — or cut API cost.

Coding agents burn a huge share of every turn re-reading the repo: full files, grep hits, rebuild context. Ganvil’s MCP hands them structured answers—outlines, symbols, ranked packs—so input context drops on the order of ~4× (about 75% less) vs dump+grep on the paths we measure. The result: you get way more code written per plan quota, or the same work at lower API cost—because less of every turn is spent paying to re-read the tree.

gan mcp · live session
$ganoutline crates/ganvil-core/src/repository.rs
⚡ TLCPD MCP (Outline mode)1,738 tokens
signatures + doc comments, no body bloat64% savings
⚠️ The Old Way (Full file read)4,814 tokens
dumps entire file code block into LLM context window
freshness: head 455bb84 · exact2.7X MORE COMPACT
Input token cost
75% reduction
less context bloat, tighter loops
Context tokens saved
4x fewer
measured; less work per step
Agent tools
15 over MCP
read-only, deterministic
Setup time
< 10 mins
up and running instantly

Pillars

HOW WE ACHIEVE MASSIVE AGENT CODE-WRITING THROUGHPUT WITH 4x TOKEN REDUCTION

READ

Codebase awareness in milliseconds. Stop wasting 90% of execution time waiting for agents to parse thousands of lines of context just to find a single reference.

  • Sub-second context assembly gets answers to your agent instantly, slashing feedback delays.
  • Compact 1,700-token outlines instead of 5,000-token files mean models generate code faster in theory.
  • Live Dependency Graph resolves symbol relationships instantly to avoid cloud API network round-trip lag.

Context Efficiency

Context overload is the ultimate agent bottleneck.

Traditional AI tools dump entire files and directories into the LLM context window. This is slow, expensive, and leads to hallucinations.

TLCPD query-maps your repository directly. Instead of reading whole files, agents request only the specific symbols, imports, and code definitions they need. The result is a 4x reduction in token usage, sub-second tool responses, and cleaner agent steps. Fewer tokens also means less work for the model on each turn — so agents should think and move faster even when pure generation speed is hard to attribute.

AI Agent Code Context Shapes Comparison

Install

Up and running in 10 minutes or less!

gan v0.1.1 ships as tarballs for macOS (Apple silicon) and Linux (x86_64). Every release publishes SHA256SUMS next to the artifacts — verify before you extract, the same way you'd want your auditors to.

gan CLI · v0.1.1
# macOS (Apple silicon)
curl -LO https://github.com/S7-Works/ganvil/releases/download/v0.1.1/ganvil-v0.1.1-aarch64-apple-darwin.tar.gz

# Linux (x86_64)
curl -LO https://github.com/S7-Works/ganvil/releases/download/v0.1.1/ganvil-v0.1.1-x86_64-unknown-linux-gnu.tar.gz

# verify against the published checksums, then install
curl -LO https://github.com/S7-Works/ganvil/releases/download/v0.1.1/SHA256SUMS
shasum -a 256 -c --ignore-missing SHA256SUMS   # sha256sum -c on Linux
tar xzf ganvil-v0.1.1-*.tar.gz
install ganvil-v0.1.1-*/gan ganvil-v0.1.1-*/gv ~/.local/bin/

The tarball carries two binaries: gan, the CLI, and gv, its helper. Then gan import any repo and point your agent at gan mcp.

Zero Friction Setup

Plug Throughput Lines of Code Per Day directly into your existing agent.

TLCPD implements the open Model Context Protocol (MCP) standard. Connecting it to Cursor, Claude Code, or any other agent client takes less than 30 seconds.

For Claude Code

Add the hosted server in one command — URL and token from Settings > MCP:

# hosted — nothing to install
claude mcp add \
  --transport http tlcpd <YOUR_MCP_URL> \
  --header "Authorization: Bearer gv_pat_..."

For Cursor

Add to ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "tlcpd": {
      "url": "<YOUR_MCP_URL>",
      "headers": {
        "Authorization": "Bearer gv_pat_..."
      }
    }
  }
}

Local (any agent)

Run the MCP against a checkout — your code stays on your machine:

curl -fsSL https://throughputlinesofcodeperday.com/install.sh | sh
tlocpd import .
tlocpd mcp

# then in your agent's MCP config:
{ "command": "tlocpd", "args": ["mcp"] }
Your hosted MCP URL and access token live in the TLCPD dashboard under Settings > MCP. Full per-agent setup — including VS Code and Continue — is in the docs.

Your VCS is the knowledge graph. No sidecar indexer.

Sidecar graph tools proved the demand, then went stale between runs. TLCPD makes the graph a property of the repository — incremental, versioned, and queryable at any commit.

Up and running in 10 minutes or less!
© 2026 S7 Works · Built on Model Context Protocol (MCP).75% fewer input tokens · faster code generation in theory