DEV Community: bayuh85

skimsearch: stop pasting grep dumps into your coding agent

bayuh85 — Fri, 16 Oct 2026 02:39:45 +0000

Repo: 👉 github.com/bayuh85/skimsearch (MIT, Python 3.10+)

The problem

Ask a coding agent "where is the late fee calculated?" and watch what happens. It runs grep -rn "late fee", gets back dozens of hits from code, docs, vendored dependencies, and tests, and pastes the whole dump into its context. Then it opens three wrong files before finding the right function.

Every one of those lines is tokens you pay for, re-read on every turn, crowding out the few lines that actually answer the question.

What skimsearch does

skimsearch indexes the tree once, then answers with a short deck of ranked snippets that fits a token budget.

Index. skimsearch index folds code and docs into skim cards: one function, class, heading, or text window each, with its path and line range. Cards live in a compact SQLite file at .skimsearch/index.sqlite, ranked offline with SQLite FTS5 (BM25).
Search. skimsearch search returns the best cards, trimmed so the whole deck stays inside a budget (700 tokens by default). Lexical mode never touches the network.
Ask. --mode semantic lets a cheap model turn a prose question into a few lexical probes, then searches locally. --mode ask also returns a short answer that cites only the cards it used.

It respects .gitignore, supports a .skimignore, and skips dependency folders, lockfiles, and secret files like .env and .pem.

Real use case: finding the late fee

The repo ships a small sample project, examples/acme-billing, with code, docs, a vendored folder, and a fake .env. Install and index it:

git clone https://github.com/bayuh85/skimsearch.git
cd skimsearch
python -m venv .venv
source .venv/bin/activate
pip install -e .

skimsearch index examples/acme-billing
skimsearch search "where is the late fee calculated" --path examples/acme-billing

The output:

skimsearch  mode=lexical  cards=4  tokens=322/700

1. src/billing/invoices.py:17-28  function apply_late_fee  (python, score 1.71)
    def apply_late_fee(invoice: dict, as_of: date) -> dict:
        """The late fee is calculated from the subtotal after the grace window."""
        if invoice.get("settled"):
            return invoice
        overdue = (as_of - invoice["due"]).days
        if overdue <= GRACE_DAYS:
            return invoice
        fee = round(invoice["subtotal"] * LATE_FEE_RATE, 2)
        ...

2. docs/billing.md:3-5  heading Late fees  (markdown, score 1.50)
    ## Late fees

    A fee of 1.5 percent is added after a three-day grace period.

322 tokens, with the right function first and the matching docs right below it. The vendored code and the fake .env never show up. That's what the agent reads instead of a raw grep dump.

If you'd rather get a direct answer:

export ATMOROUTER_API_KEY=ar-your-key-here
skimsearch search "where is the late fee calculated" --path examples/acme-billing --mode ask

Plugging it into Cursor or Claude Code (MCP)

