What is the maximum token horizon WholeRepo can process?

WholeRepo scales from small microservices (50k tokens) to 10M tokens on standard clusters and up to 100M+ tokens across multi-repo enterprise portfolios through high-density in-memory partitioning.

WholeRepo | Sovereign Whole-Codebase Intelligence Engine

Q: How does WholeRepo guarantee zero data retention?

All repository tokens are processed strictly in volatile memory. Buffers are automatically zero-scrubbed upon request termination or client disconnect. Zero bytes are written to persistent disks or databases, and requests emit cryptographic HMAC-SHA256 audit receipts.

Q: How does WholeRepo differ from Vector RAG and agent grep-loops?

Traditional RAG splits files into small chunks and loses 90% of cross-file context, while agent grep-loops make dozens of slow, fragile tool calls. WholeRepo evaluates the entire codebase in a single forward pass in 1.4 seconds with 0 tool calls and 100% bit-exact causal recall.

Q: Is WholeRepo compatible with existing OpenAI SDKs and IDEs?

Yes. WholeRepo exposes a standard OpenAI-compatible API (/v1/chat/completions) with full Server-Sent Events (SSE) streaming support, making it a drop-in replacement for Python, TypeScript, Cursor, and CLI workflows.

⚡ THE DEVELOPER COPILOT INTERFACE

Zero Tool Calls. Just Native Stream.

Drop-in OpenAI endpoints, zero-dependency CLI, and native TypeScript SDK.

wholerepo-engine / terminal.sh

# 1. Install sovereign WholeRepo CLI
curl -fsSL https://wholerepo.sh | sh
# 2. Ingest entire codebase and reason across all 1,420 files in 1 forward pass
wholerepo ask "Why does the SVG layout measurement skip embedded foreignObject?" \
--dir . \
--tier "portfolio" \ # Multi-repo portfolio cluster
--stream
# 3. Interactive multi-turn whole-codebase REPL with 0 persistent disk writes
wholerepo chat

Cluster Status: High-Density Nodes Ready

Security: Sovereign Ephemeral Memory | Zero Persistent Storage

Simulated Output Stream

● Ready (Click ▶ Run)

Press "▶ Run Request" above to simulate instant whole-repo forward pass...

$ wholerepo ask "Why does the SVG layout measurement skip embedded foreignObject?"

Tokens Generated: 248

📊 Live Telemetry (Single Forward Pass)

Empirical Benchmarks

Total Latency

1.41s

Ingest + Pre-fill + Reasoning

Time to First Token

24.2ms

Instant unified prefill

Recall Precision

100.0%

Bit-Exact Invariant Tracking

Tool Calls Required

0calls

Single forward pass

🔒 Data Retention Guarantee: 0 Bytes (Zero Persistence)

⚖️ THE ARCHITECTURAL CRUCIBLE

Vector RAG & Agent Loops vs. In-Memory WholeRepo

Vector chunking drops call graphs. WholeRepo resolves non-local logic in a single 1.4s pass.

1. What is this?

Chunked vector search vs. single-pass GPU memory reasoning.

2. Do I care?

RAG misses non-local calls and takes 40s. WholeRepo resolves 100% causal integrity in 1.41s.

3. What do I do next?

Select a scenario and click Run Live Simulation, or test your repo in the Studio Sandbox.

Scenario:

Baseline:

Cross-Service Enum Refactor • 1.2M LOC • 14 Downstream Microservices

Query: "Audit breaking changes if OrderStatus.PENDING is deprecated across all services."

❌ Vector RAG (512-Token Windows)

Latency: 28.6s

Architectural Limitation

Slices code into 512-token chunks. Misses 12 of 14 microservices passing enums via dynamic serializers or Kafka events.

Simulated Execution Stream Completed

Tool Calls

5 vector ops

Causal Recall

14.2%

Code Persistence

1.8 GB stored

Query Cost

$0.42 / query

⚡ WholeRepo Engine 2.0 (In-Memory V-MLA)

Latency: 1.41s

Whole-Repository Synthesis

Exhaustive call graph across 14 services. Found 14 breaking sites and 3 implicit serializers. Migration diff in 1.4s.

In-Memory Execution Stream 1.41s Single Pass

Tool Calls

0 (Single Pass)

Causal Recall

100.0% (Exact)

Code Persistence

0 Bytes (Evaporated)

Query Cost

1 credit ($0.02)

🎯 Next Step: Test Your Real Codebase with 0 Setup

Test your repo in the Studio Sandbox. 0 setup, 0 disk writes, 50 free credits.

Launch Studio Sandbox → Why Not RAG? Spec

