Ravensight

The gap between what your game does and what it reports

Analytics can only answer questions about events you actually send. The source scan reads your code and your live telemetry together, and tells you where the two disagree.

How it runs

Three front doors, one pipeline. Connect GitHub and a push scans itself (below), or send your source as a zip upload up to 100 MB, or as a JSON body of { files: [{ path, text }] } up to 40 MB, which is what makes it easy to post from CI. A cheap model reads the files in batches and writes short notes on what each one does and what it reports. A stronger model then reads those notes alongside a deterministic gather of the last 30 days of your own events, and writes the findings. Neither stage is given tools.

Those notes are kept, and your source is not. A scan builds a standing model of the repository: per file, the path, a hash of its text, and our one-line note about it, plus a repository-level read of the architecture, the modules, and which telemetry the code does and does not send. There is nowhere in it to put your code. The next scan compares hashes against that model and re-reads only what changed, which is both why a rescan is priced at a floor rather than by repo size and why the findings get sharper each time: the model that writes them is looking at the whole repository, not at the diff you happened to send. Because it does read the whole repository, a very large one is quoted at its size tier instead of the floor.

Your analyst can read that model too, and so can your own agents over MCP, through get_code_brief. That is what lets an answer about a funnel that dies at step three come back with the reason: not that players quit, but that nothing in the code reports the step.

Only code is read, and only so much of it: eight source extensions, files up to 100 KB, at most 6,000 files, with dependency and build directories skipped. Binaries are detected and dropped rather than counted. Every run carries a hard token budget, so a repo that turns out larger than it looked stops at the budget and reports what it got rather than spending without limit.

Scanning on every push

Connect GitHub once and a push scans what changed, without anybody uploading anything. Open Code in the dashboard and press Connect GitHub, which installs the Ravensight app on the account or organization that holds your repositories. You choose which repositories it can see, and you can change that on GitHub at any time. Connecting is an owner action, because a connected repository can spend your balance without anybody watching.

Ravensight asks for two read permissions and no write permissions: Contents and Metadata, both read-only. That is enough to read files, the commit tree and a diff between two commits, and it is not enough to push a branch, open a pull request, comment, or change a setting. Nothing in the scanner writes to GitHub.

Then attach a repository to a game, on the same screen. One repository belongs to one game: that is what lets a push know whose telemetry to read it against. A game with a client repo and a server repo keeps a separate model of each, and a change to one is never priced as a change to the other.

Only the default branch scans. A push to a feature branch is acknowledged and ignored, on purpose: the question the scan answers is what your shipped game reports, and a branch is not that yet. If nothing happens after a push, this is the first thing to check.

What a push spends, and how to stop it

A push scan charges the balance by itself, up to $3 a day per repository. Past that ceiling the scan is queued instead and waits for somebody to approve it in the dashboard, where the price is shown before you agree to it. You can raise the ceiling per repository, or turn auto-charge off entirely with Scan every push automatically, in which case every push queues and nothing is ever charged unattended.

The ceiling is deliberately lower than the cheapest whole-repository price, and the reason is worth knowing. Usually a push is a diff, and a diff costs $2. Sometimes there is no diff to read: the first push after connecting, a force push, or a rewritten history all leave us nothing to compare against, so the scan reads the whole repository and is priced accordingly. That is exactly the case that must not be charged while nobody is looking, so it goes past the ceiling and waits for you.

Disconnecting is on the same screen, per repository or for the whole studio. Pushes stop immediately. Your notes are kept, because you paid for them and they are what keeps the next scan at the rescan price rather than a first-scan price, so reconnecting later does not mean buying the same reading twice. Deleting the game is what deletes them.

What you get back

Findings, not patches. Each one names a kind (instrumentation_gap or risk), a severity, the file and lines, a short evidence quote, a hypothesis and a suggestion. Nothing rewrites your code, and nothing is committed anywhere.

What it costs

The first scan of a repository is a fixed price by the size of the source that survives the filter, drawn from your prepaid balance: $5 under 250 KB, $10 under 1 MB, $25 under 4 MB and $50 under 16 MB. Past 16 MB of surviving source a scan is refused rather than priced.

Every scan after that is priced on what actually changed. We compare a hash of each file you send against the hash in our notes, and only the files that differ are read and paid for: $2 while the changed source is under 250 KB, and otherwise the tier that change set belongs to on its own. Nothing is taken on trust here, and there is no flag you can set to claim a discount. Two consequences follow, both in your favor. Resubmitting a repository with nothing changed in it is free and does not run, because there is no work to do. And a change set is measured against our notes rather than against the last submission's size, so a 900 KB edit to a 1 MB repository is priced as 900 KB of work instead of as a second full scan.

Pricing is per repository, not per game. A game with a client repo and a server repo keeps a separate model of each, and a change to one is never priced as a change to the other.

Sizing is free: ask for a quote first and you see the price, what changed, and the token estimate before any money moves. Scanning needs an admin role or above, because it spends the balance. Connecting a code host so that pushes can scan on their own is a step further and is owner only: a scan spends a quoted amount once, while a connected repository is standing permission to spend. Whether that connection is available at all depends on how the deployment you are using is configured, so treat a visible connect button as an offer rather than a promise.

If a run stops early on its token budget you pay for the source it actually read, at that size's tier and never more than you were quoted, and you keep the findings and notes it produced. If a run fails outright you are refunded in full and its notes are unwound, so the next scan is priced honestly as a first scan rather than as a cheap diff against a half-written model.