skimsearch serve runs a stdio MCP server (and builds the index if it's missing). For Claude Code, add this to .mcp.json:

{
  "mcpServers": {
    "skimsearch": {
      "command": "skimsearch",
      "args": ["serve", "/absolute/path/to/repo"],
      "env": { "ATMOROUTER_API_KEY": "ar-your-key-here" }
    }
  }
}

Cursor uses the same block in .cursor/mcp.json. The agent gets two tools: skim_search (query, mode, budget, limit, format) and skim_status. Use lexical in tight loops and ask for prose questions.

Handy commands

skimsearch index . --force          # rebuild
skimsearch index . --embed          # also store /embeddings vectors
skimsearch search "session ttl" -C . --budget 500
skimsearch search "session ttl" --mode ask --format json
skimsearch status .

The test suite (44 tests) runs fully offline: pip install -e ".[dev]" && pytest -q.

About AtmoRouter (the default model endpoint)

Semantic and ask modes call an OpenAI-compatible chat API, and the default base URL is https://atmorouter.dev/v1. AtmoRouter is a cheap AI API gateway and an OpenRouter alternative: 109 models behind one key, compatible with both OpenAI and Anthropic clients, pay per token, with prices averaging 83.7% below official rates. It also accepts QRIS and USDC. That fits this tool's job: query rewriting should cost far less than the coding model it's saving tokens for. The default model is atmo/deepseek-v4.1-flash.

Prefer the Anthropic Messages API? Set SKIMSEARCH_API_STYLE=anthropic. Want another provider? Point SKIMSEARCH_BASE_URL at any OpenAI-compatible endpoint. And lexical search needs no key at all.

Try it

If your agent keeps drowning in grep output, give it a deck instead:

👉 github.com/bayuh85/skimsearch

Issues with a query that ranks badly (plus a small sample repo) are the most useful feedback you can send.

atmo-mem: persistent memory for Claude Code, Cursor, and Cline in one Go binary

bayuh85 — Thu, 15 Oct 2026 17:47:15 +0000

Repo: 👉 github.com/bayuh85/atmo-mem (MIT, pure Go, no CGO)

The problem

Every new coding-agent session starts with amnesia. You spent yesterday's session with Claude Code working out why the auth refresh was flaky, decided on an approach, and agreed on a few project conventions. Today you open a fresh session and the agent has forgotten all of it. Either you explain it again, or you keep a hand-maintained notes file and hope the agent reads it.

What I wanted was boring: a local place where the agent can write down decisions and fixes as it works, and look them up at the start of the next session. No hosted service, no Docker, no Python environment. Just one binary.

What atmo-mem does

atmo-mem is persistent cross-session memory for coding agents, shipped as one static binary.

It speaks the Model Context Protocol over stdio, so Claude Code, Cursor, Cline, and other MCP clients can use it.
The agent saves decisions, bugfixes, and facts while it works.
A later session searches and recalls them from a local SQLite database with an FTS5 full-text index.
At the end of a session, atmo-mem can compress the notes into a summary with any OpenAI-compatible model (default: zai/glm-5.3).

Privacy-wise, the important part is: save, search, and recall stay on disk. Only session_summarize calls the network.

SQLite is compiled in through modernc.org/sqlite (pure Go, FTS5 included), so you don't need CGO or a system SQLite library.

Quickstart

You need a Go toolchain. Clone and build:

git clone https://github.com/bayuh85/atmo-mem.git
cd atmo-mem
CGO_ENABLED=0 go build -o atmo-mem ./cmd/atmo-mem

Move the atmo-mem binary somewhere on your PATH, then check it:

atmo-mem version

The README also describes a go install command and GoReleaser archives for Linux, macOS, and Windows (amd64 and arm64) for tagged releases. When I wrote this the repo had no published releases yet, so building from a checkout is the reliable route.

If you want end-of-session summaries, configure an API key:

cp .env.example .env
# edit ATMO_MEM_API_KEY

You can try it without an agent first. The CLI uses the same database:

atmo-mem save --project my-app --kind decision \
  --title "Use FTS5" \
  --content "Memory search is SQLite FTS5." \
  --tags sqlite,search

atmo-mem search --project my-app fts
atmo-mem recall --project my-app memory search
atmo-mem summarize --project my-app \
  --notes "We stored memories in SQLite and exposed them over MCP."

Flags go before positional arguments. Add --json to get JSON output from save, search, recall, list, get, and summarize. atmo-mem help lists every command.

Setting it up with your agent

Running atmo-mem with no arguments (or atmo-mem mcp) reads JSON-RPC from stdin and writes JSON-RPC to stdout, with logs on stderr. In an interactive terminal it prints help instead; when stdin is a pipe, which is how editors launch it, it starts the MCP server. Don't wrap it in a script that prints a banner, because that breaks the protocol.

Two tips from the README:

Set ATMO_MEM_PROJECT to the repo name so memories from different projects don't mix.
Pass ATMO_MEM_API_KEY only if you want end-of-session summaries.

Claude Code

Project .mcp.json:

{
  "mcpServers": {
    "atmo-mem": {
      "command": "atmo-mem",
      "args": [],
      "env": {
        "ATMO_MEM_API_KEY": "your-key",
        "ATMO_MEM_PROJECT": "my-app"
      }
    }
  }
}

Or with the CLI (flags vary slightly across Claude Code versions; the JSON above is the stable form):

claude mcp add --transport stdio --scope project \
  --env ATMO_MEM_API_KEY=your-key \
  --env ATMO_MEM_PROJECT=my-app \
  atmo-mem -- atmo-mem

Cursor

Put the same block in .cursor/mcp.json in your project (or ~/.cursor/mcp.json for a global config), then reload MCP servers from Cursor settings. atmo-mem has to be on the PATH Cursor sees, or you can set command to the absolute path.

Cline

Open MCP Servers → Configure (cline_mcp_settings.json) and add:

{
  "mcpServers": {
    "atmo-mem": {
      "command": "atmo-mem",
      "args": [],
      "env": {
        "ATMO_MEM_API_KEY": "your-key",
        "ATMO_MEM_PROJECT": "my-app"
      },
      "disabled": false,
      "autoApprove": ["memory_recall", "memory_search", "memory_list", "memory_get"]
    }
  }
}

The auto-approve list here is a good default: read-only tools run without prompting, while memory_delete (destructive) and session_summarize (a billed network call) still ask for approval.

Teach the agent the workflow

The tools only help if the agent calls them. The README suggests this loop, which works well in CLAUDE.md, Cursor rules, or Cline custom instructions:

At the start of a task, call memory_recall with the task and the project.
When a decision, fix, or preference lands, call memory_save.
At the end of the session, call session_summarize with notes, or with a session_id you used along the way.

The tools

Tool	What it does
`memory_save`	Store `title`, `content`, optional `kind`, `tags`, `project`, `session_id`.
`memory_search`	AND keyword search. Words of 3+ characters are prefix-matched (`auth` finds `authentication`).
`memory_recall`	Rank memories for a task. An empty query returns recent project memory. The newest summary is pinned first.
`memory_list`	Recent memories, newest first.
`memory_get`	One memory by id.
`memory_delete`	Permanently delete one memory by id.
`session_summarize`	Compress a transcript and that session's memories with the LLM, then store a `summary`.

Memory kinds: observation (default), decision, bugfix, preference, fact, summary, task.

How it works

Search vs. recall

The two lookups deliberately behave differently:

Search is strict. A memory is returned only when every query word matches. Results are ordered by FTS5 bm25, with the title weighted above the body and tags.
Recall is wide. Any word can match, and a small recency bonus breaks near ties. The latest summary for the project goes to the front even if it shares no words with the query. A much stronger text match still outranks a memory that's only newer.

Common English filler words (the, and, for, …) are dropped when the query has other words. Matching is case-insensitive, words shorter than two characters are ignored, and two-character words such as go match exactly.

Storage

Everything lives in one SQLite file, by default ~/.atmo-mem/atmo-mem.db. The directory is created with mode 0700, and the file is set to 0600 where the OS allows it. Triggers keep an FTS5 index (unicode61 tokenizer) in sync on insert and delete.

There's no update call: to change a memory, delete the old id and save a new one. Sessions are just bookkeeping rows. What the next session actually reads is a normal memory with kind summary.

Summarization

session_summarize sends the transcript or notes, plus memories saved under that session_id, to POST {ATMO_MEM_BASE_URL}/chat/completions with a standard body (model, messages, temperature, max_tokens) and stores the result as a summary memory. Because recall pins the newest summary, the next session starts with it.

Configuration

Settings are read from flags first, then environment variables, then a .env file in the working directory; the first non-empty value wins. ATMO_MEM_* takes precedence over the OPENAI_* fallbacks.

Variable	Default	Purpose
`ATMO_MEM_API_KEY`	empty	Bearer token for summarization (falls back to `OPENAI_API_KEY`).
`ATMO_MEM_BASE_URL`	`https://atmorouter.dev/v1`	OpenAI-compatible base URL, including `/v1` (falls back to `OPENAI_BASE_URL`).
`ATMO_MEM_MODEL`	`zai/glm-5.3`	Model id (falls back to `OPENAI_MODEL`).
`ATMO_MEM_DB`	`~/.atmo-mem/atmo-mem.db`	SQLite file.
`ATMO_MEM_PROJECT`	empty	Project used when a call omits `project`.
`ATMO_MEM_TIMEOUT`	`60s`	Summarization timeout.

Credit

atmo-mem is inspired by claude-mem and engram, two projects that have explored persistent agent memory further than this one. atmo-mem is not affiliated with either. Its angle is narrow: one dependency-free binary, local SQLite + FTS5, and an optional summary step that works with any OpenAI-compatible endpoint. If you want something richer, look at those projects too.

About AtmoRouter: a cheap AI API gateway and OpenRouter alternative

Disclosure: by default, session_summarize sends requests to AtmoRouter using zai/glm-5.3; summaries don't need the model you code with. Any OpenAI-compatible provider works. AtmoRouter is a cheap AI API gateway that speaks both the OpenAI Chat Completions API and the Anthropic Messages API, so one key reaches 100+ models from Cursor, Cline, Claude Code, or any compatible client. It is pay-per-token with no subscription, accepts QRIS and USDC, and prices sit well below official rates: AtmoRouter advertises an average of 83.7% below official prices, which makes it an affordable LLM API and a practical OpenRouter alternative for agent workloads.

Try it

If you're tired of re-explaining your project to a fresh agent session every morning:

👉 github.com/bayuh85/atmo-mem

Issues and PRs are welcome. Real-world reports on how recall ranking holds up across a long-running project would be especially useful.

ctxtrim: stop feeding your coding agent 300-line logs

bayuh85 — Thu, 15 Oct 2026 17:26:38 +0000

Repo: 👉 github.com/bayuh85/ctxtrim (MIT, Node.js 20+)

The problem

Coding agents like Claude Code, Cursor, and Cline are great until the context window fills up with junk. A test run dumps hundreds of lines. A server log repeats the same startup message over and over. The agent cats a large JSON file to check one field. All of that lands in context, gets re-read on every turn, and pushes out the stuff that actually matters — like what you decided twenty minutes ago.

The usual fixes are manual: | tail -50, grep ERROR, or telling the agent "please don't read the whole file." That works until it doesn't.

What ctxtrim does

ctxtrim shrinks what a coding agent reads:

Press: large logs, test runs, and file dumps are trimmed mechanically — no network, no key needed.
Gloss (optional): if the trimmed result is still big, a cheap OpenAI-compatible model summarizes it (default: zai/glm-5.3).
Session notes: decisions and findings go into a compact session ledger instead of a growing transcript.

It ships as both a command-line tool and an MCP server, and both expose the same operations.

Quickstart

Requires Node.js 20 or newer.

git clone https://github.com/bayuh85/ctxtrim.git
cd ctxtrim
npm install
npm run build

The mechanical press works with no key at all. If you want model summaries, set a key:

cp .env.example .env
# CTXTRIM_API_KEY=your-key

Now pipe something noisy through it:

export CTXTRIM_API_KEY=your-key
# optional; these are already the defaults
export CTXTRIM_BASE_URL=https://atmorouter.dev/v1
export CTXTRIM_MODEL=zai/glm-5.3

npm test 2>&1 | node dist/cli.js shrink --kind test --session demo
node dist/cli.js note add --session demo --tag decision "Retry refresh with jitter."
node dist/cli.js recall --session demo

The brief goes to stdout (so you can keep piping), and a one-line receipt goes to stderr. The README's example: pressing a 300-line log containing three connection errors and one warning reports:

ctxtrim · log · press · 12578 → 1299 bytes · kept 10%

The brief keeps the repeated startup line collapsed (ready ×3), the errors, the warning, and the head and tail. The quiet middle becomes a single omission line.

The receipt tells you which path was taken:

passthrough — input was already small
press — mechanical trim
gloss — model summary
cache — a gloss reused for the same text and model

Setting it up with your agent (MCP)

Build first (npm run build), then point your client at node /absolute/path/to/ctxtrim/dist/cli.js serve.

Claude Code

Project .mcp.json (or your user config):

{
  "mcpServers": {
    "ctxtrim": {
      "command": "node",
      "args": ["/absolute/path/to/ctxtrim/dist/cli.js", "serve"],
      "env": {
        "CTXTRIM_API_KEY": "your-key",
        "CTXTRIM_BASE_URL": "https://atmorouter.dev/v1",
        "CTXTRIM_MODEL": "zai/glm-5.3"
      }
    }
  }
}

Or from a shell:

claude mcp add ctxtrim --env CTXTRIM_API_KEY=your-key -- node /absolute/path/to/ctxtrim/dist/cli.js serve

Cursor

Put the same mcpServers.ctxtrim block in .cursor/mcp.json in your project, or add it via Cursor Settings → MCP.

Cline

Add the same entry to Cline's MCP settings file:

Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json

(VS Code Insiders and other forks use their own User/globalStorage directory.) Cline picks up the file on save.

The tools your agent gets

Tool	Use it when
`shrink`	A tool result is too large to keep. `mode` is `auto` (default), `gloss`, or `offline`.
`note_add`	You decided something, found a cause, or have a next step.
`note_list`	You only want the current notes.
`note_clear`	The session is finished.
`recall`	You need the stats, the rolled-up digest, and the notes.

After restarting the MCP client, the practical habit is: ask the agent to call shrink on bulky tool output, and recall at the start of a long task. You can bake that into your CLAUDE.md, Cursor rules, or Cline custom instructions.

How a shrink works

Detect. auto classifies the input as a log, a test run, a file dump (source or JSON), or generic text. Override with --kind.
Press. Duplicate lines collapse. Logs keep errors, warnings, and the head and tail. Test output keeps failures, nearby frames, and the summary. Source code keeps an outline of imports and declarations. JSON becomes a short description of its shape. Anything still huge is cut to a character cap.
Gloss. If the press is still large and CTXTRIM_API_KEY is set, ctxtrim sends the press — not the original blob — to POST {CTXTRIM_BASE_URL}/chat/completions and asks for a plain-text brief under CTXTRIM_TARGET_CHARS. A gloss that comes back empty or longer than the press is thrown away. Results are cached under CTXTRIM_HOME.

A few behaviors worth knowing:

--offline never calls a model.
--gloss requires a key and exits with status 2 if it's missing.
Provider errors fall back to the press, unless you explicitly asked for --gloss.
Binary input isn't expanded; you get the original size and a one-line stub.

The idea behind the split is simple: the mechanical press is free and deterministic, and the cheap model only ever sees already-trimmed text, so the summary step stays much cheaper than having your main coding model read the raw output.

The session ledger

Notes are stored per session as JSON under $CTXTRIM_HOME/sessions/ (default ~/.ctxtrim), one compact line per note, with optional tags like decision, blocker, or a filename stem. When active notes exceed CTXTRIM_NOTE_BUDGET, the oldest lines roll up into a digest so the session stays small enough to paste back into a prompt.

recall prints shrink totals (bytes in, bytes out, how much was kept), the digest, and current notes. Note that the shrunk brief itself isn't copied into the ledger — if you want the agent to remember a conclusion, write a note.

Tuning

Everything is an environment variable. The main knobs:

Variable	Default	Role
`CTXTRIM_PASSTHROUGH_CHARS`	`2000`	Return text as-is at or below this size
`CTXTRIM_GLOSS_THRESHOLD`	`3500`	Gloss when the press is still at least this long
`CTXTRIM_TARGET_CHARS`	`1800`	Budget given to the model
`CTXTRIM_PRESS_CHARS`	`12000`	Cap on the press (what the model sees)
`CTXTRIM_NOTE_BUDGET`	`4000`	Active note budget before rollup

Use it as a library

import { loadConfig, shrink, Ledger } from "ctxtrim";

const result = await shrink(logText, { env: process.env, kind: "log" });
const ledger = new Ledger(loadConfig().home);
await ledger.add("feature-auth", "Refresh flake is a clock skew, not a bad signature.");

Credit

The concept is inspired by context-mode by mksglu. ctxtrim is a separate project and is not affiliated with it. If you're exploring this space, check out context-mode too.

About AtmoRouter: a cheap AI API gateway and OpenRouter alternative

Out of the box, ctxtrim sends glosses to AtmoRouter using zai/glm-5.3, which fits the "keep the summary step cheaper than the coding model" idea. Any OpenAI-compatible endpoint works too. AtmoRouter is a cheap AI API gateway that speaks both the OpenAI Chat Completions API and the Anthropic Messages API, so one key reaches 100+ models from Cursor, Cline, Claude Code, or any compatible client. It is pay-per-token with no subscription, accepts QRIS and USDC, and prices sit well below official rates: AtmoRouter advertises an average of 83.7% below official prices, which makes it an affordable LLM API and a practical OpenRouter alternative for agent workloads.

Try it

If your agent keeps drowning in test output and logs, give it a try:

👉 github.com/bayuh85/ctxtrim

Feedback on the press heuristics is especially welcome — if there's a log or test format it handles badly, an issue with a sample is the most useful thing you can send.

grunt-proxy: a local proxy that trims your coding agent's prompts (and shows what it saved)

bayuh85 — Thu, 15 Oct 2026 17:25:31 +0000

Repo: 👉 github.com/bayuh85/grunt-proxy (MIT, Node.js 20+, TypeScript)

The problem

If you use Claude Code, Cursor, or Cline every day, you are sending a lot of text you didn't write: system prompts, tool descriptions, tool results, and your own "could you please…" phrasing. Every token of that is billed. And the replies often come back with a greeting, a recap, and a closing paragraph you'll never read.

None of that is a big deal per request. Across a day of agent loops, it adds up, and most of us have no idea by how much.

I wanted something that sits between the agent and the API, trims the obvious padding, asks the model to get to the point, and tells me what it actually saved — without breaking code or tool calls.

What grunt-proxy does

grunt-proxy is a small local HTTP proxy for coding agents. For each request it:

Shortens the prompt you were about to send (filler phrases, articles, common short forms — configurable).
Asks the model for a terse reply via a short, stable instruction.
Prints how many tokens and how many dollars that saved.

What it deliberately does not do:

Replies stay in normal English. The proxy doesn't role-play and doesn't rewrite the model's response.
Code, JSON, and tool calls stay intact.

It speaks both the OpenAI Chat Completions API and the Anthropic Messages API (including the Anthropic SSE stream), so the same proxy works for Cursor, Cline, and Claude Code.

Quickstart

Requires Node.js 20 or newer.

git clone https://github.com/bayuh85/grunt-proxy.git
cd grunt-proxy
cp .env.example .env

Put your upstream key in GRUNT_API_KEY in .env. The default upstream is AtmoRouter (keys look like ar-...), but you can point it anywhere — more on that below.

npm install
npm run dev

grunt-proxy now listens on http://127.0.0.1:8642. Try a request through it:

curl http://127.0.0.1:8642/v1/chat/completions \
  -H "content-type: application/json" \
  -H "authorization: Bearer $GRUNT_API_KEY" \
  -d '{
    "model": "atmo/deepseek-v4.1-flash",
    "messages": [
      {"role": "user", "content": "Could you please explain the configuration options in the documentation? Thank you!"}
    ]
  }'

