Cutting Context Waste by 98%: Architectural Breakdown of context-mode and MCP Sandboxed Execution

1. The Core Bottleneck: What Engineering Flaw Does It Target?

Modern coding agents suffer from a fundamental architectural mismatch. Most implementations treat high-cost Large Language Models as primitive I/O conduits. A single Playwright browser snapshot consumes 56 KB of context. Fetching twenty GitHub issues burns another 59 KB. Inspecting a single production access.log costs 45 KB. Within 30 minutes of real-world debugging, over 40% of the active context window vanishes into unparsed JSON structures and raw HTML blobs, triggering forced conversation compaction.

Context compaction breaks agentic continuity. When the runtime truncates historical data to stay within token budgets, the model loses critical operational context: active modified file paths, nested task queues, and recent user decisions. To make matters worse, agents burn precious output tokens on conversational filler and verbose explanations, bleeding context capacity from both directions.

context-mode resolves this by redefining the computing paradigm: an LLM must design execution logic, not execute computational brute force over raw streams. When an agent needs to scan function declarations across 50 source files, the legacy approach triggers 47 sequential Read() operations, ingesting 700 KB of text. context-mode directs the model to emit a compact script, run it in an isolated local sandbox, and pipe only the distilled output via console.log(). 315 KB of raw data collapses into 5.4 KB. This yields a deterministic 98% reduction in context overhead.

💡 Core Architectural Insight: Large language models are intent compilers, not data buffers; dispatch computation directly to the data layer and return only distilled runtime outputs to the context window.

2. Core Architecture and Data Flow Mechanics

The context-mode platform acts as a low-latency Model Context Protocol (MCP) server. It hooks directly into the client execution lifecycle to intercept raw tool execution, route data parsing, and manage compressed state retention.

[ Client CLI (Claude / Gemini) ]
           │  ▲
 (1) Hooks │  │ (6) Compacted Result (e.g. 5.4 KB)
           ▼  │
┌───────────────────────────────────────────────┐
│ context-mode MCP Server                       │
│                                               │
│  ┌──────────────────┐   ┌──────────────────┐  │
│  │ Routing Intercept│──>│ Sandboxed Runner │  │
│  │ (PreTool Hooks)  │   │ (ctx_execute)    │  │
│  └──────────────────┘   └────────┬─────────┘  │
│                                  │            │
│                                  ▼            │
│  ┌──────────────────┐   ┌──────────────────┐  │
│  │ FTS5 Search Core │<──│ Session Tracker  │  │
│  │ (BM25 Retrieval) │   │ (SQLite Engine)  │  │
│  └──────────────────┘   └──────────────────┘  │
└───────────────────────────────────────────────┘
           │                       ▲
 (2) Script│                       │ (4) Raw Data
           ▼                       │
┌─────────────────────┐   ┌─────────────────────┐
│ Node.js/OS Sandbox  │──>│ Local FS / APIs     │
│ Execution Runtime   │(3)│ (315 KB Source Dump)│
└─────────────────────┘   └─────────────────────┘

The runtime pipeline executes across four discrete phases:

1. Lifecycle Interception: Before standard inspection commands fire, PreToolUse hooks capture the raw tool call intent, rerouting payloads to ctx_execute or ctx_batch_execute.
2. Dynamic Sandboxed Execution: The agent generates JavaScript or Bash snippets targeting specific questions. Scripts run as isolated child processes, interacting directly with local directories, system logs, or external APIs.
3. Payload Distillation: Parsing, regex matching, and statistical reduction occur inside the execution engine. Only calculated terminal summaries reach stdout and stream into the context window.
4. Vectorless State Tracking: File modifications, git transitions, and error traces stream into an embedded SQLite engine. During conversation compaction, context-mode avoids bulk-dumping session state back into the window; instead, it compiles events into an FTS5 full-text index, answering future contextual queries via exact BM25 ranking.

The framework intentionally avoids prose-style constraints. Benchmark findings on models like kimi-k2.5 show that aggressive prompt constraints targeting output brevity degrade deep reasoning and code generation capabilities. context-mode controls routing topologies rather than dictating the lexical tone of the model.

3. Technical Trade-offs: Head-to-Head Comparison

