Questions, answered as the system actually behaves

Vigil is a proxy that sits between your application and your AI provider. You point your SDK at one URL, and every call your agents make becomes visible: cost, tokens, latency, errors, per call and per agent, across 17 providers. On providers that support it, Vigil also injects prompt cache markers to cut the token spend on traffic it works on.

Monitoring is free on every plan. What you pay for is turning optimisation on.

One line and one header. Your SDK's baseURL moves from the provider to Vigil, and you add X-Vigil-Key with your Vigil key. Your provider API key stays exactly where it is and passes through untouched.

baseURL: "https://api.vigil.wtf/{your_id}/anthropic"
headers: { "X-Vigil-Key": "vgl_..." }

Same SDK and same calls. Unless you switch on history trimming for an agent — which can change its answers — nothing else changes.

Yes, in transit. The proxy reads your full request in memory to find the cacheable span and place cache markers, and it scans the response for personal data the model produced so it can warn you — and, where Vigil records how a response ended, reads it to see how. That happens on Cloudflare's edge for the duration of the request.

What Vigil stores is different. No prompt text, no message content, no model responses, no tool arguments or results. Two exceptions, stated plainly: the names of your tools, verbatim, because reordering them silently busts your cache, and a short excerpt of any timestamp detected in the cacheable prefix, capped at 32 characters, because a clock in your system prompt is the most common way a cache stops working. Both exist to diagnose caching problems. Section 4 of the privacy policy lists everything a call record holds, and section 6 spells out those two exceptions.

No, not the key itself. Your Anthropic, OpenAI or other provider key passes through the proxy with the request and is never written to disk. What a call record can keep is a short one-way digest of the credential in the request headers, so that one key's cache is kept apart from another's. It cannot be turned back into your key, but it is a checksum rather than encryption: someone who already had the key could confirm it matches. On Google Vertex AI the record can hold your Google Cloud project id and location instead.

Your Vigil key is stored as a SHA-256 digest. It is shown once at creation and cannot be recovered. If you lose it, revoke it and mint another.

Seventeen route today: Anthropic, AWS Bedrock, Google Vertex, OpenAI, Google Gemini, Mistral, xAI Grok, Fireworks AI, Baseten, Cloudflare Workers AI, Groq, Together AI, DeepSeek, Moonshot, Cerebras, Z.ai and OpenRouter.

Cache injection, which is where the savings come from, only works where the provider supports explicit caching: Anthropic, Google Vertex and Mistral — plus AWS Bedrock, but only when the request carries a Bedrock API key rather than a SigV4 signature. Everywhere else Vigil monitors and prices the calls but cannot create cache hits. On xAI Grok, Fireworks AI, Baseten and Cloudflare Workers AI it can still raise the odds: with optimisation switched on, it adds a routing hint that makes a warm cache likelier. The rest cache automatically and offer no control.

Azure OpenAI, Cohere, Perplexity, Replicate, Hugging Face and Ollama (local) are not yet routable. The connect page marks them as coming soon.

Your request fails the way it would if the provider went down, with a properly formed error your SDK can parse. Vigil never returns HTML, empty bodies or malformed responses on any failure path.

This is a design rule, not a hope. No plan limit, quota check, detection or logging failure is allowed to break a customer's request. Database lookups on the request path are deadlined. If something inside Vigil fails, the worst outcome is that Vigil did nothing and your call went through as if the proxy were not there.

Anthropic and a few other providers let you mark part of a prompt as cacheable. If the next call has the same prefix, the provider reads it from cache at roughly a tenth of the cost instead of processing it again. Most teams either never set these markers or set them in the wrong place.

Vigil reads your request, finds the stable prefix (system prompt and tools), checks it meets the provider's minimum length, and places the markers. It also tracks whether the cache actually hit on the next call. If your prompt has a timestamp in it, or your tools change order between calls, the cache will never hit and Vigil will tell you why.

If your client already sets its own markers, Vigil stands aside and forwards them untouched. Re-marking around your breakpoint would break the reads you already get.

Because Vigil does not know the number, and a plausible guess would be worse than an honest gap.

Every figure Vigil shows is either measured or explicitly labelled as something else. When a model has no verified rate, the cost shows as a dash and the row is marked "rate unverified." When too many calls in a window have no billed cost, the total refuses to render, because summing the rest would not be a fair sample. When there is one day of data, the trend line says "not enough for a trend" instead of drawing one.

Other dashboards show $0.00 in those situations. A silent zero standing in for missing data is the one thing Vigil treats as a critical bug. The full argument, case by case, is why our dashboard shows a dash instead of $0.00.

Monitoring is free on every plan, including Free, with no limit on providers or agents watched. You see every call, every cost, every error, up to your plan's monthly logged-call volume, and a measured figure for what caching would save you.

Paid plans turn optimisation on. Plus is $29 a month for 3 optimised agents and $300 of optimised spend. Pro is $99 for 10 optimised agents and $1,000 of optimised spend. Supreme is $299 for unlimited optimised agents and $3,000 of optimised spend. All prices exclude VAT. Enterprise is custom.

The meter that sets the price is optimised spend, meaning the AI spend Vigil actively works on, which comes to roughly 10% of it. Logging is not a second price on optimisation, but it does have a ceiling: each plan includes a monthly logged-call volume — 100,000 on Free, 500,000 on Plus, 2,000,000 on Pro and unlimited on Supreme — and on Plus and Pro, calls above it are $9 / 100k calls and $7 / 100k calls. See pricing for the full table.

Some. The proxy runs on Cloudflare's edge, so the added hop is short, but reading the request body to place cache markers — and, where history trimming runs, to find what it can trim — takes time, and there is a bounded lookup for your account state. Vigil measures its own overhead and the dashboard shows total latency per call.