(Model ids change — check your provider's current catalog before relying on an example id.)

Each request prints one line on stderr:

grunt  atmo/deepseek-v4.1-flash  in 1,204→640 (−46.8%)  out 180  saved $0.001692

For the running total, hit GET /savings.txt or press Ctrl+C when the server is in the foreground:

grunt-proxy savings
requests              12
failed                0
input tokens          48,200 → 21,040  (−56.3%)
input tokens saved    27,160
output tokens         6,410
est. input $ saved    $0.081480
projected output $    $0.000000
est. $ saved          $0.081480
upstream billed       –

To be clear, the README labels those numbers as an illustration of the layout, not a benchmark. Your savings depend on your prompts, your level setting, and your prices.

For a compiled build: npm run build && npm start.

Setting it up with your agent

Claude Code

Claude Code (and the Anthropic SDK) appends /v1/messages itself, so use the proxy origin without /v1:

export ANTHROPIC_BASE_URL="http://127.0.0.1:8642"
export ANTHROPIC_API_KEY="ar-your-key"
claude

grunt-proxy receives POST /v1/messages, compresses it, and forwards it upstream, streaming included. It sets anthropic-version: 2023-06-01 if the client didn't send one.

Cursor

Start grunt-proxy (npm run dev).
Open Cursor Settings → Models.
Set the OpenAI API key to your upstream key. If GRUNT_API_KEY is already set in .env, any non-empty placeholder works — the proxy replaces the client key.
Override the OpenAI base URL with http://127.0.0.1:8642/v1.
Add a custom model whose id matches a model on your upstream, e.g. atmo/deepseek-v4.1-flash.

Cline

Start grunt-proxy.
Set the API provider to OpenAI Compatible.
Base URL: http://127.0.0.1:8642/v1
API key: your upstream key (or a placeholder when GRUNT_API_KEY is set).
Model ID: a catalog id from your provider.

Quick reference:

Client	Base URL the client uses
Cursor, Cline, OpenAI SDKs	`http://127.0.0.1:8642/v1`
Claude Code, Anthropic SDK	`http://127.0.0.1:8642`

How it works

What gets compressed (and what doesn't)

grunt-proxy only edits text the model will read: system and user text, assistant text, tool descriptions, and tool-result text. It leaves these alone:

fenced code, inline code, and indented code lines
URLs, file paths, and filenames
JSON values, including tool-call arguments and tool parameter schemas
camelCase and PascalCase identifiers
image blocks and Anthropic tool_use / thinking blocks

Levels

Level	What changes
0	Nothing.
1	Courtesy and padded phrases ("could you please", "in order to", "thank you").
2	Level 1, plus `a`/`an`/`the` and a few other fillers, plus short forms like `config`, `fn`, `param`, `impl`.
3	Level 2, plus `of`/`that`, some contractions, and shorter forms like `cfg`, `btwn`, `w/o`.

Level 2 is the default. If an agent starts misreading instructions, drop to level 1. Level 3 is lossier; only use it once you've checked the output.

You can override per request with headers: x-grunt: off forwards the body unchanged, and x-grunt-level: 0–3 / x-grunt-terse: auto|always|off override the config for one call.

The terse instruction

With GRUNT_TERSE=auto (the default), the proxy adds a one-paragraph instruction only when compression already pays for it, or when the prompt is roughly 800+ estimated tokens. It tells the model to answer in normal English, skip the greeting and recap, and keep code and tool calls valid.

A nice detail: the instruction is the same bytes for a given level, so a provider's prompt cache can still reuse the prefix.

Honest savings math

This is the part I appreciate most. The README is upfront about what's measured and what's estimated:

The token delta is a local before/after estimate, not a clone of any provider's tokenizer. It's consistent, which is what a savings figure needs. When the upstream returns usage, the actual counts are stored too.
Dollars are tokens saved × price / 1,000,000, using approximate public list prices for known model families, or $1 / $3 per million for unknown ids.
Set GRUNT_PRICE_IN / GRUNT_PRICE_OUT to what you actually pay, otherwise the estimate won't match your invoice (and may overstate savings if your provider is cheaper than list price).
Output terseness is requested, not measured. projected output $ stays $0 unless you explicitly set GRUNT_ASSUME_OUTPUT_CUT, which is a labeled guess.
Failed upstream calls count as failures and add $0.
The response headers x-grunt-original-tokens, x-grunt-compressed-tokens, and x-grunt-saved-tokens expose the estimate per call. Saved tokens can even be negative when the terse instruction costs more than compression saved — and the proxy says so instead of hiding it.

If you set GRUNT_LOG_FILE, you get a JSONL savings ledger (prompts are not written), and grunt-proxy --report .grunt-savings.jsonl reprints a report from it without starting the server.

Safe defaults

Binds to 127.0.0.1 by default, so the proxy doesn't become a public credit sink.
No proxy-side request timeout by default, so long Claude Code or Cursor streams aren't cut off. Disconnecting the client aborts the upstream request.
Oversized bodies (default limit 32 MiB) are rejected with HTTP 413.

Credit where it's due

grunt-proxy is inspired by caveman by Julius Brussee — the idea that you can strip a lot of words from what goes to and from a model without losing meaning. grunt-proxy takes that idea and packages it as a transparent proxy with a savings report, while keeping replies in normal English.

About AtmoRouter: a cheap AI API gateway and OpenRouter alternative

Full disclosure: grunt-proxy's default upstream is AtmoRouter, but any OpenAI- or Anthropic-compatible upstream works. AtmoRouter is a cheap AI API gateway that speaks both the OpenAI Chat Completions API and the Anthropic Messages API, so one key reaches 100+ models from Cursor, Cline, Claude Code, or any compatible client. It is pay-per-token with no subscription, accepts QRIS and USDC, and prices sit well below official rates: AtmoRouter advertises an average of 83.7% below official prices, which makes it an affordable LLM API and a practical OpenRouter alternative for agent workloads.

Try it

If you run coding agents all day and want to see where your tokens go, give it a spin:

👉 github.com/bayuh85/grunt-proxy

Issues and PRs welcome — especially reports of prompts where a compression level changed the model's behavior, since that's exactly what the level knob is for.

AtmoRouter: A Cheaper OpenRouter Alternative (OpenAI-Compatible, Pay-Per-Token)

bayuh85 — Thu, 15 Oct 2026 17:16:35 +0000

OpenRouter made a great idea mainstream: one API, many models. Subscription coding tools like Command Code bundle model credits into monthly plans. Both are solid options. But if your main goal is paying less per token for frontier models without signing up for a plan, there's another option worth benchmarking.

AtmoRouter is an OpenAI-compatible API gateway. You get one ar- key and one base URL, pay per million tokens, and requests are routed to healthy capacity. Moving existing OpenRouter code over takes two lines.

Why look for an OpenRouter alternative?

OpenRouter is transparent about how it charges. Per its FAQ, it passes provider pricing through without markup and makes money from a 5.5% fee (minimum $0.80) on credit purchases, or a 5% fee for crypto payments. That's fair, but it also means you pay roughly the official list price for every model.

Command Code takes a different approach. It sells monthly plans (for example Go at $1/mo, GOAT at $10/mo, Pro at $20/mo, Max 10× at $100/mo, all plus a processing fee) that include a pool of credits. Those credits have rolling 5-hour and weekly usage caps, and per-model allowances on the lower tiers. Pay-as-you-go API access through its Provider plan costs $15/mo.

AtmoRouter takes a third approach: no subscription, no seats, no minimum, and per-token rates listed below official pricing for many models.

Price comparison: AtmoRouter vs OpenRouter (checked October 16, 2026)

All prices are in USD per 1M tokens. They were pulled from each service's public /models API on Oct 16, 2026. Prices change, so check the live lists before you decide.

Model	OpenRouter (input / output)	AtmoRouter model ID	AtmoRouter (input / output)
Claude Sonnet 5.5	$2.00 / $10.00	`cc/claude-sonnet-5-5`	$0.50 / $2.50
Claude Sonnet 4.6	$3.00 / $15.00	`cc/claude-sonnet-4-6`	$0.75 / $3.75
Claude Opus 4.6	$5.00 / $25.00	`cc/claude-opus-4-6`	$1.25 / $6.25
GPT-6 Astra	$10.00 / $50.00	`cx/gpt-6-astra`	$0.10 / $0.50
GPT-6 Sol	$2.00 / $10.00	`cx/gpt-6-sol`	$0.045 / $0.225

Notes:

OpenRouter's numbers are its pass-through list prices. Its 5.5% credit-purchase fee comes on top.
AtmoRouter often lists the same model under several upstream families (for example ag/, cc/, and cx/ prefixes), each with its own price, context window, and capacity. The table shows one option per model. Check /v1/models for every variant.
Command Code isn't in the table because it's mainly priced as subscription bundles, not one public per-token rate per model.

What you get with AtmoRouter

One key, all models. It's a drop-in replacement for OpenAI: change the base URL and keep your SDK. Anthropic-compatible clients work too.
Routing to healthy capacity. Exhausted or degraded sources are skipped automatically.
Exact per-token metering. Input and output are priced separately, based on the upstream usage report.
Real streaming. Full SSE passthrough in OpenAI's format, with usage on the final frame. Stop the stream, stop paying.
Keys with guardrails. Create unlimited keys with per-key rate limits and model allowlists.
Auditable usage. Every request is logged with tokens, latency, and cost, and you can export it.
Failed upstream requests are never billed. Every response also includes an X-Atmorouter-Cost header showing the exact amount deducted.

Migrating from OpenRouter in two lines

If you use the OpenAI SDK with OpenRouter, change the base URL and the key:

from openai import OpenAI

client = OpenAI(
    # base_url="https://openrouter.ai/api/v1",   # before
    base_url="https://atmorouter.dev/v1",          # after
    api_key="ar-xxxxxxxxxxxx",                     # your AtmoRouter key
)

res = client.chat.completions.create(
    model="cc/claude-sonnet-5-5",   # use an AtmoRouter model ID
    messages=[{"role": "user", "content": "Explain PKCE."}],
)
print(res.choices[0].message.content)

Node.js works the same way:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://atmorouter.dev/v1", // was https://openrouter.ai/api/v1
  apiKey: process.env.ATMOROUTER_API_KEY,
});

