Security at Bugstack

Your code stays yours. Every bug fix is proven in an isolated, network-cut sandbox, and every change runs through your CI before anything ships.

What we access

Bugstack reads the connected repository to scan it and to write fixes, through the GitHub access you grant when you sign in. It works only on the repositories you connect. To prove a fix, it copies the repository into an isolated sandbox for the length of that fix, then destroys it.

The verification sandbox

Bugstack proves every bug fix before you see it: a test reproduces the bug on your current code, then passes with the fix while the rest of your test suite stays green. That runs your code, so it runs in a sandbox built to keep it contained.

  • On its own infrastructure. Sandboxes run on machines Bugstack operates for this, never on the servers that run Bugstack’s own app.
  • One per fix. Each fix gets its own sandbox. Two sandboxes cannot see each other’s files or processes.
  • Nothing to steal. A sandbox starts from an empty environment. None of Bugstack’s keys, tokens or host settings reach it, and it gets none of your secrets.
  • The network is cut before the tests run. While dependencies install, it can reach only your package registries, through a proxy that allows nothing else. Before the first test runs, the network is cut completely: no outbound connections, no DNS.
  • No way to escalate. The sandbox gets no added privileges: it cannot mount filesystems, change user or chroot, and root inside it is not root on the machine.
  • Hard limits. Each sandbox has caps on time, memory, processes and disk, and every run is covered by Bugstack’s kill switch.
  • Destroyed afterwards. When the fix is done the sandbox is destroyed. What is kept is the result and its logs, with secrets scrubbed.

Auto-merge guardrails

These rules decide whether a change may merge without you. They are enforced in code, outside the model that wrote the change. A change that fails one is not thrown away. It waits for your review.

  • An error fix that adds a new external import never merges automatically
  • An error fix that fails a syntax check never merges automatically
  • Changes under authentication, cryptography or security paths always go to review
  • Every check on the pull request must be green. A pull request with no checks does not merge
  • An Autopilot merge of a bug fix needs sandbox proof: a test that failed before the fix and passes after, with the rest of the suite green. Bugstack runs that proof again at merge
  • You choose what waits for a person at every level. By default that is changes to sign-in and security code, infrastructure changes and rollbacks. On Autopilot, a security upgrade to a package can merge once your CI passes

Control and audit

Three autonomy levels per repository: Suggest, Review and Autopilot. New repositories start on Review: Bugstack opens pull requests and you merge them.

Sensitive actions wait for a human. Security changes need your approval at every level, and so do infrastructure changes and deploy rollbacks in production and staging. Bugstack never rotates a secret itself; it tells you.

Audit log: Every decision lands on a tamper-evident audit log.

Undo: Undoing a change opens a revert pull request.

Untrusted input and prompt injection

A crash report is text an outsider can influence. If someone can make your app throw an error containing words they chose, those words reach an AI model. This is called prompt injection, and any AI tool that reads untrusted text has to be designed for it. This is how Bugstack is built against it.

The ingest key is a secret, kept on your server. Bugstack has no public key for browsers and does not capture browser errors. An outsider cannot post events to your project without your key.

Error text is marked as data. Error messages, stack traces and log excerpts are wrapped in markers before they reach the model, and the model is told to treat them as evidence only. This lowers the risk. It is not a guarantee, and we do not rely on it alone.

The fixer cannot run anything. Writing a crash fix is a single model call that returns proposed edits, retried once if a check rejects them. The model has no shell, cannot install a package, and cannot make a network request. Bugstack’s own code applies the edits and opens the pull request.

The model does not choose your packages. For a dependency update, the package name comes from your manifest and the version from the registry. The model writes only the summary. Lockfiles are regenerated with install scripts switched off.

The limits that matter sit outside the model. Whether a change may merge is decided by rules in code: the guardrails above, the autonomy level you set, and the audit log. The model that wrote the change has no say in it.

What this does not cover. Bugstack does not yet scan incoming error text for injection attempts. That detector is planned. And a pull request from Bugstack runs your CI before you have read it, like a pull request from anyone else with write access. Keep deploy credentials out of pull-request workflows, and stay on the default level, where you do the merging, until you trust what you see.

What we store and for how long

Error data (stack traces, error messages, request context) is retained indefinitely. Duplicate errors within a 24-hour window are collapsed into a single record with an occurrence count. Deleting a project cascades to all associated error and fix data.

Bugstack does not keep a copy of your codebase. The copy in a sandbox exists only while a fix is being proven. What it keeps from your repository: a map of file paths, an inventory of your packages and versions, each finding with its location, and each change it proposes (the title, the explanation, the diff and the files it writes). Source files are fetched through GitHub when a scan or a fix needs them.

File tree metadata (paths and types only, no contents) is stored per project to enable scoped context building.

Request context is redacted before storage. Header values, query parameter values, and request body values are replaced with [REDACTED] — only key names are visible.

Infrastructure: PostgreSQL on Neon (AWS, US region). Application hosted on Render (Oregon). No multi-region replication.

Code & AI model providers

AI providers: Fixes are written by Anthropic's Claude. One other provider is involved. Bugstack keeps a searchable record of the intent behind changes, drawn from pull request descriptions and any documents you upload or connect, and it indexes that text with OpenAI's embedding model.

What we send to the model: error type, message, stack trace (first 15 lines), the primary source file, up to 6 related files it imports and 2 files beside it, the most recent changes to each of those files, type definitions, test files, framework context, and the sections of any spec you have uploaded that bear on the error. Request context values are redacted — only key names are included.

Model training: Your code is not used to train or fine-tune models. Bugstack does not train models, and neither Anthropic nor OpenAI trains on data sent through its API by default. See Anthropic's privacy policy for how long it keeps API data.

Encryption

At rest: Sensitive fields (GitHub access tokens, refresh tokens, project API keys) are encrypted with AES-256-GCM — authenticated encryption with random 12-byte IVs and 16-byte auth tags. Error data is stored with Neon's default storage encryption.

In transit: TLS 1.2+ enforced on all connections. TLS is terminated at Render's reverse proxy with automatic certificate provisioning. Database connections use sslmode=require.

Authentication

Bugstack uses GitHub OAuth for sign-in. The sign-in asks for read and write access to your repositories, which GitHub calls the repo scope. That scope is broad, so this is the limit we hold ourselves to: Bugstack reads and writes only the repositories you connect.

Production infrastructure (Render, Neon, GitHub org) is single-operator — no shared credentials or team access.

Compliance

SOC 2: Not currently pursued. Our infrastructure providers (Neon, Render, Anthropic) maintain their own SOC 2 certifications.

GDPR: Bugstack can process EU user data — both Neon and Render offer EU regions. No formal Data Processing Agreement (DPA) is available at this time. If you have GDPR-specific requirements, contact us.

Data deletion: Deleting a project removes all associated error data, fixes, and metadata. Account deletion is available on request.

Technical details

For a deep dive into exactly what data the SDK transmits, see Data and Privacy. For architecture details on the capture-to-PR pipeline, see How Bugstack Works.

Reporting a vulnerability

Found a security issue? Email security@bugstack.ai. We take every report seriously and will respond within 48 hours.

See it work on your own code.

$100 a month

Includes $100 of usage credit every month. Start with a 14-day trial: $50 of credit and a first security audit on us. A card is required.