rtk-token-killer — Summary

One-liner: Rust binary that acts as a command proxy, intercepting CLI tool output before it reaches Claude Code's context window and compressing it 60-90% through smart filtering, grouping, truncation, and deduplication.

Identity

What It Does

rtk (Real Token Killer) is a Rust-based CLI command proxy that sits between Claude Code's Bash tool and the underlying shell commands. When a developer runs rtk init -g, it installs a PreToolUse hook into Claude Code's hook system. That hook intercepts every Bash command Claude attempts to execute and rewrites it to the rtk <cmd> equivalent, which runs the real command but filters, condenses, and deduplicates the output before returning it to Claude.

The result is 60-90% token reduction on command output while preserving all decision-relevant information. Token savings are tracked in SQLite and surfaced via analytics commands.

Key Capabilities

• Command proxy architecture: Each CLI family (git, jest, cargo, npm, kubectl, etc.) has a dedicated filter module in src/cmds/*/
• PreToolUse hook integration: hooks/claude/rtk-rewrite.sh wraps Bash tool calls; exit codes signal rewrite/no-equivalent/deny/ask
• Token analytics: rtk gain, rtk gain --graph, rtk gain --daily, rtk gain --history, rtk gain --all --format json
• Session tracking: rtk session shows current session savings
• Discoverability: rtk discover shows which commands in the current repo can be optimized
• Custom filters: .rtk/filters.toml per-project configuration
• Multi-tool init: rtk init -g (Claude Code/Copilot), --gemini flag, --codex flag, or --agent cursor/windsurf/cline/kilocode/antigravity/hermes
• Package managers: brew install rtk, cargo install rtk, prebuilt binaries

Scope

Single-purpose utility. No orchestration, no AI calls, no multi-agent patterns. Pure output compression pipeline with hook-based integration.

rtk-token-killer — Purpose & Workflow

Problem Solved

Every Claude Code session burns tokens on verbose CLI output: git status prints 40 lines, npm test spits 800 lines of Jest runner boilerplate, cargo build scrolls through dependency compilation logs. Claude reads all of it. Most of it is noise.

rtk intercepts this output stream at the PreToolUse boundary and compresses it before Claude sees it — achieving 60-90% token reduction without losing decision-relevant content.

Workflow

Claude attempts: bash("git status")
        ↓
PreToolUse hook (rtk-rewrite.sh)
        ↓
rtk rewrite "git status"
  → exit 0: "rtk git status"    (rewrite found)
  → exit 1: passthrough         (no equivalent)
  → exit 2: blocked             (deny rule)
  → exit 3: human approval      (ask rule)
        ↓
rtk git status
  → run real git status
  → filter: remove untracked preamble noise
  → group: consolidate similar lines
  → truncate: cap at threshold
  → dedupe: remove repeated patterns
        ↓
Compressed output returned to Claude
        ↓
SQLite tracking: original bytes, compressed bytes, command, timestamp

Workflow Phases

1. init — rtk init -g writes the hook file to ~/.claude/hooks/ and registers it in Claude Code's config; also installs init for other agents via flags
2. intercept — PreToolUse hook catches every Bash call, queries rtk for rewrite
3. compress — rtk runs the real command, applies filter module, returns condensed output
4. track — SQLite records the before/after byte counts per command
5. analyze — rtk gain aggregates savings, rtk discover finds optimization opportunities

Supported Command Families

Each family has a dedicated filter module under src/cmds/:

Setup Path

# Install
brew install rtk            # macOS
cargo install rtk           # cross-platform

# One-time init
rtk init -g                 # Claude Code + Copilot
rtk init -g --gemini        # Gemini CLI
rtk init -g --codex         # Codex
rtk init --agent cursor     # Cursor IDE

# Ongoing analytics
rtk gain                    # total savings
rtk discover                # optimization opportunities in current repo

rtk-token-killer — Commands & Skills

Claude Code Commands

rtk ships a .claude/commands/ directory but its primary integration path is the PreToolUse hook, not slash commands. The hook is auto-installed via rtk init -g.

No user-facing /project:* slash commands documented.

Claude Code Skills

None shipped as skill markdown files. The project has a .claude/ directory structure for hook registration, not for behavioral guidance files.

Hook Integration (Primary Interface)

The core integration is a single PreToolUse hook:

File: hooks/claude/rtk-rewrite.sh

#!/bin/bash
# rtk PreToolUse hook — intercepts Bash tool calls
# Exit codes:
#   0 = rewrite found (output: replacement command)
#   1 = no equivalent (passthrough)
#   2 = deny rule matched (block)
#   3 = ask rule matched (request human approval)

CMD="$1"
rtk rewrite "$CMD"

The hook delegates entirely to rtk rewrite "$CMD" — a single Rust function that is the source of truth for all rewrite decisions.

Registration: rtk init -g writes the hook registration into Claude Code's hooks config. The hook fires on every PreToolUse event where tool_name == "Bash".

rtk CLI Subcommands

These are rtk's own CLI surface, not Claude Code commands:

Custom Filter Configuration

.rtk/filters.toml (per-project):

[deny]
patterns = ["rm -rf /", "curl.*sudo"]

[ask]
patterns = ["git push --force"]

[truncate]
max_lines = 50

[dedupe]
enabled = true

rtk-token-killer — MCP & Tools

MCP Server

None. rtk does not ship an MCP server and does not register as an MCP server.

Integration Mechanism

rtk integrates with Claude Code exclusively through the PreToolUse hook pattern, not the MCP protocol. The distinction matters:

• MCP servers expose tools Claude can call
• rtk's hook intercepts tools Claude has already decided to call and rewrites the command before execution

This makes rtk a transparent proxy layer, not an additional tool surface.

Tool Ecosystem Coverage

rtk installs hooks across multiple AI coding tools via a single binary:

No AI Calls

rtk makes zero LLM/AI API calls. All compression is deterministic Rust code — pattern matching, regex, heuristic line grouping. No model is invoked during the proxy path.

Homepage

https://rtk-ai.app — product landing page with feature overview and install instructions.

rtk-token-killer — Uniqueness

differs_from_seeds

rtk has no direct analog among the 11 seeds. All seed frameworks address the input side of Claude's context — what CLAUDE.md, skills, and commands tell Claude to do. rtk addresses the output side — what command results Claude sees. This is a different and complementary axis.

Specifically:

• superpowers, BMAD-METHOD, spec-driver: behavioral guidance via skills and CLAUDE.md
• taskmaster-ai, spec-driver: task/workflow management via structured input specs
• Any seed with hooks: hooks in seeds are used for routing logic or pre/post actions — not for output compression
• None of the seeds use hooks to intercept and rewrite command output before Claude reads it

rtk's closest conceptual relative in the batch is claude-overlay (which also uses bash hooks), but claude-overlay configures model routing while rtk compresses tool output. They operate on different parts of the same hook lifecycle.

Positioning

• Primary differentiator: Output-side context management. The only tool in the catalog that reduces token consumption by filtering command output at the PreToolUse boundary before it enters Claude's context window.
• Secondary differentiator: Cross-tool breadth from a single binary. rtk init supports 10 different AI coding agents (Claude Code, Copilot, Gemini CLI, Codex, Cursor, Windsurf, Cline, Kilocode, Antigravity, Hermes) via a single Rust binary.
• Tertiary differentiator: Empirical token analytics. rtk gain surfaces concrete token savings data with historical trends and JSON export — treating token spend as a measurable engineering metric.
• Target user: Developers in heavy AI coding sessions who notice context window pressure from verbose tool output, and want to address it at infrastructure level without changing their development workflow.

Observable Failure Modes

1. Filter module coverage gaps: Commands not in any src/cmds/*/ module pass through uncompressed (exit 1). As the ecosystem evolves, new frameworks' test outputs won't be compressed until a module is written.
2. Information loss risk: Overly aggressive compression could strip output that Claude actually needs for debugging. Configuring truncation thresholds requires judgment.
3. Name collision on crates.io: Two different rtk crates exist; cargo install rtk may install the wrong one. Homebrew is the safe install path.
4. No watch mode for filter config: Changes to .rtk/filters.toml take effect immediately but there's no live reload or validation — misconfigured deny rules could silently block commands.
5. Rust binary distribution friction: Non-Homebrew users must either use cargo or download prebuilt binaries; no npm/pip/deb install path for non-Rust developers.

Most Surprising Finding

54,590 GitHub stars — the most popular tool in this 33-batch catalog by a large margin (ccs-switch at 2,410 is the second in this batch). The combination of a simple hook-based approach, Rust performance, and measurable token savings appears to have resonated with the developer community at scale despite being a narrow single-purpose utility.