⚡ DUAL-HORIZON INTELLIGENCE ARCHITECTURE

From 100M-Token Enterprise Swarms to True Local Edge Inference

Distributed 100M+ token swarms down to 100% offline edge inference on Apple Silicon.

Breakthrough 01 Sub-Second Execution

Unified Context Engine™

2M–100M+ tokens in unified GPU memory. Resolves cross-file dependencies in a single 1.4s pass.

The Context Horizon & Recall Curve Token count vs. real codebase scale

Target Horizon: 2.67M Tokens (SQLite3) Single Forward Pass

WholeRepo 100.0%

Latency: 1.41s • 0 Tool Calls

Vector RAG 0.0%

Status: Context Cliff

Agent Grep 14 Calls

Latency: 34.8s • Ambiguity Stall

Cold Latency: 1.41s total Single Forward Pass Reasoning

Breakthrough 02 100% Invariant Precision

Bit-Exact Invariant Recall™

Zero attention decay across 10M+ tokens. Resolves non-local calls, types, and mutex states.

3-Hop Invariant Call Graph

sqlite3_exec()

Token Offset: 0 • API Ingress

0xF7637533

↓ +1,120,400 unchunked tokens ↓

sqlite3VdbeExec()

Token Offset: +1.12M • Opcode Loop

0x6BDEA933

↓ +970,200 unchunked tokens ↓

sqlite3BtreeMoveto()

Token Offset: +2.09M • Mutex Lock

Coupled Lock

Active Invariant Inspector: 100% Deterministic Match

Ingress entrypoint receives initial counterfactual transaction mask 0xF7637533.

Reconstructed 64-bit Invariant: 0x6BDEA933F7637533

Context Decay: 0.00% 10M+ Token Coherence Guarantee

Breakthrough 03 4x Context Density

High-Density Context Fabric™

Volatile memory compaction quadruples token capacity on standard GPUs with zero precision loss.

Hardware Memory Footprint 99.56% Less VRAM

Dense Attention (FP16 Baseline) 8.75 TB • 109x A100s

Fatal OOM Cliff at 65,536 tokens on single GPU

WholeRepo High-Density Fabric™ 1.55 GB • 1x GPU

Fits in commodity 24GB VRAM with zero loss

Required Node: 1x Commodity GPU (A10G / RTX 4090)

Capacity: 3.2M+ tokens on standard nodes Zero Accuracy Degradation

Breakthrough 04 No Vector DBs • 100% Private

Zero Indexing Lag. Zero Model Retraining.

No vector DBs, chunk tuning, or indexing lag. 1.4s answers. 0 bytes written to disk. Never trained on.

Developer Workflow Comparison Compare infrastructure complexity & code security

1. Native Ingest

Stream files directly into GPU memory. 0 chunking.

2. In-Memory Reasoning

1.4s single forward pass. Bit-exact cross-file resolution.

3. Total Code Privacy

0 bytes to disk. Never stored. Never trained on.

✓ Zero Vector DBs • ✓ 0 Chunks Broken • ✓ 100% Private Code

Persistent Disk Writes: 0 Bytes (Zero Persistence)

Model Training Retention: 0 Bytes (Never Used For Training)

Security Guarantee: Enterprise IP Protected • 100% Private Context

Privacy Guarantee: 100% Private • Never Trained On Zero Storage Retained

Breakthrough 05 • Dual-Horizon Intelligence 100% Offline Air-Gapped

Zero Network Egress • Local Unified Memory

True Local Edge Inference™

Run whole-codebase reasoning 100% offline on Apple Silicon or NVIDIA RTX. Sub-4.5GB VRAM footprint with zero cloud egress.

⚡ 4-Bit AWQ / FP4

Sub-4.5GB VRAM footprint. 99.8% fp16 precision with zero AST degradation.

📦 576 B/tok MLA Compression

Compresses KV cache to 576 B/tok, running millions of tokens on laptops.

🚀 Zero-Copy Unified Memory

Zero-copy unified memory bypasses bus transfers for sub-10ms TTFT.

🔒 100% Air-Gapped

Zero network calls. Complies with ITAR, HIPAA, and strict IP mandates.

🖥️ Dual-Horizon Hardware Spectrum Zero Cloud Egress • Metal 3

Target Model Runtime: wholerepo-edge-7b (INT4 MLA)

Memory Allocation: 4.18 GB (Unified LPDDR5X)

Cold Ingestion (3M tokens): 0.85s (Zero-Copy Host Shaders)

Inference Throughput: 68.4 tokens / sec

Network Telemetry & Egress: 🟢 0.00 Bytes (100% Air-Gapped)

$ curl -fsSL https://wholerepo.sh/edge | sh

