Probe0 vs Requesty
Requesty is a cloud gateway: your requests go to their infrastructure, and the routing, caching and policy decisions happen there. Probe0 is a proxy that runs on your laptop, sees every call your AI coding agent makes, and never sends the request anywhere except to the provider you were already paying.
A hosted, OpenAI-compatible AI gateway that routes one endpoint out to 300+ models across 20+ providers, with server-side caching, fallback policies and a spend dashboard.
| Feature | Probe0 | Requesty | Edge |
|---|---|---|---|
| Where routing decisions run | On your machine. There is no Probe0 server. | Requesty cloud (hosted only, no self-host option). | Probe0 |
| Setup for Claude Code, Codex, Cursor | One local proxy plus a certificate, installed once. No per-tool config. | Point each client at the Requesty endpoint with a Requesty key. | Probe0 |
| Model and provider catalogue | The providers coding agents actually call. Not a catalogue product. | 300+ models across 20+ providers behind one endpoint. | Competitor |
| Local model routing | Sends work to a model already running in Ollama or LM Studio; weak answers auto-retry on the cloud. | Can route to a self-hosted Ollama endpoint as one backend among many. | Probe0 |
| What a cache hit costs | Exact cache on local disk. A hit never touches the network. | Opt-in server-side auto caching, enabled per request. | Probe0 |
| Cache safety around tool calls | Strict similarity floor, and the semantic cache refuses to match anything carrying tool calls. | Cache behaviour is set per request against the hosted store. | Probe0 |
| Spend limits | Hard cap per run and per day. Warns, then pauses the run. | Real-time alerts on pay-as-you-go; policy engine and budget hierarchies at enterprise. | Probe0 |
| Attributing cost to a caller | Local ledger records model, tokens, real cost, latency and which process made the call. | Cost and latency per key and per model in the dashboard. | Probe0 |
| Dashboards and tracing exports | Local ledger and per-module savings figures. No hosted dashboard, no tracing export. | Hosted dashboard for cost, latency, TTFT and errors, plus exports to Langfuse, LangSmith and others. | Even |
Requesty is genuinely good at the catalogue problem: one endpoint reaching 300+ models across 20+ providers means you stop tracking keys, model IDs and deprecations per vendor. What that design cannot give a solo developer is a view of the machine the work is happening on. Probe0 sits in front of every agent CLI on the laptop, so Claude Code, Codex and Cursor route through one proxy and one certificate installed once, with no per-tool setup and no SDK changes. It knows which process made each call, which is the difference between seeing that yesterday cost $40 and seeing that one runaway Codex subprocess spent $31 of it. Nothing about that requires an account with me, because there is no Probe0 server to hold it.
I built Probe0 for the case I was in: one developer, one laptop, four coding agents, and a bill that kept climbing without an explanation. Each module is switchable on its own and states what it saved, so you can turn off semantic caching for a week and watch the number move rather than trust a claim. The exact cache is a file on your disk and never touches the network, so a hit costs nothing and works with the wifi off. The semantic cache holds a strict similarity floor and refuses outright to serve a hit for anything carrying tool calls, because a wrong hit in the middle of an agent run corrupts the run and you pay twice to find out. Coalescing collapses simultaneous identical calls into one upstream request, which matters more than it sounds when three agent subprocesses fan out on the same file. The spend guard warns and then actually pauses, rather than emailing you after the money is gone.
The money arithmetic differs too. Requesty prices at the provider base rate plus a markup on pay-as-you-go, which is a fair price for what they operate, but it means every token you send crosses their infrastructure and carries a percentage. Probe0 keeps your existing provider accounts and your existing keys; requests go straight from your machine to the provider, and the savings come from calls that never leave the laptop or that a cheaper model handled first. Because the ledger knows your real usage rather than your plan, it can also tell you when you are paying for a subscription tier above what you consume, which for me was the single largest line item. The honest cost of that design: macOS only, private beta, no team deployment, and the provider coverage is what coding agents call rather than a full catalogue.
The verdict
If you are one developer on a Mac spending your own money on AI coding agents, pick Probe0: local routing to a model you already have loaded, caches that never touch the network, per-process cost attribution and a cap that pauses the run instead of alerting you afterwards. Requesty is the better pick in one situation, and it is a real one: you want a single endpoint onto 300+ models across 20+ providers and you do not want to think about vendors again. Short of that, the proxy that lives on your machine is the one that can actually tell you where the money went, and stop it.
Questions
- Is Probe0 a Requesty alternative?
- For a single developer on macOS, yes. Probe0 covers the same jobs of caching, model tiering and LLM cost control, but the proxy runs on your machine against your own provider keys instead of a hosted endpoint. For team governance, CI traffic or a 300-model catalogue, Requesty is the better fit.
- Do my requests leave my machine with Probe0?
- Only to the provider you were already calling. There is no Probe0 server in the path, and both caches live on local disk, so cached and locally routed requests never reach the network at all.
- Can I use local models with either one?
- Both can reach Ollama. The difference is where the decision is made: Requesty picks a backend in its cloud and can list a self-hosted endpoint as one of them, while Probe0 does local LLM routing on the machine and automatically retries a weak local answer against the cloud model.
- Which one stops an AI coding agent from overspending?
- Probe0 enforces a hard cap per run and per day: it warns first, then pauses. Requesty gives real-time spending alerts on pay-as-you-go and adds approval workflows and budget hierarchies at its enterprise tier.