RTK：砍掉 AI Agent 读取的 90% Bash 输出
AI 编程助手的 token 账单里，藏着一大块隐形消耗——bash 输出。跑一次失败的 cargo test，200 多行测试日志全部灌进上下文；git push 的进度条占 15 行；ls -la 一下 45 行……这些输出大部分是 agent 不需要的"噪音"，却实打实消耗 input token、挤占宝贵的上下文窗口。RTK（Rust Token Killer）的思路极其直接：做一个高性能 CLI 代理，拦截这些命令、把输出压缩最多 90% 再喂给 agent——单个 Rust 二进制、100+ 支持命令、<10ms 开销，一行命令接入 Claude Code、Cursor、Codex 等 16 个 AI 编程工具。参考 GitHub 仓库。
1、概述：RTK 是什么
官方一句话："High-performance CLI proxy that cuts up to 90% of the bash output your agent reads"（高性能 CLI 代理，削减 agent 读取的 bash 输出高达 90%）。它不做模型侧优化、不改 prompt，只做一件事：让命令输出在进入 LLM 上下文之前"瘦身"。
定位 高性能 CLI 代理，压缩 agent 读取的 bash 输出
形态 单个 Rust 二进制，100+ 支持命令，<10ms 开销
效果 bash 输出最多削减 90%（ls 45行→12行、git push→1行）
接入 一行 rtk init 接入 16 个 AI 编程工具（Hook 自动重写）
兼容 macOS / Linux / Windows 原生 / WSL 全支持
License Apache 2.0，Homebrew 可装核心要点：
1. 它是"命令输出与 LLM 上下文之间的压缩代理"
2. Rust 单二进制 + <10ms 开销，对工作流几乎零感知
3. 100+ 常用命令有专门定制的压缩 filter
4. 通过 Hook 自动把 git status 重写为 rtk git status，agent 无感
2、痛点：bash 输出是 token 的隐形杀手
看三组官方真实对比，直观感受"噪音"有多肥、压缩后有多瘦：
// ① 目录列表：45 行 → 12 行
# ls -la (45 行) # rtk ls (12 行)
drwxr-xr-x 15 user staff 480 ... my-project/
-rw-r--r-- 1 user staff 1234 ... +-- src/ (8 files)
...（还有 40+ 行） | +-- main.rs
+-- Cargo.toml
// ② git push：15 行 → 1 行
# git push (15 行) # rtk git push (1 行)
Enumerating objects: 5, done. ok main
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
...（还有 10+ 行进度条）
// ③ cargo test 失败：200+ 行 → 约 20 行
# cargo test (200+ 行) # rtk test cargo test (~20 行)
running 15 tests FAILED: 2/15 tests
test utils::test_parse ... ok test_edge_case: assertion failed
test utils::test_format ... ok test_overflow: panic at utils.rs:18
...（每个通过的测试都占一行）核心要点：
1. 进度条、逐条 pass 记录、冗长表头——对人有用，对 agent 全是噪音
2. 测试输出最肥：200+ 行里 agent 真正需要的只有"哪几个失败、为什么"
3. git push 的 15 行进度 → 一句 "ok main"，信息零损失
4. 这些噪音不仅烧钱，还挤占上下文窗口，加速长会话的上下文膨胀
3、四种压缩策略
RTK 按命令类型施加四种策略，不同命令组合不同：
策略 作用
------------------------------------------------------------------------
Smart Filtering 去噪：删注释、空白、样板输出
Grouping 聚合：按目录分组文件、按规则分组错误、按文件分组匹配
Truncation 截断：保留相关上下文，切掉冗余（如 git diff 减上下文行）
Deduplication 去重：重复日志行折叠 + 出现次数计数
// 各命令的处理方式（节选）
ls / tree → 树形 + 文件计数，不再一行一条
cat / read → 智能读文件：签名与结构，而非完整函数体
grep / rg → 截断长行，按文件分组
git log → 只要 hash、作者、主题
git add/commit → 一行确认（"ok abc1234"）
cargo/npm test → 只留失败，通过的折叠成计数
ruff check → 按规则和文件分组
docker ps → 只保留关键字段核心要点：
1. 不是粗暴截断，而是按命令语义定制的结构化压缩
2. 测试类输出"failures only + pass 计数"是最有价值的策略
3. read 的"签名优先"策略类似代码摘要——结构给 agent，函数体按需再读
4. -u（--ultra-compact）还能进一步压：ASCII 图标 + 内联格式
4、100+ 命令覆盖全景
覆盖开发工作流里几乎全部高频命令——文件、Git、测试、构建、包管理、云与容器、IaC、数据工具：
分类 代表命令
------------------------------------------------------------------------
文件 rtk ls / read / smart / find / grep / diff
Git rtk git status / log / diff / add / commit / push / pull
GitHub CLI rtk gh pr list / pr view / issue list / run list
测试 jest / vitest / playwright / pytest / go test /
cargo test / rspec / rtk test（通用包装，-90%）
构建与 Lint lint / tsc / next build / prettier / cargo build /
clippy / ruff / golangci-lint / rubocop / sbt
包管理 pnpm list / uv run / pip list / bundle install / prisma
AWS sts / ec2 / lambda / logs / cloudformation / dynamodb /
iam / s3（自动脱敏 secrets）
容器 docker ps / images / logs / compose +
kubectl pods / logs / services + OpenShift
IaC pulumi preview / up / destroy / refresh / stack
数据工具 json / deps / env / log / curl / wget / summary / proxy核心要点：
1. 从本地开发到云上运维（AWS/K8s/Pulumi）全链路覆盖
2. aws lambda list-functions 会自动剥离 secrets——压缩同时兼顾安全
3. 没有专用 filter 的命令可用 rtk summary（启发式摘要）或 proxy（原样透传+统计）
4. rtk discover 还能扫描历史命令，找出"还没被压缩的省钱机会"
5、Auto-Rewrite Hook：无感接入 16 个工具
最有效的用法是 rtk init 安装 Hook：它透明地拦截 Bash 命令，在执行前自动重写为 rtk 等价命令——所有会话和子代理 100% 采用，零逐命令开销：
// 接入：一行命令（按你的 AI 工具选）
rtk init -g # Claude Code / Copilot（默认）
rtk init -g --gemini # Gemini CLI
rtk init -g --codex # Codex (OpenAI)
rtk init -g --agent cursor # Cursor
rtk init -g --agent windsurf # Windsurf
rtk init --agent cline # Cline / Roo Code
rtk init -g --opencode # OpenCode 插件
# 还支持 Kilo Code / Kimi / Antigravity / Droid / Hermes / Pi 等，共 16 个
// 原理：Hook 在执行前自动重写
你输入: git status
实际执行: rtk git status → agent 收到紧凑输出
// 装完 restart AI 工具即可生效
// 重要限制（官方明确说明）：
// Hook 只作用于 Bash 工具调用。Claude Code 内置的 Read/Grep/Glob
// 不经过 Bash Hook，不会被自动重写——想要 RTK 的紧凑输出，
// 改用 shell 命令（cat/head/tail、rg、find）或直接调 rtk read/grep/find核心要点：
1. rtk init -g 一行接入，装完重启 AI 工具即生效
2. Hook 自动重写 Bash 命令，agent 与用户都无感知
3. 16 个工具各有专属接入机制（PreToolUse hook / hooks.json / 插件 API / 规则文件）
4. 注意边界：Claude Code 内置 Read/Grep/Glob 不走 Bash hook，需改用 shell 命令或 rtk 子命令
6、容错设计：失败时 tee 兜底
压缩会不会"把关键信息压没了"？RTK 用 tee 机制兜底：命令失败时自动保存完整未过滤输出，agent 需要时直接读文件，无需重新执行命令：
// 失败时的输出：紧凑结果 + 全量存档路径
FAILED: 2/15 tests
[full output: ~/.local/share/rtk/tee/1707753600_cargo_test.log]
// agent 需要细节时 cat 这个文件即可，不用重跑测试
// 配置：~/.config/rtk/config.toml
[hooks]
exclude_commands = ["curl", "playwright"] # 这些命令跳过重写
[tee]
enabled = true # 失败时保存全量原始输出（默认开）
mode = "failures" # "failures" / "always" / "never" 三档核心要点：
1. 失败才给全量：成功时只要一行"ok"，失败时细节一条不丢
2. 全量输出存本地文件，agent 按需读取，避免重新执行命令
3. exclude_commands 可把不适合压缩的命令（如 curl）排除出重写
4. 这是"激进压缩"与"信息完整性"之间的漂亮平衡
7、诚实的账本：90% 到底省了什么
这个项目最难得的地方是不夸大。官方明确区分"bash 输出削减 90%"和"账单减 90%"，并解释了逐级稀释：
// 稀释链：90% 在每一步都会被稀释
bash 输出 (-90%)
↓ 只是 input tokens 的一部分
input tokens（还有 prompt、系统提示、对话历史）
↓ 只是账单的一部分
账单（还有 output tokens）
// 因此：90% 是"agent 读取的 bash 输出"的削减率，不是账单削减率
// token 数按 bytes/4 估算（不内置 tokenizer）：
// 百分比可靠，绝对 token 数是近似值
// 量化你的真实收益：rtk gain
rtk gain # 汇总统计
rtk gain --graph # 最近 30 天 ASCII 图
rtk gain --history # 最近命令历史
rtk gain --all --format json # JSON 导出，接自己的仪表盘
rtk discover # 找出还没覆盖的省钱机会
rtk session # RTK 在最近会话中的采用率核心要点：
1. 诚实是亮点：明确说 90% 是 bash 输出的削减，不是账单的削减
2. 稀释链两层：bash 输出 ⊂ input tokens ⊂ 账单
3. token 数是 bytes/4 估算——百分比可信、绝对值近似
4. rtk gain / discover 让节省可量化、可审计、可导出
8、总结
RTK 抓住了 AI 编程的一个朴素洞察：agent 上下文里的 bash 输出，绝大部分是噪音。用一个 Rust 二进制做"输出压缩机"，配合 Hook 无感接入，token 与上下文双省。
关键要点：
- 定位：高性能 CLI 代理，削减 agent 读取的 bash 输出最多 90%
- 策略：Filtering / Grouping / Truncation / Dedup 四种，按命令语义定制
- 覆盖：100+ 命令（文件/Git/测试/构建/AWS/K8s/Pulumi/数据工具）
- 接入：rtk init -g 装 Hook 自动重写，16 个 AI 工具，agent 无感
- 兜底：失败时 tee 保存全量输出，细节不丢、无需重跑
- 诚实：90% 是 bash 输出削减而非账单削减，rtk gain 量化真实收益
- 注意：Claude Code 内置 Read/Grep/Glob 不走 Bash Hook，需换 shell 命令
对于重度使用 Claude Code、Cursor 等 AI 编程工具、又被 token 账单和上下文膨胀困扰的开发者而言，RTK 是"投产成本最低、回报最直接"的优化之一——brew install 加 rtk init 两步完成，从下一条 git status 开始就在省钱。它更示范了一种"AI 工具链 token 经济学"的思路：与其在模型和 prompt 上卷，不如先看看上下文里有多少字节根本不该进去。配合 rtk gain 的可视化，你会清楚看到自己的工作流里哪些命令最"费 token"；而它对"90% 不等于账单 90%"的坦诚，本身就是技术产品该有的样子。
