What it actually does
Agents run shell commands and then read the output. Run `ls` in a large directory, or `git log`, or a verbose test suite, and thousands of tokens of low-information text land in the context window. You pay for all of it, and it crowds out things that matter.
RTK is a proxy that intercepts commands and compresses their output before the agent reads it. `ls` and `tree` become compact tree formats. Over a hundred commands are supported, with under 10ms of overhead, from a single Rust binary with no dependencies.
The claimed reduction is 60–90% on common development commands, which on a long agentic run is a material change to both cost and context pressure.
Apache 2.0, 75,000 stars. Note the open issue count is high relative to stars — worth checking whether your specific commands are well handled before relying on it.
Who it's for
- 01
Anyone running long agentic sessions where context fills with command noise
- 02
Teams where model spend on input tokens is material
- 03
Developers whose agents work in large repositories with verbose tooling
- 04
People hitting context limits mid-task rather than mid-project
Where it earns its keep
- Cutting input token cost across a team's agent usage
- Keeping more useful context available during long runs
- Working in large monorepos where directory listings are enormous
- Reducing the noise an agent has to reason through
- Extending how far a session can go before hitting a context limit
Use it, or skip it
Reach for it when
- Your agents run many shell commands per session
- Input token cost is showing up meaningfully on the bill
- Context exhaustion is interrupting work
- Your repositories are large enough that command output is genuinely verbose
Skip it when
- The agent needs exact raw output — compression is lossy by design
- Your workflows use commands the proxy does not handle well
- You are debugging something where every line of output matters
- Adding a proxy into your shell path is more risk than the saving justifies
10 automations
Ideas, not tutorials. Each one is work a team does by hand today.
- 01Finance
Input token cost reduction
Deploy across the team and report the change in input token spend over a month.
- 02Engineering
Longer effective sessions
Measure how much further agent sessions get before hitting context limits after enabling it.
- 03Engineering
Monorepo agent support
Make agents usable in very large repositories where raw directory output would flood context.
- 04Engineering
CI log compression
Compress verbose CI output before an agent reads it for failure triage.
- 05Engineering
Command coverage audit
Check which of your team's most-used commands are supported before rolling it out widely.
- 06Finance
Stacked token optimisation
Combine with an output-compression skill and measure the effect on both sides of the bill.
- 07Engineering
Context budget monitoring
Track what fraction of context is consumed by tool output versus actual work.
- 08Engineering
Selective bypass rules
Configure exceptions so debugging sessions get raw output while routine work stays compressed.
- 09Engineering
Rate limit relief
Fewer input tokens per turn means fewer throttling stalls on constrained plans.
- 10Engineering
Before-and-after benchmark
Run an identical task with and without the proxy to verify the claimed reduction on your workload.
Want one of these running by Friday?
LimeDock builds these as real workflows inside your stack — deployed to your cloud, wired into your Slack and CRM, with the code in your repo. You pay a build fee and your own API keys, nothing else.
Source
Repository stats were read from the GitHub API and reflect the last time we refreshed this entry. The editorial breakdown above is LimeDock’s own analysis — we are not affiliated with rtk-ai.
https://github.com/rtk-ai/rtk