# Throughput Lines of Code Per Day — Full corpus for LLMs > Combined site content + Metaphone blog (brand=ganvil). > Site: https://throughputlinesofcodeperday.com · Generated with rev=tlcpd-llms-v2-combined This file is intentionally one document so agents load product truth and published posts together — not blog-only and not marketing-only. Sections: 1. Site (product summary, pricing, benchmarks, FAQ, docs, download) 2. Blog (Metaphone topics + article bodies) ══════════════════════════════════════════════════════════════════════ PART 1 — SITE ══════════════════════════════════════════════════════════════════════ # Throughput Lines of Code Per Day — Site content > Agent-native version control on the Model Context Protocol (MCP). Throughput Lines of Code Per Day indexes your workspace inside the version control system and hands coding agents instant, structured answers — outline, symbol body, callers, impact, search — instead of dumping whole files into context. Measured ~10.7× context-token savings; git-compatible round-trips are byte-perfect. Canonical site: https://throughputlinesofcodeperday.com Sources: in-repo marketing content (src/content/*) + docs. Blog is published via Metaphone brand "ganvil" and merged in llms-full / llms-blog. ## Pages - [Home](https://throughputlinesofcodeperday.com/) — Have AI agents write code 10× faster by skipping codebase rediscovery. TLCPD indexes the workspace inside VCS and multiplies agent fleet throughput. - [Pricing](https://throughputlinesofcodeperday.com/pricing) — Pro Developer and Enterprise plans for 10× code intelligence. Simple, predictable pricing; custom on-prem/private cloud available. - [Benchmarks](https://throughputlinesofcodeperday.com/benchmarks) — Measured token savings from MCP tools — every figure sourced from published benchmark docs. - [Docs](https://throughputlinesofcodeperday.com/docs) — Tutorials: inviting team members, configuring MCP, workspaces and agent infrastructure. - [Download](https://throughputlinesofcodeperday.com/download) — Install the TLCPD CLI for macOS and Linux (v0.1.1 archives or install script). - [FAQ](https://throughputlinesofcodeperday.com/faq) — Data leaving the machine by tier, git compatibility, and how TLCPD differs from sidecar code-graph indexers. - [Blog](https://throughputlinesofcodeperday.com/blog) — Engineering deep dives and product notes from Metaphone CMS (brand ganvil). --- # Pricing URL: https://throughputlinesofcodeperday.com/pricing ## 10x Code Intelligence. Simple, Predictable Pricing. Throughput Lines Of Code Per Day indexes your codebase to give AI agents precise symbol intelligence. Contact us for custom on-premise or private cloud hosting options. ### Pro Developer — $20 (per seat / month) High-performance code indexing and symbol resolution infrastructure. Eliminate context bloat, save 90%+ on LLM tokens, and speed up your coding agents. READ capabilities: - Hosted symbol index: structural context resolution across your codebase - Selective Transparency: passes only necessary symbol graphs to your LLM - Remote MCP gateway with tenant scoping and rate limits EXECUTE capabilities: - Zero LLM token markup — use your own model API keys directly - Unlimited local agent connections via open MCP standard - Silent degradation: falls back to local execution if offline ### Enterprise — Custom (tailored per organization) Built for teams with strict compliance, on-premise hosting, or zero-trust requirements. Custom VPC deployments, cryptographic audit logs, and dedicated architecture support. READ capabilities: - Includes all Pro READ capabilities - Role-Based Access Control (RBAC) scoped to custom token claims - Compliance and SOCS EXECUTE capabilities: - Dedicated VPC or self-hosted on-premise orchestrator deployment - Cryptographic signatures (Ed25519) & hash-chained audit trail - Custom SLA & 24/7 dedicated architecture setup support - Fail-closed security posture for remote tool access --- # Benchmarks URL: https://throughputlinesofcodeperday.com/benchmarks ## The numbers, and exactly how we got them. One measured run, published with its method and its caveats. Where a benchmark hasn't been run yet, this page says so instead of showing you a chart. ### Method Corpus: the TLCPD repository itself at commit 455bb84c5c57 (135 files), imported via gan import and served by gan mcp from the imported store. Run 2026-07-08. Counterfactual: token cost of the naive alternative: read the file, or grep + read hit files, for the same answer. ### Results (response tokens vs counterfactual) - **API Outline Generation**: response 1,738 · counterfactual 4,814 — read the file · saving 2.8× - **Retrieve Single Function Body**: response 889 · counterfactual 4,705 — read its file · saving 5.3× - **Cross-Reference Mapping Callers**: response 141 · counterfactual 14,820 — grep + read 8 hit files · saving 105× - **Transitive Change Impact Scope**: response 2,012 · counterfactual 15,210 — grep + read hit files · saving 7.6× - **Ranked Multi-File Intelligence Search**: response 406 · counterfactual ~5,700 — grep + read candidates · saving 14× - **Type-Safe Structural Pattern Match**: response 2,012 · counterfactual ~22,200 — grep + read to filter false positives · saving 11× - **Dynamic Context Bundle Packaging**: response 2,012 · counterfactual 26,420 — read top 6 relevant files · saving 13× - **Compute Workspace Diff**: response 14 · counterfactual ~2,000 — read the text diff · saving 143× - **Trace Attribution**: response 74 · counterfactual ~5,000 — read log -p of the file · saving 68× - **Semantic Query Logs Filter**: response 283 · counterfactual ~1,500 — read full log output · saving 5.3× Session total: 9,581 response tokens vs 102,410 counterfactual → **10.7×**. ### ~90% of context-acquisition tokens disappear. A session that spends 100k tokens rediscovering the repository needs about 10k through the tool surface. ### Graph queries are the outliers. callers at 105× and mappings_diff at 143×: the response is a list of names where the counterfactual is many whole files. These are also the queries agents repeat most. ### outline tool’s is the floor. Measured on a file that is mostly API surface; body-heavy files fare far better. That’s just one tool too. ### The multiplier grows with repo size. Responses are roughly constant-size; counterfactual file reads grow with the codebase. The benchmark corpus is small (135 files) — large repos sit well above 10.7×. --- # FAQ URL: https://throughputlinesofcodeperday.com/faq ## What data leaves my machine, per tier? Local CLI execution: nothing. Embeddings are computed on-device, search runs locally, and the whole system operates fully offline. Hammer & Burst: Repository indexes (outlines, symbol lists) are sent to the hosted Throughput Lines of Code Per Day index service to run embeddings and queries in the cloud, and active VM compute logs route through our remote MCP gateway. Compliance & Governance: Same as Hammer & Burst, plus an append-only audit trail of all agent activity and proposal signature history stored in the cloud. Zero Trust: Same as Compliance, but all remote tool access is strictly confined through path-cone filters and verified against time-bound token claims. ## Is it actually git-compatible, or "mostly compatible"? The bridge round-trips byte-perfectly in both directions — gan import then gan export reproduces the original repository exactly, and that property is tested, not aspirational. ## How does this differ from a sidecar code-graph indexer? Sidecar tools proved that agents with a code graph beat agents without one. But a sidecar is a second source of truth: stale between runs, blind to history, gone when the folder moves. TLCPD computes the graph inside the VCS — updated sub-second per file on every change, keyed by OID so it is queryable at any commit, not just the last time an indexer happened to run. --- # Documentation URL: https://throughputlinesofcodeperday.com/docs ## Inviting Team Members Category: Workspaces & Access Throughput Lines of Code Per Day utilizes a highly secure, link-based invitation system for adding members to your workspaces. ### Generating an Invite Link 1. Navigate to the **Organization Settings** in your TLCPD Dashboard. 2. Select **Teams & Access** and click on **Invite Members**. 3. Use the **Invite Link Generator** to create a secure token link. 4. Set an expiration duration (e.g., 1 hour, 24 hours, or 7 days) to limit the window of access. 5. Click **Generate Secure Link**. ### How Invite Tokens Work TLCPD invitations are backed by short-lived cryptographic tokens prefixed with `gv_tkn_`. When generated, the dashboard will output a link similar to: `https://throughputlinesofcodeperday.com/invite/join?token=gv_tkn_abc123&expire=1h` ### Joining a Workspace When a user clicks the invitation link: - If they are **not authenticated**, they will be securely redirected through the login/signup flow (backed by Buttrbase) and then returned to the invitation page. - If they are **authenticated**, the system intercepts the `token` parameter, validates it against the Buttrbase API, and securely provisions them as a `member` of the organization. - Upon success, the user is immediately redirected to the workspace dashboard. > **Note:** For security purposes, workspace roles are strictly enforced by the backend upon joining, defaulting to member-level access. --- ## Configuring Your MCP Connection Category: Agent Infrastructure TLCPD relies on the Model Context Protocol (MCP) to seamlessly communicate with the agent daemon. ### Setup Instructions 1. Open the **MCP Settings** tab in your dashboard. 2. Provide your backend connection URL and authentication token. 3. Once configured, TLCPD will establish a persistent connection with exponential backoff and jittered reconnects. This means even if you're coding offline on an airplane, the UI will restore connections and pick up exactly where it left off once Wi-Fi is restored! --- # Download URL: https://throughputlinesofcodeperday.com/download Version: v0.1.1 Install: `curl -fsSL https://ganvil.app/install.sh | sh` Tarball ships gan (CLI) and gv (helper). gan import any repo and point agents at gan mcp. ══════════════════════════════════════════════════════════════════════ PART 2 — BLOG (Metaphone) ══════════════════════════════════════════════════════════════════════ # Throughput Lines of Code Per Day — Blog > Engineering posts from Metaphone CMS (brand=ganvil), merged with local build-content bodies. Index: https://throughputlinesofcodeperday.com/blog ## Welcome to Throughput Lines of Code Per Day URL: https://throughputlinesofcodeperday.com/blog/welcome-to-throughput-lines-of-code-per-day Source: metaphone+local Category: engineering Agent-native version control that query-maps your repository instead of dumping files into context. **Metaphor:** A map instead of a filing cabinet. Agents waste most of their context budget rediscovering your repo. Throughput Lines of Code Per Day keeps a queryable code graph inside the VCS, so agents get structured answers instead of file dumps — measured 10.7x context-token savings on real workloads. The repository itself becomes the knowledge surface your tools already speak: Model Context Protocol, outlines, symbol lookup, and impact queries that stay versioned with every commit. Plug Throughput Lines of Code Per Day into your existing agent via MCP and stop paying context tax on every session. --- ## 10.7x Context-Token Savings: How We Measured It URL: https://throughputlinesofcodeperday.com/blog/10-7x-context-token-savings-how-we-measured Source: metaphone+local Category: engineering Every number on our benchmarks page is copied from measured runs — not marketing fiction. **Metaphor:** A stopwatch on the critical path, not a slide deck. Token savings claims are easy to invent and hard to defend. We instrumented real agent workflows against Throughput Lines of Code Per Day MCP surface: API outline generation, single-function body retrieval, caller mapping, transitive change impact, ranked multi-file search, structural pattern match, context bundle packaging, workspace diff, and attribution traces. The counterfactual is what agents do without a graph — grep plus whole-file reads. On those paths, agents spent roughly an order of magnitude fewer input tokens through outline and query tools than through file dumps. Graph queries are the outliers: callers and diffs return lists of names where the alternative is many whole files. Read the full tables on /benchmarks, then run the same tools against your own workspace. --- ## Why Sidecar Code Graphs Go Stale URL: https://throughputlinesofcodeperday.com/blog/why-sidecar-code-graphs-go-stale Source: metaphone+local Category: engineering Sidecars proved agents need a graph. They also proved a second source of truth is a liability. **Metaphor:** A second map that never quite matches the terrain. Sidecar graph tools proved the demand, then went stale between runs. An indexer that lives outside version control is blind to history, missing mid-session edits, and gone when the folder moves. Throughput Lines of Code Per Day computes the graph inside the VCS — updated sub-second per file on every change, keyed by object ID so it is queryable at any commit, not just the last time an indexer happened to run. Agents propose; history stays yours. Delete the derived layer and nothing canonical is lost. Prefer tools that treat the repository as the source of truth — not a cache that drifts. --- ## Plug MCP into Cursor and Claude in 30 Seconds URL: https://throughputlinesofcodeperday.com/blog/plug-mcp-into-cursor-and-claude-in-30-seconds Source: metaphone+local Category: engineering Zero-friction setup: open Model Context Protocol, one config block, agents start querying structure. **Metaphor:** A power outlet, not a custom adapter farm. Integration tax kills good tooling. Throughput Lines of Code Per Day implements the open Model Context Protocol standard. Connecting it to Cursor, Claude Code, Claude Desktop, or any MCP client is a single server entry — local CLI for offline outline mode, or a hosted index token when you want cloud embeddings and multi-agent coordination. No proprietary SDK lock-in. No second repo format. Agents that already speak MCP get outline, search, get_symbol, and context_pack without reinventing discovery. Open the Zero Friction Setup section on the home page and paste the config for your client. --- ## Byte-Perfect Git Compatibility (Not Mostly Compatible) URL: https://throughputlinesofcodeperday.com/blog/byte-perfect-git-compatibility Source: metaphone+local Category: engineering The bridge round-trips exactly — import then export reproduces the original repository. **Metaphor:** A translator that never paraphrases. Security reviews always ask whether it is actually git-compatible. Throughput Lines of Code Per Day is a 1:1 git drop-in for agent workflows. The import/export path is tested for byte-perfect round trips — not aspirational compatibility. Your history, remotes, and review process stay familiar. What changes is what agents can ask of the repository: structural queries instead of recursive greps, symbol bodies instead of whole-file dumps, impact scope instead of hope. Keep git as the wire format. Add a query surface agents can trust. --- ## Outline Mode Beats File Dumps URL: https://throughputlinesofcodeperday.com/blog/outline-mode-beats-file-dumps Source: metaphone+local Category: engineering Agents should read the map before they read the library. **Metaphor:** A table of contents before the novel. Dumping whole files into context is the default — and the most expensive habit. Outline mode hands agents the shape of the workspace first: modules, symbols, imports, and relationships. Only then do they fetch the bodies they actually need via get_symbol or a tight context_pack. That ordering is why measured sessions drop about 90 percent of context-acquisition tokens. Prefer context_pack for a task and outline before monorepo greps. Prefer package-scoped dependency queries over vendored tree walks. Make outline the first tool call in every agent session. --- ## Agent-Native VCS Architecture URL: https://throughputlinesofcodeperday.com/blog/agent-native-vcs-architecture Source: metaphone+local Category: engineering Version control was built for humans reviewing diffs. Agents need a different primary interface. **Metaphor:** A control plane for code, not just a log of patches. Chat-first coding agents inherited git as a storage layer and a text dump as a context strategy. An agent-native VCS still stores history the way teams expect — commits, branches, protection rules — but exposes a query plane optimized for tools: structural search, symbol resolution, change impact, provenance, and packaging of only the slices an agent needs for the current task. Throughput Lines of Code Per Day sits on that boundary: warm forge for canonical truth, phosphor for derived intelligence. AI proposes; humans merge; the graph rebuilds from truth. Build agents that query the repo like a system of record, not a bag of files. ---