Ctxfw – In-memory Tree-sitter AST compactor that cuts coding tokens by 72%

The deterministic boundary between probabilistic LLM hallucination and production infrastructure.

Installation • Benchmarks • Diagnostic • Architecture • Enterprise Governance

Autonomous coding agents (Claude, Gemini, Cursor, Antigravity) consume massive context windows with bloated peripheral dependencies, triggering token exhaustion, context drift, and security degradation.

CTXFW is an open-core context firewall and Model Context Protocol (MCP) gatekeeper. It combines an in-memory polyglot AST pruner with a deterministic axiomatic intake sieve:

Compacts Peripheral Code (72.4% token reduction) : Replaces distance-1 and distance-2+ module implementations with clean interface signatures, type definitions, and functional stubs. 2. Enforces Axiomatic Integrity (ACI : Rejects ungrounded or deficient architecture briefs missing negative invariants ($\ge$ 0.9000)$N \ge 5$ ), bounded variable domains, deterministic state machines, or formal error taxonomies. 3. Zero Telemetry Egress : Guaranteed local execution with zero network telemetry leakage on standard operating mode.

CTXFW operates directly at the syntax tree layer using native polyglot grammars:

Empirical context reduction metrics generated via ctxfw.resolve_context_bundle running against 16 internal dependencies:

Topological Hierarchy Breakdown:

ctxfw/cli.py) : 100% Full Implementation preserved.$D_0$ Target ( #

gatekeeper.py, mcp.py) : Implementation truncated to typed stubs ($D_1$ Direct Deps (e.g.... ). Token savings:73% – 86% . #

polyglot.py) : Nominal symbols only. Token savings:$D_{2+}$ Transitive Deps (e.g.91.9% .

Install via pip or isolated environment manager:

pip install ctxfw

Or for global CLI availability using pipx:

pipx install ctxfw

Register the stdio server directly in your IDE or client configuration (claude_desktop_config.json, Cursor, Windsurf, or Antigravity):

{
  "mcpServers": {
    "ctxfw": {
      "command": "ctxfw",
      "args": ["mcp"]
    }
  }
}

CTXFW is indexed and verified with Grade A compliance on the official Glama MCP registry:

Direct access to tool inspection, schemas, and live diagnostic telemetry on Glama.

Validate local environment readiness, stdio isolation purity, SQLite WAL concurrency, and Tree-Sitter grammars with a single command:

[PASS]   Python Package & sys.path        ctxfw v3.5.0 loaded cleanly.
[PASS]   MCP stdio Stream Isolation       100% pure JSON-RPC on stdout. Diagnostic logs isolated to stderr.
[PASS]   Global CLI Executable (PATH)     Binary 'ctxfw' found in PATH.
[PASS]   Axiomatic Sieve Engine           Evaluation verified (ACI: 1.0000, Invariants: 5).
[PASS]   SQLite WAL Cache & Concurrency   Journal mode: WAL, Busy timeout: 5000ms.
[PASS]   Polyglot Tree-Sitter Grammars    Initialized language parsers (typescript, go, java).
------------------------------------------------------------------------
CTXFW // 72.4% AST Bloat Eliminated. Zero Telemetry Egress.
Need team-wide budget circuit breakers or multi-node proxy governance?

CTXFW enforces a strict deterministic perimeter dividing probabilistic agent code from the core codebase:

PROBABILISTIC DOMAIN                      DETERMINISTIC PERIMETER
┌───────────────────────┐                  ┌────────────────────────────────────────┐
│  Autonomous AI Agent  │                  │             CTXFW ENGINE               │
│  (Claude / Gemini /   │                  │                                        │
│   Cursor / Antigravity│                  │  ┌──────────────────────────────────┐  │
└───────────┬───────────┘                  │  │   Polyglot AST Topological Engine│  │
            │                              │  │  - Python (ast)                  │  │
            │  Target Context / Brief      │  │  - TypeScript / Go / Java (CST)  │  │
            ▼                              │  │  - Multi-Depth Interface Stubs   │  │
┌───────────────────────┐                  │  └────────────────┬─────────────────┘  │
│ MCP Stdio Interceptor ├─────────────────►│                   │                    │
└───────────────────────┘                  │  ┌────────────────┴─────────────────┐  │
                                           │  │  SQLite WAL High-Concurrency     │  │
                                           │  │  Semantic Cache (<5ms warm hit)  │  │
                                           │  └────────────────┬─────────────────┘  │
                                           │                   ▼                    │
                                           │         [ ACI >= 0.9000? ]             │
                                           │          /              \              │
                                           │       YES                NO            │
                                           │        │                  │            │
                                           │        ▼                  ▼            │
                                           │ ┌──────────────┐   ┌─────────────────┐ │
                                           │ │ VERIFIED     │   │ QUARANTINED     │ │
                                           │ │ SHA-256 Seal │   │ Execution Halt  │ │
                                           │ └──────┬───────┘   └────────┬────────┘ │
                                           └────────┼────────────────────┼──────────┘
                                                    │                    │
                                                    ▼                    ▼
                                           [ Code Generation ]   [ Forensic Report ]
                                           [ & Git Permitted ]   [ Pre-Commit Abort]

1. Polyglot Tree-Sitter Pruner :

• Compiles topological dependency trees. Distance 0 (target file) is preserved in full; Distance 1 dependencies retain signatures and docstrings while pruning implementation logic; Distance 2+ dependencies are reduced to compact type stubs.
• Built-in support for Python ,TypeScript/JavaScript ,Go , andJava .

2. SQLite WAL High-Concurrency Semantic Cache :

• Atomic multi-process caching configured with Write-Ahead Logging (PRAGMA journal_mode=WAL ) andbusy_timeout=5000ms , delivering sub-millisecond warm cache hits.

3. Atomic multi-process caching configured with Write-Ahead Logging (
4. Axiomatic Sieve Engine :

• Formal specification gatekeeper evaluating requirements against 5 negative invariants (shall never ), explicit mathematical bounds, deterministic state machines, and a 4-class error taxonomy.

5. Formal specification gatekeeper evaluating requirements against 5 negative invariants (

Inject perimeter rules, MCP server declarations, and pre-commit sentinels into your workspace:

ctxfw init --global

Automatically configures Google Antigravity, Cursor, and Claude Desktop.

ctxfw init --repo .

Deploys .git/hooks/pre-commit to prevent uncertified code commits lacking an attested specification brief.

For distributed engineering teams requiring centralized policy controls:

• Team-wide LLM budget circuit breakers : Hard token and dollar thresholds with automatic killswitches.
• Multi-node reverse proxy governance : Centralized firewall gateways supporting OpenAI and Anthropic streaming SSE endpoints.
• FinOps Telemetry Ledger : Aggregate tokens saved, cost elusion analytics, and tamper-evident audit trails.

Control Plane & Enterprise Licensing: https://ctxfw.heuristicolab.com

_{ENGINEERED BY HEURISTICO LAB // SKUNK WORKS DIVISION}

_{HIGH-ASSURANCE DEFENSE SYSTEMS GROUP}