Tokf

Tokf

Tokf filters terminal command output before your AI coding assistant reads it, cutting cargo and npm noise by up to 98%.

76/100Safe BetFreeFree

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

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
  • Privacy-conscious developers who need filtering to run fully offline or air-gapped
Not ideal for
  • 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
Visit Website

IntermediateHomebrew 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.CLINo public APIVerified 8h ago
Pricing
Free
FreeFree tier
Learning curve
Intermediate
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.
Runs on
CLI
No public API · 15 integrations
Who it's for
Rust developer running Claude Code against a large workspaceTeam lead who wants savings to apply without anyone remembering to wrap commandsPrivacy-constrained engineer on an air-gapped or restricted network
Live sentiment
Is Tokf actually worth it?

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
Run a free scan

3 free scans · no card needed

Skip it if

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.

The 30-second take
Price reality

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 ago

Across the latest 5 updates: 5 feature updates.

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

76/100
Safe Bet

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

Recent activity
90
Traction
100
Site health
95
User sentiment
58
What the vendor publishes
40

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

FreeIntermediateNo APICLI

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.

Rust developer running Claude Code against a large workspace

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.

Team lead who wants savings to apply without anyone remembering to wrap commands

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.

Privacy-constrained engineer on an air-gapped or restricted network

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.

  1. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — 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.

Annual total
Free
Over 12 months
Effective monthly
—
—

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.

Migrating in
  • →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.
Migrating out
  • ↗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

Claude CodeCodexCursorAiderGemini CLIClineWindsurfgitmakejustmisecargodockernpmpnpm

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.

Tools that pair well with Tokf

Common stack mates teams adopt alongside Tokf, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Tokf

View all
Claude Code

Claude Code

Anthropic's agentic coding assistant that plans, edits, and runs commands across your repo from the terminal, IDE, browser, or cloud session.

FreemiumTry
Codeium

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

FreemiumTry
Junie (JetBrains)

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.

FreemiumTry

Frequently Asked Questions

Used Tokf? Help shape our editorial sentiment research.