Flat monthly subscriptions are wonderful until you need to answer a question about money. What did this repository cost? What do I put on this client's invoice? Did the plan pay for itself? This batch of launches tries to answer those questions from data the tools already leave on your disk, and then to reduce the number once you can see it.
Reading the bill off your own disk
Tallyhook is one dependency-free Node.js file that reads the session logs Claude Code and Codex CLI already write. Run it and you get a per-repo table of sessions, output tokens and list cost over the last thirty days. The useful part is the next step: group repos into teams to see what each service costs, or register clients with a rate on top and run it again to get the figure that goes on an invoice. No account, no signup, nothing uploaded.
What Would It Cost is the same arithmetic moved into the prompt. It is a Claude Code plugin that keeps one line above your prompt, updated after every model request: this session at API prices, the session's model mix, every session on the machine today, your current weekly limit window from Claude Code's own reset time, your billing cycle so far, and how many times over the cycle has paid for your plan. Click invoice and you get the full breakdown by model and token type with a 60-day chart. It reads your existing transcripts on install, so the numbers start with your past month instead of zero.
Quota you were going to lose anyway
RemainderBot starts from a different observation: your weekly quota resets and whatever you did not use is gone. An hourly cron job reads each CLI's own quota numbers and, when the reset is under four hours away with at least ten per cent left, runs the agent against a snapshot of your task lists, issues and notes, reads your GOALS.md to decide what matters, and opens a finished pull request in your own private repo. The output is a reviewable PR rather than raw text, which is what makes the idea survivable.
Sending the bulk work somewhere cheaper
Flash Agents hands bounded coding work — implement this slice, port these tests, review this diff, map this codebase — to cheap workers such as DeepSeek V4.1 Flash or MiniMax M3.1 Flash, chosen per hand-off, while Claude keeps the architecture, the acceptance criteria and the final review. Every job runs in a disposable copy of your repository and comes back as a patch, and the diffstat and file list are computed by git from that copy rather than taken from the worker's own account. A worker that deletes everything deletes a throwaway.
Ototo does the same for reading. It is an MCP server that offloads codebase exploration to a small model on your own infrastructure, returning concise answers backed by verified source citations. A question that would otherwise spend your main model's context is answered in a handful of turns on the cheap one, with the relevant lines and file positions attached.
DaiDocs attacks the token cost of memory itself. It stores memory as plain text on your disk — .dai for documents and session history, .cai for a graph of your code — and a router decides which half a question belongs to. The code graph answers callers, callees and rename impact from a fraction of the tokens that reading the files would cost.
Singularity is a narrower memory: it records the task, files and commands each time your agent commits, and points a later session at that commit plus the check scripts earlier sessions ran. It helps most where the repository does not already hold the answer, such as a script a past session wrote outside the repo.
Decisions that cost nothing per call
Gutsy runs local decision models that return calibrated probabilities instead of prose. You send a state and typed questions — yes or no, choice, score — and get a probability per option, with no text generation, no network calls and no per-call cost. The state is encoded once, so each extra question costs only its own tokens, and there is a reject probability for none of these fits.
MLX Direct Decider reaches similar ground without a separate model: it turns an MLX model you already run on Apple Silicon into a decision engine, reading candidate logits from the unchanged output head without generating a continuation, so there is no fine-tuning and no extra weights to download.
The hardware underneath
Flopper is the one stop on the list that prices inputs rather than tokens. It compares GPUs by memory, bandwidth, FP8 throughput and FP8 per dollar, with lowest and median hourly rental across providers, availability and a 30-day trend — the arithmetic behind whether to rent or buy capacity for everything above.