Dual-Horizon Spectrum: Apple Silicon / RTX ↔ Multi-A100 Enterprise Swarms 100% Sovereign Offline Available

🪙 TRANSPARENT GPU CREDIT BILLING

Interactive Credit & Pricing Engine

Pay only for active GPU cycles in volatile memory. No vector DB fees, no storage retainers.

Select Codebase Archetype (or Use Slider Below) Scale Guide

📁 Codebase Scale (Active Tokens)

3,000,000 tokens

~11.4 MB source code

📊 Codebase Size Visualizer Matches: SQLite3 / DuckDB

Estimated Files ~1,420 files

Lines of Code ~241,000 LOC

Vector DBs Needed 0 (Eliminated)

Code Privacy 100% Private

⚡ Compute Engine Tier & Deployment Model

💡 Estimated Savings vs Legacy Vector RAG Save $640 / mo

• Vector DB Hosting: $240/mo ➔ $0

• Indexing Latency: 45 mins ➔ 1.4s

Developer Tier Zero Retention

$20 / batch of runs

Includes 100 whole-codebase queries across your 3.0M token repository.

Credits Consumed / Run: 24 credits

Est. Cold Ingestion: 1.41s

VRAM Allocation (Zero-Copy): 1.72 GB

Data Persistence: 0 Bytes (Evaporated)

Start Free with 50 Credits →

No credit card required • Instant API key in Sandbox

100% AIR-GAPPED

⚡ Open Source • Self-Hosted

Local Edge Edition

$0 / forever free

Run whole-codebase intelligence 100% offline. Zero cloud calls, zero subscriptions.

✓ 4-bit INT4/FP4 Quantization
✓ 576 B/tok MLA Compression
✓ Apple Silicon (Metal) & RTX (CUDA)
✓ Zero Network Egress (Air-Gapped)

curl -fsSL wholerepo.sh/edge | sh

Install Local Edge →

Developer & Pro

$20 / batch (1,000 runs)

Zero setup serverless compute. 1.4s ingestion on NVIDIA A10G cloud nodes.

✓ Single Forward Pass (<1.5s)
✓ 50 Free Welcome Credits
✓ Zero Data Retention (Evaporated)
✓ Webhooks & GitHub PR Integration

Launch Cloud Studio →

Top of Scale • Distributed

Enterprise Swarms

Custom / dedicated cluster

Distributed multi-GPU swarms across multi-A100/H100 clusters for 100M+ token repos.

✓ 100M+ Token Repositories
✓ Multi-A100 Parallel Swarms
✓ Air-Gapped VPC & On-Prem
✓ Dedicated SLA & Support

Contact Architecture Team →

⚡ EMPIRICAL PROOF

13.8M Token Multi-Repository Gauntlet

Empirical benchmarks on Linux Kernel, Ladybird Browser, and TypeScript ASTs.

Ladybird Browser (2.3M Tokens)

CSS Layout Bug Localization

Agentic RAG: 14 Tool Calls (Failed @ depth 3)

WholeRepo Unified Engine: 1 Pass (1.4s • Bit-Exact)

Linux Kernel v6.8 (8.4M Tokens)

RCU Lock Race Detection

Dense Model: OOM on 80GB VRAM

WholeRepo Unified Engine: 2.8s Latency (0 Tool Calls)

TypeScript Compiler (3.1M Tokens)

Circular Type Resolution Trace

Graph DB Search: 12.4s Graph Hop Delay

WholeRepo Unified Engine: 1.8s Single Forward Pass

❓ FAQ

Frequently Asked Questions

In-memory execution, security guarantees, and developer integration.

How does WholeRepo guarantee zero data retention? ▼

Tokens are processed strictly in volatile GPU memory and zero-scrubbed on disconnect. Zero bytes are written to persistent disks or databases, backed by cryptographic HMAC-SHA256 audit receipts.

How does WholeRepo differ from Vector RAG and agent grep-loops? ▼

Vector RAG fragments code into 512-token chunks, losing cross-file context; agent grep loops make dozens of slow tool calls. WholeRepo processes the entire codebase in a single 1.4s forward pass with zero tool calls.

What is the maximum codebase scale WholeRepo can process? ▼

Scales from single repos (50K–10M tokens) on standard clusters up to 100M+ tokens across multi-repo enterprise portfolios via distributed GPU swarms.

Is WholeRepo compatible with existing OpenAI SDKs and tools? ▼

Yes. WholeRepo exposes a standard OpenAI-compatible API (/v1/chat/completions) with full SSE streaming. Point your OpenAI SDK, Cursor, or cURL base URL to WholeRepo.

All your base are belong to you.