PromptWake vs LiteLLM
LiteLLM routes and governs the model calls your systems make. PromptWake records the AI coding your developers do. The gateway sees everything that passes through it — and a Cursor session never does.
you need one API in front of many model providers, with key management, budgets, rate limits and routing.
you need a record of what your developers asked AI tools and what those tools changed in your codebase.
| Capability | LiteLLM | PromptWake |
|---|---|---|
| Position in the stack | In the request path — a proxy in front of providers | Beside the developer — reads tool history on disk |
| What it sees | Every call routed through it | Every AI coding session on the machine |
| Sees Cursor / Claude Code sessions | No — they call the vendor directly | Yes |
| Key management and budgets | Yes | No |
| Provider fallback and routing | Yes | Not applicable |
| Prompt → response → diff | Logs the call, not the code | Yes, linked together |
| Deployment | A service you run and route traffic through | A daemon on the developer's machine |
LiteLLM is a gateway: one OpenAI-compatible API in front of a hundred providers, with key management, budgets, rate limits, routing and fallbacks. It is a good answer to a real problem, and teams running AI in production often should have one. It is not an answer to the question this product exists for, and the reason is worth stating precisely because it is a load-bearing assumption in a lot of evaluations.
A gateway sees exactly what is routed through it
That sentence is the whole comparison. Point your services at LiteLLM and you get complete visibility and control over those calls — who spent what, which model answered, which key was used, what the fallback did. It is genuinely comprehensive for the traffic it carries.
Now consider what a developer's day actually looks like. They open Cursor, which talks to Cursor's backend. They run Claude Code, which talks to Anthropic. They use Copilot, which talks to GitHub. None of that traffic passes through your gateway, and no configuration change will make it: the network path is between a vendor's client and a vendor's API, on a laptop, over the developer's own session.
A gateway governs the calls your systems make. The calls that write your code are made by someone else's client, to someone else's API, and they never come near it.
Why this gap is easy to miss
Because the gateway dashboard is convincing. It shows spend, models, users and volume, and it is all real — so it reads as complete. The absence is invisible: nothing on the screen says 'and here is the AI usage that did not come through here'.
The way to test your own coverage takes a minute. Take the spend your gateway reports for last month, then ask how many developers have a Cursor or Claude Code subscription. If those two numbers describe different populations, you have two AI estates and are measuring one.
What PromptWake does instead
We capture at the other end: not in the network path, but on the machine, from the files these tools already write to disk. Claude Code writes JSONL transcripts, Cursor keeps a SQLite database, Copilot writes per-workspace sessions, Codex writes rollout files. A local daemon reads them and turns them into one timeline of prompt, response and the resulting file diff — no proxy, no keys, no traffic interception, and nothing to route.
That approach has its own limit, and it is the mirror image of the gateway's: we see what happens on machines where the daemon runs, and nothing on machines where it does not. Neither product can cover the other's blind spot, which is why the honest answer for a team running AI in production and building software with AI is that these are two line items, not a choice.
Where they meet
There is one real overlap: cost. LiteLLM reports the spend of routed calls; we report the token usage the coding tools themselves record, per project and per team member. If your question is 'what is AI costing us', you need both numbers — and the second one is usually the one nobody has.
If your question is instead 'why does this function look like this, and who asked for it', the gateway was never going to answer that, no matter how much traffic you route through it.