For CLIs and coding agents, environment variables are enough:

export OPENAI_BASE_URL="https://atmorouter.dev/v1"
export OPENAI_API_KEY="ar-xxxxxxxxxxxx"

# List every model (with pricing) you can call:
curl $OPENAI_BASE_URL/models -H "Authorization: Bearer $OPENAI_API_KEY"

Model IDs differ between the two services (OpenRouter uses anthropic/claude-sonnet-5.5, AtmoRouter uses cc/claude-sonnet-5-5), so update your model strings when you switch.

How AtmoRouter billing works

Deposit USDC on Solana or pay with QRIS. No card on file, no recurring charge.
Input and output tokens are counted separately. Cached input bills at 10% of the input rate.
The cost formula is public:

cost = ((in − cached) × input_price + cached × input_price × 0.10 + out × output_price) / 1M

Your balance is deducted when a request settles. An empty balance blocks new calls and never overdraws.

OpenRouter vs Command Code vs AtmoRouter at a glance

	OpenRouter	Command Code	AtmoRouter
Pricing model	Pass-through provider pricing + 5.5% credit fee	Monthly plans with included credits; $15/mo Provider API plan	Pay-per-token, no subscription
Usage caps	Provider rate limits	5-hour and weekly caps on plan credits	Per-key rate limits you set
OpenAI-compatible	Yes	Yes (Provider plan)	Yes
Payment	Cards, AliPay, USDC	Subscription + top-ups	USDC on Solana, QRIS

Is AtmoRouter right for you?

If you want the widest catalog and provider-level routing controls, OpenRouter is excellent. If you want a coding agent with bundled credits, Command Code fits. If you want frontier models at per-token rates below list price, no monthly plan, and a migration measured in lines of code, give AtmoRouter a try:

Create an account (email only).
Top up with USDC on Solana or QRIS.
Generate an ar- key.
Point your existing client at https://atmorouter.dev/v1.

👉 Try AtmoRouter at atmorouter.dev

Questions or model requests? Join the AtmoRouter Discord, linked from the site.

Pricing sources, checked Oct 16, 2026: openrouter.ai/docs/faq, openrouter.ai/api/v1/models, commandcode.ai/pricing, commandcode.ai/docs/resources/usage-limits, atmorouter.dev/v1/models.