PromptWake vs LiteLLM

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.

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.

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.

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.

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.

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.