Axon Shaft docs

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 git output the model asks for while it works, from inside the checkout;
  • for /ask and /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, task or help), 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, /fix and /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.yml or bunfig.toml sets a registry other than npm's;
  • any requirements*.txt package 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

WhatKept for
A run, with its pull request, findings, card or reply, tokens and error7 days from when it started
Each project's daily totals: runs, how they ended, tokens and cost3 months
An audit-log entry3 months
A resolved or dismissed report of a marketplace item3 months
A session8 hours, then deleted at the next sign-in
A package version's advisories and licence, with no repo or run1 day
The job's logOn GitHub, as long as the repo's own setting says
The pull request comment and check runsOn GitHub, with the pull request
Each project's lifetime totals: runs, tokens, cost, and its first and last runUntil you remove the project
Projects, automations, settings, tokens and marketplace itemsUntil 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