Optimizing context utilization usually involves picking between raw brute-force window expansion, semantic vector retrieval (RAG), or execution-driven code sandboxing. The trade-offs break down as follows:

Traditional vector retrieval frequently fails on source code repositories. Chunking destroys AST boundaries, scope hierarchies, and variable references. By relying on deterministic SQLite FTS5 text indexing and ephemeral script execution, context-mode keeps code references anchored to exact line numbers and syntax symbols while maintaining a zero-infrastructure footprint.

4. Hands-on Implementation: Building the Minimal Loop

The following implementation demonstrates setting up the context-mode engine within Claude Code and validating the sandbox routing pipeline.

Environment Setup and Plugin Installation

Ensure Node.js >= 22.5 and Claude Code v1.0.33+ are available on your host system.

# Verify Claude Code version
claude --version

# Register plugin marketplace and install context-mode
/plugin marketplace add mksglu/context-mode
/plugin install context-mode@context-mode

# Reload active plugins
/reload-plugins

Running Diagnostics

Validate runtime dependencies and hook registration:

/context-mode:ctx-doctor

The command returns a system health checklist:

[x] Node.js Runtime (v22.12.0 detected)
[x] SQLite FTS5 Extension Loaded
[x] Hook Registration: PreToolUse, PostToolUse, PreCompact, SessionStart
[x] Sandbox Permissions: OK

Real-world Sandbox Execution

When tasked with analyzing line counts across an unfamiliar repository, context-mode intercepts the prompt, bypassing individual file reads by synthesizing a target script for ctx_execute:

// Synthesized dynamically by the agent and executed via ctx_execute
// Objective: Extract line counts across src/ without loading file payloads into context
import fs from 'node:fs';
import path from 'node:path';

const ROOT_DIR = 'src';

// Recursively walk directories to gather all TypeScript files
function walk(dir) {
  let entries = fs.readdirSync(dir, { withFileTypes: true });
  return entries.flatMap(entry => {
    const res = path.join(dir, entry.name);
    return entry.isDirectory() ? walk(res) : res;
  });
}

// Perform aggregation within the sandbox, discarding raw contents
const files = walk(ROOT_DIR).filter(file => file.endsWith('.ts'));
const summary = files.map(file => {
  const lines = fs.readFileSync(file, 'utf8').split('\n').filter(l => l.trim().length > 0);
  return `${file}: ${lines.length} lines`;
});

// Only the distilled breakdown hits the LLM context
console.log(summary.join('\n'));

Validating Token Savings

To inspect context usage metrics during an active session, run the stats utility command:

/context-mode:ctx-stats

The utility reports token reduction metrics:

Tool                 Calls    Tokens In     Tokens Out    Savings Ratio
------------------------------------------------------------------------
ctx_execute             1       320 B          480 B          98.2%
read_file (prevented)  47       680 KB         0 B           100.0%
------------------------------------------------------------------------
Total Session Savings: 679.2 KB (approx. $1.35 saved)

5. Production Gotchas and Operational Constraints

Deploying context-mode inside high-throughput engineering workflows requires managing runtime state boundaries and execution scopes.

⚠️ Production Gotcha [Session Continuity and State Deletion]: context-mode enforces an ephemeral storage lifecycle. If a developer exits the CLI agent and restarts without the --continue flag, the SQLite session store drops historical state and indices immediately. To maintain continuous awareness across extended development iterations, always launch sessions using claude --continue.

⚠️ Production Gotcha [Sandbox Dependency Resolution]: Scripts executed via ctx_execute run directly within the parent host environment. In monorepos leveraging isolated package linkers or custom virtual environments, generated scripts cannot reliably import non-global modules. Standardize configurations inside CLAUDE.md to instruct the agent to generate scripts using standard library modules only (such as node:fs, node:child_process, or Python's pathlib).

⚠️ Production Gotcha [Unenforced Tool Calls on Non-Hook Platforms]: Full automated routing depends on client hook ecosystems (Claude Code, Gemini CLI). When deploying context-mode across clients lacking hook infrastructure (e.g., standard VS Code extensions), the MCP tools remain accessible, but models will fall back to legacy read_file operations unless explicitly constrained. Developers must manually inject strict context routing rules into their base system prompts.