Tokf
Tokf filters terminal command output before your AI coding assistant reads it, cutting cargo and npm noise by up to 98%.
If your AI coding assistant keeps choking on cargo, docker or npm output, tokf is the cleanest fix available: filter upstream, keep the original command intact, run offline with no account. The TOML filters live in your repo so teammates can review them instead of trusting a black box. Budget a few hours for in-house build tooling the 63 built-ins don't cover — and note it's a terminal-only tool.
Verified 8h ago · liveness 76/100 · cite: rightaichoice.com/tools/tokf
- Developers running Claude Code, Copilot, Cursor, Aider, Gemini CLI or Codex against real repos
- Rust and JS/TS teams whose cargo, npm, pnpm and Next.js output floods every LLM turn
- Teams that want token-savings filters checked into git and reviewed like any other config
- Privacy-conscious developers who need filtering to run fully offline or air-gapped
- Anyone not using a terminal-based AI coding assistant — there is no GUI or web app
- Workflows where command output is already only a few lines, so the compression win is near zero
- Teams unwilling to author and maintain TOML (and sometimes Luau) filters for internal build tooling
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip tokf if you want your LLM to summarise noisy command output rather than filter it upstream, or if your daily noise comes from proprietary build scripts tokf ships no filter for.
Tokf's pricing fits teams whose volume aligns with the published tiers. Compare against the alternatives listed below for stage-specific value.
In short
Tokf — Tokf filters terminal command output before your AI coding assistant reads it, cutting cargo and npm noise by up to 98%. Best for Developers running Claude Code, Copilot, Cursor, Aider, Gemini CLI or Codex against real repos, Rust and JS/TS teams whose cargo, npm, pnpm and Next.js output floods every LLM turn, Teams that want token-savings filters checked into git and reviewed like any other config. Free to use.
What's new in Tokf
Checked 6 days agoAcross the latest 5 updates: 5 feature updates.
v0.2.54 — leave git unrewritten inside linked worktrees
tokf now leaves git commands unrewritten when running inside a linked worktree, avoiding interference with worktree-specific git state.
v0.2.53 — capture pipelines to surface swallowed exit codes
Pipelines are now captured so exit codes that a shell pipeline would otherwise swallow become visible; program resolution was also fixed to match Windows behaviour.
v0.2.52 — reject nondeterministic filters at publish time
Filters that produce nondeterministic output are now rejected when published, and `run` overrides honestly report what was actually executed.
v0.2.51 — rarity-weighted richness metric in tokf verify
Adds a rarity-weighted richness metric to `tokf verify`, annotates filtered output with its history entry ID, asserts byte-stable filter output across runs, and recalibrates the bytes/4 token estimator.
v0.2.50 — unwrap local environment wrappers (nix develop -c)
tokf now unwraps local environment wrappers such as `nix develop -c`, so commands run inside those wrappers still get matched to the right filter.
What people actually say about Tokf — is it worth it?
We scanned public community sources for Tokf on Sep 22, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Only 3 of the posts we fetched could be positively tied to Tokf. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
Viability Score
How well maintained and how widely used is Tokf? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Filters terminal command output through TOML filters before it reaches your LLM
- Run any command through filtering with `tokf run <command>`
- Automatic git hooks filter every commit, push and pull after one install
- Transparently wraps make, just and mise task runner targets
- 63 built-in command patterns across cargo, docker, git, gh, go, gradle, kubectl, Next.js, npm, pnpm, prettier, prisma,
- TOML filter files stored in .tokf/filters/ and version-controlled with your repo
- Filter precedence: local, then user, then built-in library, first match wins
- `tokf which "cargo test"` shows which filter file will be applied
- Sandboxed Lua/Luau scripts for numeric math, multi-line lookahead and branching
- Filter pipeline stages: skip/keep, replace, dedup, on_success and on_failure
- `tokf skill install` lets AI agents author and install filters, with a PreToolUse hook
- PreToolUse hook for real-time filtering inside Claude Code and, since v0.2.46, Codex
- `tokf doctor` detects filters that cause agent confusion
- `tokf discover` surfaces token savings you are currently missing in past AI sessions
- `tokf verify` checks filter output with a rarity-weighted richness metric and byte-stability assertions (v0.2.51)
About Tokf
tokf is a Rust CLI that sits between your shell and your AI coding assistant. Prefix a command with `tokf run <command>` and it spawns the process, captures stdout and stderr, matches the command against a TOML filter, then hands your model only the signal — the vendor example turns a 1.7 KB `cargo test` dump into 35 bytes. Install its git hooks once and every commit, push and pull runs through the filters automatically, and task runner substitution wraps make, just and mise targets without editing a single task file. The filter library is plain TOML living in `.tokf/filters/`, version-controlled and reviewable like any other repo config. Precedence runs local, then user, then built-in library, first match wins, and `tokf which "cargo test"` tells you which file was picked. Where TOML runs out of road there's a sandboxed Luau escape hatch for numeric math, multi-line lookahead and branching. The pipeline is explicit: skip/keep, replace, dedup, on_success and on_failure. Built-ins are the practical draw — 63 command patterns across cargo, docker, git, gh, go, gradle, kubectl, Next.js, npm, pnpm, prettier, prisma, ruff and vite, all overridable locally. Agents can author filters themselves via `tokf skill install`, which wires a PreToolUse hook into Claude Code and, since v0.2.46, Codex. Recent releases tightened quality control: v0.2.52 rejects nondeterministic filters at publish time, v0.2.53 captures pipelines to surface swallowed exit codes, and v0.2.54 leaves git unrewritten inside linked worktrees. v0.2.50 added unwrapping of local environment wrappers such as `nix develop -c`. Everything is local by default — no telemetry, no phone-home, no account, token stats in local SQLite, works air-gapped. Optional cloud sync stays inert until you run `tokf auth login`. Compared with prompt-compression libraries that rewrite what you send the model, tokf cuts at the source: the original command runs untouched and only noise is removed.
Behind the Verdict
Most token-saving tools for coding agents work on the prompt side: they summarise, compress, or rewrite what you send the model. tokf goes the other way. The command runs exactly as written, and the filter strips noise from its output before the model ever sees it. When a `cargo test` dump collapses from 1.7 KB to 35 bytes, you're saving context on every turn without touching your code or your prompt. Pick this when you live in a terminal and run an agent against a real repo. Rust teams drowning in cargo build and clippy output, JS/TS teams with npm, pnpm and Next.js spew, anyone whose kubectl or gradle output eats half the context window — those are the wins. The git hook install is the sleeper feature: set it once and every commit, push and pull gets filtered without you remembering to prefix anything. Where it bites is custom tooling. The 63 built-ins cover the popular stack, but in-house build scripts and bespoke CLIs need hand-written TOML, and occasionally Luau when the logic gets conditional. That's maintenance on your team, checked into the repo — fine if you treat filters like lint config, annoying if nobody owns them. We'd skip it if your commands already print a few clean lines, or if you'd rather have the LLM summarise noisy output than filter it upstream. There's also no GUI or web app; it's a CLI, full stop. The closest alternative is prompt-compression middleware, which is provider-agnostic but leaves the original noise in the shell and can alter what the model reads. tokf's bet is that the source is the better place to cut. Recent releases suggest the team cares about correctness over feature count: v0.2.52 rejects nondeterministic filters at publish time, v0.2.53 captures pipelines so swallowed exit codes become visible, and v0.2.54 stops rewriting
Researching Tokf? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Tokf actually fits — and what changes day-one when you adopt it.
You install tokf, run `tokf run cargo test` on a failing suite, and watch a 1.7 KB dump become the handful of failing assertion lines the model actually needs.
Outcome: Fewer tokens per turn and a model that reacts to the failure instead of the wall of green-pass output.
You install the git hooks once; from then on every commit, push and pull output is filtered automatically, and you wrap make, just or mise targets via task runner substitution so those logs are condensed too.
Outcome: Filtering becomes the default rather than a habit, and the TOML filters sit in `.tokf/filters/` where teammates can review them in a pull request.
You run tokf entirely locally — token stats go to local SQLite, no telemetry, no account, no network requests — and use `tokf doctor` and `tokf discover` to tune filters without any external service.
Outcome: Token savings inside the model's context window with nothing leaving the machine.
Use Cases
- Cut token usage by compressing cargo build and test output before it reaches Claude Code
- Automatically strip noise from git diff and git status output when using Copilot inline chat
- Set up git hooks so every commit, push and pull command is filtered without manual wrapping
- Wrap make, just or mise targets so build logs are condensed before reaching an agent
- Use `tokf doctor` to find filters that confuse agents and `tokf discover` to find missed savings
- Share custom filter sets across a team via optional, explicitly enabled cloud sync
Limitations
- tokf is a CLI tool that filters command output for LLMs; it requires comfort with terminals and command-line workflows.
- Advanced filtering may require knowledge of TOML and, for complex logic, Luau scripting.
- The tool is in early versioning (v0.2.54 as of September 6, 2026) and while stable, features may evolve.
- The published built-in filters will not cover bespoke internal build tooling, so you should expect to write and maintain your own filters.
as of 2026-10-12
Verification history
We have re-verified Tokf 11 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-checked, vendor evidence unchanged
Showing the 6 most recent of 11 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Tokf tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Individual developers and teams using a terminal-based AI coding assistant who want filtering to run locally with no account and no recurring cost.
What this tier adds
Starting tier — MIT licensed at $0/mo, covering all 63 built-in filters, git hooks, task runner substitution, the Luau escape hatch and optional cloud sync.
Where the pricing makes sense
The company stage and team size where Tokf's pricing actually pencils out — and where peers do it cheaper.
Tokf's pricing fits teams whose volume aligns with the published tiers. Compare against the alternatives listed below for stage-specific value.
Setup time & first value
How long it actually takes to get something useful out of Tokf — broken out by persona, not the marketing-page minute.
Homebrew or Cargo install gets a working `tokf run` in minutes. If you are running Claude Code or Codex, `tokf setup` is an interactive wizard for AI tool detection, and `tokf skill install` wires the PreToolUse hook. git hooks and task runner wrapping are one-time installs. Expect a few hours to author filters for in-house build tooling the built-ins do not cover.
Switching to or from Tokf
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From hand-rolled shell aliases or wrapper scripts: replace the alias with `tokf run <command>` and let the filter pipeline handle skip/keep and dedup.
- →From prompt-compression libraries: stop rewriting what you send the model and let the original command run, then keep only the signal.
- →From copying build logs into the chat manually: install the git hooks and let commit, push and pull output filter themselves.
- ↗To hand-written TOML-only filtering: your `.tokf/filters/` files are readable text, but the pipeline stages, Luau escape hatch and `tokf which` resolution are tokf-specific.
- ↗To a prompt-compression approach: you would move the trimming from the command output to the message you send, and lose the guarantee that the original command ran unmodified.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Tokf”, and we withheld 6: 6 could not be judged, because “Tokf” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Tokf.
Official links
Tools that pair well with Tokf
Common stack mates teams adopt alongside Tokf, with the specific reason each pairing earns its keep.
Claude Code
Anthropic's agentic coding assistant that plans, edits, and runs commands across your repo from the terminal, IDE, browser, or cloud session.
Codeium
Devin Desktop is a free AI coding assistant and agent IDE with unlimited Tab completions and an Agent Command Center for fleets of local
Junie (JetBrains)
Junie is JetBrains' AI coding agent: run it in your terminal, IDE, GitHub, or GitLab on any model you bring — with a free local Mac build.
Featured Head-to-Head Comparisons
Tokf vs Spider Cloud
Choose Spider Cloud if you need real-time, structured web data for AI agents or RAG pipelines, especially with its new browser AI commands and 1000+ scrapers. Choose Tokf if you're a developer using Claude Code or Copilot and want to slash token costs from CLI output—it's free, offline, and can reduce payload by 98%. They solve completely different problems, so your decision depends on whether you need to gather web data or compress command output.
Tokf vs Temporal Ai
Temporal AI is the right choice for teams building durable, failure-resistant AI agents and orchestrating complex workflows with retries and rollbacks. Tokf is a niche but powerful cost-saving tool for developers who feed terminal output into LLMs. Choose Temporal for orchestration, Tokf for token efficiency.
Tokf vs Voyage Ai
Voyage AI and tokf address completely different needs: Voyage AI improves retrieval accuracy in RAG pipelines with fine-tuned embeddings and rerankers, while tokf reduces token costs by compressing CLI output before it reaches an LLM assistant. Choose Voyage AI if you're building enterprise RAG on specialized domains; choose tokf if you're a developer wanting to cut token waste from command output in your AI coding workflow.
Alternatives to Tokf
View allClaude Code
Anthropic's agentic coding assistant that plans, edits, and runs commands across your repo from the terminal, IDE, browser, or cloud session.
Codeium
Devin Desktop is a free AI coding assistant and agent IDE with unlimited Tab completions and an Agent Command Center for fleets of local
Junie (JetBrains)
Junie is JetBrains' AI coding agent: run it in your terminal, IDE, GitHub, or GitLab on any model you bring — with a free local Mac build.
Frequently Asked Questions
Best-of guides
Used Tokf? Help shape our editorial sentiment research.