Execution and limits

What Sigma does with your code

Sigma reviews a pull request from an immutable copy of its code, inside a disposable container, and sends model requests to one or two model providers. This page says what is copied, where it runs, what leaves the machine, what is kept, and what Sigma refuses to publish.

What is fetched

Sigma fetches the pull request's exact head and base commits by SHA, as Git objects, with a repository-scoped installation token that stays on the controller. There is no checkout, no hook, no inherited Git credential and no redirect. A later push does not change a snapshot already taken; it starts a new run (see What a push does).

A snapshot is bounded: 128 MB and 20,000 entries. Every changed file must fit, or the snapshot fails and the review does not start. When the rest of the tree does not fit, the largest unchanged files stay out, and the run carries a scope note explaining the source-tree size limit and naming the largest files that stayed out. Historical runs keep the wording they were published with.

For coding agents. Read the run's scope notes before treating a review as complete coverage. A bounded snapshot, unprepared dependencies and unread files are described there, on the check summary and in the review body.

What Sigma cannot review

Some repository shapes stop a review before any model runs. The check says so; there is no partial review in these cases:

  • Git submodules and LFS pointers; unsafe or cyclic symbolic links; paths that are not UTF-8.
  • Trees above 50,000 entries, or changed files that do not fit the snapshot budget.

Dependency preparation is a separate limit. Python source distributions, editable installs and VCS requirements, and npm workspaces, non-registry sources and conflicting archive names are unsupported. If required checks or an explicit dependency seed require preparation, its failure stops the review. Otherwise Sigma can continue a source review with a scope note that dependencies were not prepared; it does not claim those checks ran.

Private registries, native build tools and tests that need the network are not yet available.

Where it runs

Every attempt runs in a disposable Docker container: non-root user, read-only system filesystem, no Linux capabilities, no new privileges, no Docker socket, bounded command output. The container is removed after the attempt.

Network access depends on the executor (see Executors):

  • gateway: no network at all (network=none). Model calls go through Sigma's credential gateway; the worker never holds a provider key.
  • owner-login (Claude subscription producer): a Docker network with internal: true whose only exit is a proxy that allows CONNECT to api.anthropic.com, claude.ai, claude.com and platform.claude.com on port 443 and refuses every other host, port and method.
  • logins (Claude producer and Codex verifier on subscriptions): the Claude stage as above; the Codex stage on a second internal network whose proxy allows only chatgpt.com and auth.openai.com on port 443. Codex's own telemetry host is refused.

For the legacy native execution profiles, two differences between the model command-line tools matter for isolation:

  • Claude Code's shell commands do not run in the container that holds the login. Every command is forwarded to a sidecar container with the same image and limits, the shared /work tree, no login mount and no network.
  • Codex has no sidecar on any executor. Its own Linux sandbox needs bubblewrap, which an unprivileged container cannot run, so Sigma starts Codex with --sandbox danger-full-access. A Codex command therefore runs in the same container as the credential its stage uses: a scoped gateway token on gateway, the ChatGPT login on logins. The outer container is the only boundary for Codex commands.

In those legacy profiles, dependency preparation and required checks run inside the stage container; on the login paths that is the login-bearing container. Closing that gap for the configured paths remains separate acceptance work.

For operators. The subscription paths do not inherit the gateway's offline guarantee. Accept each path on your installation separately. A configured login proves neither readiness nor a grant for hosted or commercial use; see Provider constraints.

For operators. The source also includes a separate, default-off Claude MCP profile that moves repository preparation, checks and tools into a credential-free executor. It does not change the legacy profiles or prove that an installation uses the new boundary. Read the run's recorded profile.

What leaves the host

Model requests can carry source and review context to a provider. Sigma also fetches repository data and publishes reviews and checks through GitHub. The model execution path depends on the reviewer and the executor:

Wide tables: scroll horizontally to see more columns.

Executor Producer Verifier
gateway Sigma's API keys, through the credential gateway Sigma's API keys, through the gateway
owner-login the owner's Claude subscription login, directly to Anthropic Sigma's API keys, through the gateway
logins the owner's Claude subscription login, directly to Anthropic the owner's ChatGPT subscription login, directly to OpenAI

In the "crossed" construction, Bravo's producer is Codex and its verifier is Claude; Charlie's producer is Claude and its verifier is Codex, so no producer is checked by a model from its own provider. Subscription variants exist only for Charlie.

