Data flow
Exactly what a run sends to Anthropic, to the Axon Shaft API and to GitHub, what the API looks up on osv.dev and the package registries, what never leaves the runner, and how long each thing is kept.
The review runs on your GitHub Actions runner. The code stays there, except for what the model reads, which goes to Anthropic with your Claude token.
To Anthropic
The action runs Claude through the Claude Agent SDK on the runner, with the project's Claude token. Anthropic gets what the model reads:
- the prompt: the pull request's title, author, body, commits and diff (after the skip globs), the comments of people inside the repo, the previous review's findings, the repo guide files, the project's review rules and the checklists' steps;
- the files and
gitoutput the model asks for while it works, from inside the checkout; - for
/askand/fix, the comment that asked.
Your Claude plan's terms, or the Console's for an API key, cover how Anthropic handles it. See Anthropic's privacy policy. The Axon Shaft API isn't part of that exchange and never gets the prompt or the model's answers, beyond the review card and replies listed below.
To the Axon Shaft API
Each call signs in with the run's GitHub OIDC token, never a stored secret.
When a run starts, the action sends:
- the job (
review,reply,taskorhelp), the pull request event, and whether the pull request is from a fork; - the pull request's number, title, branch and author, which the run keeps for the dashboard;
- the branch it goes into, the author's association with the repo, whether a bot opened it, and its label names, for the filters. The run doesn't keep these;
- the action's version and the ref the workflow runs it at.
When a run ends, the action sends:
- for a review: the verdict, the model, the effort, the finding counts, how long it took, the tokens, the cost on an API key, and the review card. The card is what the pull request comment shows: the headline and summary lines, each checklist's result, and every finding with its file, line, title, text and suggested change;
- for
/ask,/fixand/axonshaft: the model, the effort, the tokens, the cost on an API key, and the reply as it was posted; - for a failed run: the failure's code and message.
For a blocking security finding with private advisories on, the action sends the finding's fingerprint, title, text, file, line, the pull request's number and the commit, so the API can open the draft on GitHub. The API keeps no copy: the draft on GitHub is the record.
The push token for /fix and the Code quality findings call send an empty body. The package lookups send public package names and versions, as Package lookups says.
The API never gets the repo's code, the diff, the job's log or the model's tool calls. The dashboard reads the job's log from GitHub, with your own GitHub sign-in, when you open a run's page.
Package lookups
Only the Known vulnerabilities and Licences checklists look packages up. The action reads the lockfiles on the runner and sends the Axon Shaft API the ecosystem, name and version of each public package the pull request adds or changes. Licences sends only the packages it adds. The call carries the run's OIDC token, like every call to the API, and nothing else about the repo.
The API then asks these services, with the User-Agent axon-shaft-api and nothing about the repo or who runs it:
- osv.dev, in one request for all the versions, then one request per advisory found, for its rating and fixed versions;
- GitHub's advisory database, when osv.dev fails or takes over 10 seconds, one request per version, for at most 50 versions;
- npm, PyPI or crates.io, for the licence each new package declares.
The API keeps each version's answer for a day, under its ecosystem, name and version only, so the next repo on that version gets it without a new request. The cache doesn't record which repo asked.
On an Axon Shaft API older than these lookups, Known vulnerabilities asks osv.dev itself, as action 1.9 and earlier did: the same names and versions, with the User-Agent axon-shaft-action, and GitHub's advisory database with the run's GitHub token when osv.dev fails. Licences is skipped there.
Neither checklist ever sends:
- scoped npm packages (
@scope/name), or packages from a private registry, git or a URL; - any npm package when the repo's
.npmrc,.yarnrc,.yarnrc.ymlorbunfig.tomlsets a registry other than npm's; - any
requirements*.txtpackage when the file names an index other than PyPI; - Go modules under the repo's own owner;
- versions the pull request removes or leaves as they were.
The API refuses a name that can't be a public package's, such as a scoped one or a path, and looks nothing up for that call.
To send nothing, turn off Known vulnerabilities and Licences in the automation.
To GitHub
The action posts the comments, reviews, reactions and check runs through GitHub's API, as axonshaft[bot], with a token the API mints for that repo and that run.
What never leaves the runner
- The repo's files, except what the model reads, which goes to Anthropic only.
- The Claude token and the GitHub tokens, which the action masks in the job log and replaces with
***in anything it posts. - The values of the project's environment variables.
What the dashboard keeps about you
- Your GitHub login, name and picture, from your sign-in.
- Your GitHub sign-in token, encrypted, which the dashboard uses to ask GitHub which accounts, repos and runs you can see.
- Your sessions: the system and browser from the User-Agent, the IP address, and Cloudflare's country and city. A session ends after 8 hours at most, and the API deletes it, with its details, at the next sign-in after that.
- Claude tokens, encrypted. No response, error or log line contains one.
- Your projects, automations, settings and the audit log.
The dashboard uses Cloudflare Web Analytics.
How long it's kept
| What | Kept for |
|---|---|
| A run, with its pull request, findings, card or reply, tokens and error | 7 days from when it started |
| Each project's daily totals: runs, how they ended, tokens and cost | 3 months |
| An audit-log entry | 3 months |
| A resolved or dismissed report of a marketplace item | 3 months |
| A session | 8 hours, then deleted at the next sign-in |
| A package version's advisories and licence, with no repo or run | 1 day |
| The job's log | On GitHub, as long as the repo's own setting says |
| The pull request comment and check runs | On GitHub, with the pull request |
| Each project's lifetime totals: runs, tokens, cost, and its first and last run | Until you remove the project |
| Projects, automations, settings, tokens and marketplace items | Until you remove them |
The API deletes what's past its time when it starts, then once a day. The daily totals hold numbers only, so the usage view and the monthly spending cap still work after the runs are gone.
Last updated on
Runs, automations and the audit log
The Runs list, usage and each run's page, how automations and templates work, the audit log, and the notifications the dashboard shows.
What runs in CI
The action is a fixed, versioned engine that never runs code the server sends. The tokens it holds, the model's environment and tools, the sandbox for /fix, and the push token.