For streaming calls, Vigil forwards bytes as they arrive. One thing to know: Cloudflare's edge terminates non-streaming connections after roughly 125 seconds. If your agent makes long calls, send stream: true.

Your account and telemetry are stored in Supabase's Frankfurt region, in the EU. The proxy runs on Cloudflare's global edge, which means the request itself is processed at whichever location is closest to the machine making the call. Stripe handles payments in the US and Ireland.

Vigil is operated by Evolmet B.V., a Dutch company. For your account data, Vigil is the controller. For telemetry about the traffic you route through it, you are the controller and Vigil is a processor acting on your instructions. The Data Processing Addendum covers the Article 28 terms. The privacy policy states, in section 19, which questions are still open and waiting on a lawyer, rather than answering them with a plausible sentence.

You can route through it, and Vigil will log and price the calls. But the AWS SDK signs every request with SigV4, and the signature covers the request body. If Vigil injected a cache marker, the signature would break and Bedrock would reject the call.

So on SigV4-signed traffic, Vigil forwards the request untouched and does not inject. The log records auth_mode_forbids_mutation so you can see why an opted-in agent never caches. To get injection on Bedrock, use a Bedrock API key as a bearer token instead of the SDK's signing. Those keys carry no body signature, and Vigil can then place markers freely. The mechanics of why one credential permits mutation and the other forbids it are in Bedrock API keys are bearer tokens.

Every rate in Vigil carries a provenance label. VERIFIED means a human read it off the provider's published pricing page on a recorded date. CONTRACT_DESIGNATED means the platform's terms point to another party's published rate, as Bedrock does for Anthropic models. INFERRED means it was derived from a documented rule, such as a cached input discount, rather than a published figure for that exact model. unverified means Vigil has no rate and the cost shows as a dash.

The same model on different platforms has different prices and separate caches. Claude on direct Anthropic, on Bedrock and on Vertex are three different rows in Vigil's pricing table, never merged — three different products, three separate caches. Rates that change on a schedule are stored with their validity windows, and the build goes red when a window is about to expire and needs re-verification. The full anatomy of a pricing key is in the same model ID is not the same price everywhere.

Tokens are not the only thing a call is billed for, and where the response says how much else ran, Vigil prices that too: web search per request at Anthropic's published rate, and advisor, fallback and compaction steps at the rates of the models that ran them. Code execution is billed per container-hour across an organisation, so no per-call figure exists, and Vigil leaves it out rather than inventing one. The detail is in the costs nobody meters.

Yes, immediately, from Settings. "Delete all data" clears your call and error history, the scores you sent for calls included, and keeps your account open. "Delete account" removes your account and your calls, the scores you sent for them, errors, API keys, preferences, alert rules, team invitations and usage counters. Two kinds of record outlive it: billing records, which the law requires us to keep, and the sign-in entries in our database provider's service logs, for as long as that provider keeps them. If either deletion stops partway, it tells you exactly what was removed and what was not.

One thing to know: clearing your history does not reset your monthly usage meter. That meter is kept separately and only ever goes up within a billing period, so that deleting your calls cannot become a way to reset your plan limits — how that hole existed and was closed is written up. The privacy policy states this.

Those are observability platforms. You instrument your code with their SDK, send them traces, and they show you what happened. They sit outside the request path, which means they cannot change a request, and it also means they cannot break one.

Vigil sits inside the path. That is what lets it inject cache markers and create savings rather than only report them. It is also why the live-path rule exists: being in the path means a failure could hurt you, so no Vigil failure is ever allowed to.

The other difference is what gets shown. Vigil will show a dash rather than a figure it cannot stand behind. If that is not a property you care about, other tools will show you more numbers. The longer version of the trade-off is in-band and out-of-band.

Not today. Vigil runs as a Cloudflare Worker with a Supabase database, and there is no distributed build.

If self-hosting is a requirement for you, say so — it changes the roadmap, and knowing whether one team or ten want it is the difference between building it and not.

Nothing breaks: no plan limit ever stops a request. The optimised-spend and optimised-agent limits govern optimisation only: if you exceed your optimised-spend limit or your optimised-agent count, Vigil stops optimising the traffic above the limit and keeps forwarding, logging and pricing every call. The monthly logged-call volume is the one limit that affects monitoring: past it, calls are still forwarded and counted, but no longer logged.

The worst outcome of hitting a limit is that Vigil does less, never that your request fails. The caps per plan are on pricing.

Yes, for every provider that supports it. Vigil forwards stream chunks as they arrive rather than buffering, and reads usage from whichever chunk carries it. Three provider quirks are handled: OpenAI needs stream_options to report usage at all, xAI puts usage on the second-to-last chunk rather than the last, and Bedrock uses a binary framed format that breaks if you split on newlines.

If you make long calls, send stream: true — a CDN edge terminates non-streaming connections after roughly 125 seconds.

Yes, if the framework lets you set a base URL and custom headers on the underlying client, which all three do. Vigil sits below the framework, at the HTTP layer, so it sees the same calls your framework makes without knowing or caring which framework made them.

The trade-off is that Vigil sees calls, not chains. It will tell you that an agent made forty calls costing eleven dollars; it will not tell you which node in your graph caused them.

Vigil never calls a model on your behalf. It forwards your request to the provider you addressed, using your key, and the cost you see is the cost the provider charged. The only thing Vigil adds to a request is a cache marker, and a cache marker makes calls cheaper rather than more expensive. History trimming, if you switch it On, sends fewer tokens on the conversations it trims.

Where Vigil cannot verify a rate, it shows a dash rather than a figure, so the numbers on your dashboard are never higher than reality through a guess of ours.