The best ideas for cutting AI cost go viral one at a time:
One local-first binary behind a single base_url change. A dozen celebrated
optimizations, instrumented, auto-applied, and tuned to pull in the same direction instead of fighting each other.
Built for Claude Code, with prebuilt support for Codex and other OpenAI-compatible tools now in active benchmarking.
Free 60 days·~20MB binary·localhost-only·honest receipts
A monthly invoice never changed anyone's behavior. Prefex coaches the habit inline, in the moment, so the savings actually change how you work, not just what you read in a report.
Live coaching, in the moment:
Numbers from real sessions, read from Anthropic's own billing fields, not computed by us. What you save depends on your workload, which is exactly why the dashboard shows you the receipt per request instead of a headline.
From the maintainer's own machine, March to May 2026. Every figure is read from Anthropic's own billing fields, not computed by us. Your numbers depend entirely on your workload, which is why the dashboard shows you the receipt per request instead of a headline.
| Number on your dashboard | What it means | Whose credit |
|---|---|---|
| Saved by Prefex | What routing, trimming and guardrails added beyond the native caching you already get free. | Prefex |
| vs no optimization at all | Every token repriced at full strong-model rate with no caching discount. The bigger number, shown only for context. | mostly Anthropic's free caching |
Most eye-catching "X% saved" figures elsewhere are really Anthropic's native caching, which you get without us. Prefex only takes credit for what it adds.
Twelve layers and a dozen-plus optimizations in one proxy. Drop it in front of your existing client, change nothing else, and watch a local dashboard account for every cent.
An explainable rules router sends simple turns to a cheaper model and keeps the hard ones on the strong one. You set the threshold.
Prefix detection, a cache warmer, prefix-stabilization, and prewarm-on-switch keep your cached context hot — including pre-paying the re-write before a model switch or a proxy stop, so you never eat the cold-turn spike.
Lossless-first compaction of tool output, logs, and JSON. Cache-boundary-safe and recoverable. Never lossy on code.
Typed facts extracted from your sessions and re-injected by project, so a new session starts with what the last one learned. Strictly project-scoped: one project's memory never leaks into another.
When a session ends, prefex distills a structured note — goal, progress, key files, blockers, next steps — and hands it to your next session in that project. Injected once, cache-safely, so continuity costs nothing per turn.
Token traps, loop guards, think-caps, and lean reasoning catch runaway turns before they bill.
An embedded OPA engine evaluates every tool call against policy — advisory logging or hard enforcement, your call. Scans MCP tool descriptions at session start and flags suspicious ones on a security activity view. Your policies, your machine, no cloud.
Savings attributed per mechanism, in honest incremental terms, then surfaced inline as you work so the numbers actually change how you spend.
An optional on-device encoder, a frozen ModernBERT trunk that runs fully offline, scores prompt complexity for sharper routing than rules alone. Opt-in and default-off; the fast heuristic router runs until you switch it on.
A background sentinel reads your live request stream and flags the expensive stuff the moment it happens: big cold cache writes, prefix flapping, rate limits, and spend spikes, straight to your status line.
Trims model verbosity on mechanical turns — measured ~11% fewer output tokens, the ones that bill at 5× input and never cache. Honest number, honestly measured.
prefex wrap codex (or aider, cursor, zed) routes any tool through the same shared daemon — one dashboard, one savings ledger, per-tool attribution. Codex rides the OpenAI Responses API natively. Pricing for ~3k models resolves automatically from an embedded snapshot; unknown models are flagged, never silently guessed.
A local dashboard at localhost:8019: honest savings per request, every layer, full control. No account, localhost-only, no auth.
// shown with sample data, localhost-only, your data never leaves your machine
Cheaper tokens sit in a blind spot. The frontier labs optimize capability, and more usage is their business, not less of it. Developers chase the next model and the next feature, not last month's bill. So the savings problem sits unowned, in no man's land, and the partial fixes that do exist do not add up.
Every week a new viral repo: a cache trick, a router, a compressor. You bolt it on and move on when the next one ships. Each is brilliant alone, but a pile of bolt-ons is not a scalable model, and they never knew about each other.
A monthly total never changed anyone's habits. You change how you work when you see the saving happen, in the moment, inline, as you type. A number in a report you never open is not a feedback loop.
Cache goes cold. Every restart pays to rebuild the same context, the same files, the same prompt. You are not doing more work. You are paying for the same warmup again, and nothing tells you it is happening.
So the answer was never one more optimizer. It was a foundation: measure everything, apply the wins automatically, and coach the habit while the work is happening. Prefex is the first product built on that base.
Three layers sit under everything PromptForce builds. Saving tokens is the visible result. This is the base that makes it compound, and the reason a proxy turns into a platform.
Every request measured and attributed per mechanism, in honest, incremental terms. You cannot improve, or trust, what you cannot see. Instrumentation came first; the savings followed the data.
The wins apply themselves. No workflow change, no config archaeology, fail-open by default. A saving that takes effort to claim does not get claimed, so we claim it for you.
Savings shown inline, in the moment, so behavior actually changes (you saw it in action up top). The layer that compounds: a number you watch happen sticks.
Prefex runs on this base today. ReadyBase and the tools after it build on the same three layers, which is why this is a company, not a feature.
Internal errors never block a request. On bad input, a missing dependency, or a slow path, we log and forward upstream unchanged. The optimization is never a single point of failure.
One CGO-free Go binary. No runtime fan-out of processes, no sidecar to supervise. Trained weights are the one exception, and they stay behind an opt-in, default-off seam.
Everything runs on localhost. No telemetry, no analytics, no external logging. The dashboard has no auth because nothing can reach it but you.
We credit the sources we distilled from even when not legally required. Copyright protects code, not ideas, so we study the source, extract the intuition, and re-author it inside our own principles.
Every PromptForce tool is local-first, single-binary, and honest about what it does. We launch with Prefex. ReadyBase is next. More are in the distillery.
A local-first proxy for Claude Code and the Anthropic API. Smart model routing,
prompt-cache assist, cross-session memory, request compression, and spend guardrails, all behind one
base_url change. It shows the honest savings it adds beyond the native caching you
already get free, request by request.
A dependency and co-change graph that scores how ready your repo is for AI agents, and guards high-blast-radius edits. It knows which files are cold, hot, and risky, so your agents (and Prefex) work with context, not guesswork.
We study the sharpest ideas in AI tooling and rebuild the ones that clear our bar as native, fail-open tools. The roadmap follows the thesis below.
Try the full toolkit on your own machine, no strings. Add team features when you are ready.
Every optimization layer, the full dashboard, all of Prefex, free for 60 days. No credit card, no call-home. Renew online in a click when the trial ends. Your keys and prompts never leave your machine.
Shared caches, organization-wide routing policy, per-developer attribution, budgets and spend alerts, SSO, and consolidated billing, built on the same single binary. Available on request, tailored to your setup.
Two short reads: running Prefex solo, and rolling it out across a team.
The cost breakdown, the optimization stack, and how to get savings from the first request as an individual developer.
Read the solo guide →Admin setup, onboarding developers, spend and access controls, SSO, shared knowledge, and the numbers at scale.
Read the team guide →Download, review the script, run it. The installer starts Prefex and connects Claude Code for you.
The install commands unlock the moment you join. Free for 60 days, no obligation, no credit card.
prefex preview first to see exactly what would change.curl -fsSL https://promptforce.ai/install.sh -o install.sh && less install.shbash install.shopen http://localhost:8019/dashboard~20 MB standalone binary, zero dependencies. Your prompts and keys never leave your machine.
curl -fsSL https://promptforce.ai/install.sh -o install.sh && less install.shbash install.shxdg-open http://localhost:8019/dashboard~20 MB standalone binary, zero dependencies.
iwr https://promptforce.ai/install.ps1 -OutFile install.ps1Get-Content install.ps1 | more.\install.ps1Start-Process http://localhost:8019/dashboardRequires PowerShell 5.1+ and Windows 10/11. Windows support is lightly tested, issues to contact@daytwoai.com.
Prefex is a local proxy. Anything that lets you set a custom API base URL works out of the box.
| Tool | How to connect | Status |
|---|---|---|
| Claude Code | Set ANTHROPIC_BASE_URL in ~/.claude/settings.json | Auto-configured |
| Cursor | Set ANTHROPIC_BASE_URL env var in your shell | Supported |
| Continue.dev | Set apiBase per model in ~/.continue/config.json | Supported |
| Aider | Run with --api-base http://localhost:8019 | Supported |
| Codex CLI | prefex wrap codex, routes this session only | Supported |
| Python / Node SDK | Pass base_url="http://localhost:8019" to the client | Supported |
Coding agents can read llms.txt and AGENTS.md for install and config context, or call the MCP server directly at /api/mcp — search_catalog, get_install_command, get_product_overview.
Prefex runs entirely on localhost. No telemetry, no analytics, no external logging. If any internal component fails, requests pass through to the upstream API unchanged. Prefex never blocks a request because of its own failure.
Uninstall is one command. It stops Prefex, restores settings.json, and (with --purge) deletes ~/.prefex.
Prefex makes every AI token cheaper. ReadyBase makes every token count. Run either alone. Running both is strictly additive.
A proxy that makes every Claude token cheaper, with receipts. Prefex rows cheaper.
Explore Prefex →Makes your AI coding tool act like it grew up in this codebase. ReadyBase steers smarter.
Explore ReadyBase →macOS, Linux & Windows · ~20 MB binary · zero dependencies · free for 60 days, no obligation.