The person reading a run page is not thereby the owner or payer of the login the run used. See What each path costs you.

Access and removing Sigma

Create a Mnemoverse Account or sign in, then use the GitHub account linked to that Account. No invitation is needed. Your current plan and limits apply; registration preserves existing plan rights and uses the configured Free plan when no plan exists. Connect only repositories you administer.

Memory is an optional Beta feature and starts off for new accounts. Ordinary reviews do not require connecting Memory. Existing accounts keep their saved preference; enabling Memory requires a separate explicit connection and choice.

Signing in, installing the Sigma Mnemoverse App and connecting repositories are separate steps, and each can be undone on its own:

  • Turn a reviewer off: on /connect, set that reviewer to Off and save. This stops new requests for that reviewer; the repository stays connected.
  • Disconnect a repository: on /connect, uncheck the repository and save. Sigma cancels its queued and running reviews and stops admitting new ones. Work already in progress may end without a complete result.
  • Remove Sigma from an account: uninstall the App in that account's GitHub settings. Sigma stops receiving its events and loses the installation token. Reviews and checks already published stay on GitHub.
  • Review a project where you are not an admin: install the App on your own fork and open the pull request inside the fork, from a branch to the fork's main branch. Sigma reviews pull requests only in repositories where its App is installed. A pull request from your fork to the original project belongs to the original repository: GitHub delivers its events and comments there, so Sigma does not see it unless that project installs the App.
  • Close Sigma access: contact support to revoke your Sigma membership. Signing in again does not restore revoked access. Revocation is not remote erasure: the run records described below remain until they are deleted (see What is kept).

What is kept

Sigma keeps a durable run record (stages, findings, costs, scope notes, reading declarations) and the snapshot and dependency artifacts the run used, as host data outside the container. Automatic deletion of run records, snapshots and caches after 30 days is being introduced and is not yet running. To request deletion of your Sigma data, write to [email protected] from your Mnemoverse Account email address. The Sigma team confirms the request and the deletion in writing, as described in the Sigma privacy policy.

Deleting run records, snapshots and caches from live storage does not by itself remove copies in retained archives or backups. Those copies require separate handling; they do not currently have an automatic expiry schedule.

The secret guard

Before anything a model wrote becomes durable, and again before a review is published, Sigma scans it for text shaped like a credential: Anthropic keys and Claude Code OAuth tokens (sk-ant-…), GitHub tokens (ghp_, gho_, ghu_, ghs_, ghr_, github_pat_), AWS access key ids (AKIA…), JWTs, Bearer headers, and opaque runs of 40 or more characters with a 20-character alphanumeric core containing both letters and digits. A digit in a separate path component, such as v1/NotificationPreferencesController, does not make the alphabetic component opaque. Text is also checked after Unicode normalization and split-character welding; named credential prefixes are checked with spaces removed.

Ordinary review facts are exempt by exact form: 40-, 64- and 128-character hex digests (Git SHA-1, SHA-256, SHA-512) and lockfile integrity hashes (sha256-…, sha512-…, Go's h1:…). In label=value text only the value is judged.

The outcome depends on the field:

  • A match inside one finding's prose (title, claim, impact, evidence, suggested change, verification) replaces that one field with "[Sigma withheld the producer's text here: it looked like a credential (rule …).]", naming the verifier instead when the field is one the verifier wrote. The rest of the review publishes, with a scope note naming the rule, the finding number and the field. The withheld text is neither stored nor published.
  • A match in a limitation or an unread-section description replaces only that list item with the same marker. Safe findings and other notes survive. A scope note names the affected field; coverage still records the original paths, whole/partial/unread state and number of unread descriptions. Withholding does not repair incomplete or inconsistent coverage.
  • A match anywhere else withholds the whole publication: "publication withheld: finding text resembles a credential". The check names the rule and the field, never the text. Paths and finding identifiers have no blanket exemption, even when the same value appears in the repository.

For maintainers. A withheld publication is a stopped publication, not a verdict on your code or confirmation that a secret exists. A long mixed alphanumeric file name or identifier can still trigger the guard. If the model quoted a real secret from the change, rotate it before requesting a new review. For a suspected false positive, report the rule and field to Sigma's maintainers without posting the possibly sensitive value; repeating the review may hit the same guard again.