Private preview. We run the benchmarks for you.Request access →

Trust & Privacy

What Fullbeam can and can’t do, how your code is handled, and who we share it with.

Architecture and data flowCurrent

  1. Step 1

    Private task set

    Saved tasks, each tied to a pull request your team merged

  2. Step 2

    Managed benchmark runs

    Short-lived Fullbeam sandboxes that use your own model provider keys

  3. Step 3

    Recommendation

    Both setups on the same tasks, with a recommendation for each kind of work

  4. Step 4

    GitHub check

    A check on the exact commit, one summary comment and a rollout plan your own tools carry out

Isolated Fullbeam sandboxes · Short-lived workspaces · Your own model provider keys

Benchmark runs happen in isolated, short-lived sandboxes that Fullbeam manages. They use the repository access you authorize and your own model provider keys. GitHub stays the source of truth for commits and pull requests. Your existing GitOps, MDM, agent vendor or internal platform still handles deployment and rollback.

What Fullbeam can and cannot do

Can do

  • Build a private, versioned record of your agent setup from the configuration files in Git, showing which parts it could read and which it doesn't support.
  • Run the benchmark tasks you approved in fresh, short-lived sandboxes that Fullbeam manages, using your own model provider keys.
  • Receive limited runtime data from a coding agent after a user authorizes the connection, with a record of which sources it covers.
  • Link a clean commit seen during an agent session to a pull request only after GitHub's complete commit list for that pull request confirms it.
  • Read pull request diffs and metadata.
  • Read limited repository context at the exact revision for dependency-impact analysis. After listing the files, it reads up to 40 supported text files, 1 MiB in total.
  • Publish the Fullbeam Qualification check on the exact commit, and keep one summary comment on the pull request up to date. The comment shows totals only.
  • Show you a Story of the pull request, with chapters, risk tags and citations.
  • When an agent pushes a new revision, show you only what materially changed.

Cannot do

  • Deploy, sync, enforce or roll back your coding-agent configuration. Your GitOps, MDM, agent vendor or internal platform does that.
  • Merge, close, reopen or approve pull requests on its own.
  • Keep the temporary benchmark checkout after an attempt finishes.
  • Act as a user. Every write is labeled as the bot, never as you.
  • Approve on your behalf. The final review decision is always yours, in GitHub.
  • Access repositories you didn't select when installing the GitHub App.
  • Claim that an agent wrote an observed commit, or that a change to your setup caused an outcome.
  • Treat missing runtime data as zero use, a passed verification or an unchanged configuration.

Signing in versus repository accessCurrent

Signing in tells us who you are. It does not give you access to any repository. The active GitHub App installation decides which repositories are included, and Fullbeam separately checks that your GitHub account is currently a member of each one. A workspace role can't get around that check. Installation owners choose the repositories. Each reviewer owns only their own checkpoints.

App permissions and rationale

PermissionWhy we need itWhat it cannot do
pull_requests: writePost review comments and check runs labeled as coming from the App ("via Fullbeam on behalf of @you"). Needed for chapter comments and the reviewer checkpoint check.Cannot merge, close or reopen pull requests. Cannot act as a user. Every write is labeled as coming from the Fullbeam bot.
checks: writeCreate the Fullbeam Qualification check on the exact commit, linked to the Decision Report (sign-in required). The check only blocks merges if a GitHub admin makes it a required check.Cannot modify existing checks created by other apps or CI systems.
contents: writeRead pull request diffs and limited repository context. During a benchmark run you authorized, Fullbeam makes a short-lived checkout of the exact commit inside an isolated managed sandbox. If someone in your workspace chooses to publish an attempt for review, Fullbeam creates new branches under fullbeam/reviews/ and opens a draft pull request between them.Cannot push to, force-push or merge your existing branches. It only creates new fullbeam/reviews/ branches, and only when a person asks it to. Cannot access repositories you didn't select during installation. Cannot keep the benchmark checkout after the attempt ends.
issues: readRead the issue linked to a merged pull request so it can become a task description. Only used for repositories where an owner turned on issue capture, or when you add an issue and pull request pair yourself.Read-only. Cannot create, edit, comment on or close issues.
metadata: readGitHub requires it for every App installation. It provides pull request metadata (title, description, number, state) used to build the Story.Read-only. No write access to repository settings.

Webhooks received

  • pull_request
  • pull_request_review
  • pull_request_review_comment
  • issue_comment
  • issues
  • check_suite
  • push
  • Installation creation / update / deletion

Every webhook delivery is signature-verified, size-limited and processed only once per delivery GUID.

Data from your coding agentsCurrent

Runtime data from Claude Code, Codex and OpenCode is connected separately, and only after a user authorizes it. When Fullbeam records what actually ran, it keeps the link to the version of your agent setup it observed, plus a limited set of session details. Missing or partial data is shown as a gap in the record. We never fill it in from code or Git history. GitHub stays the source of truth for commits, pull requests and review outcomes.

Limits on agent runtime dataCurrent

Runtime collection records a limited set of facts: session lifecycle, tools, capabilities, permissions, verification, duration and clean Git state, along with which sources each fact came from. Prompts, responses, source code, command text and raw tool output are not part of the data we require. Missing data stays marked as unavailable or partial. We don't guess it or show it as zero.

Encryption and hosting regionVerification required

Benchmark runs are configured for private, short-lived Daytona sandboxes, with the EU as the target region. Your model provider keys stay encrypted behind the Fullbeam model gateway, and the sandbox only receives a short-lived token for that one attempt. Before production use, we still need recorded proof from the deployed system for region placement, network egress limits, cleanup and key rotation. You can't choose a hosting region today.

What data we storeCurrent

Fullbeam stores versioned agent setups built from Git, records of which setup was assigned (as reported by outside systems), limited facts about what actually ran, exact Git and GitHub identities, pull request revisions, checks, reviews, the Story versions that were cited and each reviewer's own checkpoints. Dependency analysis may list the files at the exact revision and read up to 40 supported text files, 1 MiB in total. It does not clone the full repository.

How repository access is enforcedCurrent

Every setup record, runtime view, Story, source and write action is scoped to an account and a repository. Server-side checks require a current link to your GitHub identity plus membership of the repository. Row-level security protects ordinary database reads, and changes to the GitHub App installation revoke repository access that no longer applies. Admin database clients skip row-level security only inside narrow services that run the same account and repository checks themselves.

Audit logsPlanned

Today an internal outbox records each account's GitHub actions, with their payloads and delivery state, so they can be sent and retried safely. A customer-visible audit log that also records who acted and which installation credential was used is planned. It does not ship today.

Data handling & retention

Each item below is labeled Current when we can show the control in our code, Verification requiredwhen it still has to be proven in the deployed system before release, or Planned when it isn't built yet.

No training on your codeVerification required
Our commitment is that your code and generated Stories are not used to train models, and that the model provider projects we use in production have the required data controls turned on. The provider terms and the deployed project configuration must be verified before external access.
Minimal ingestionCurrent
We read diffs, pull request metadata, linked issues and checks. Dependency-impact analysis may list files and read a limited slice of the repository. A benchmark run checks out the exact commit inside a fresh managed environment. After the results are packaged, that workspace is destroyed. It is not kept as an application artifact.
RetentionVerification required
Our intended policy: raw diff content is deleted after 90 days by default, and stored organization code is deleted within 7 days of uninstalling the App. Generated Stories stay with the pull request. A deployed deletion drill and a retention audit still have to pass before release.
IsolationCurrent
Every repository read and write needs current access to that repository, based on your GitHub identity and the repositories selected in the App. We check this on the server and refresh it when memberships or repositories change.
TokensCurrent
We don't store user tokens that can write. GitHub App installation tokens are short-lived and never kept past their expiry. Secrets are encrypted at rest and can be rotated.
AuditPlanned
Today an internal outbox records every action sent to GitHub, scoped to an account: the topic, the payload and when it was sent. Recording who acted and which installation credential was behind each write, and showing that to you as an audit log, is planned. It does not ship yet.

AI model providers

Fullbeam sends pull request diffs and metadata to AI models to write Story chapters, risk tags and citations. When an owner imports merged pull requests as benchmark tasks, it also uses them to draft each task's spec. We use these providers:

  • OpenAI: GPT-5.6 Luna, through an API project set up with the data controls we require. The final provider terms and deployed-project configuration must be verified before external access. We don't treat our own code as proof of that external setup.

We update this list when providers are added or removed. Agents in benchmark runs reach your own model provider through the Fullbeam model gateway, using your keys, so that traffic runs on your own provider account.

Analytics and AI observability

  • PostHog: optional product analytics, only after you consent. We turn off autocapture, session replay, surveys and feature flags. We don't send prompts, code, repository or account names, email addresses, URL query strings, or raw user or account IDs. Server actions and workers never send product analytics to PostHog, because they can't check browser consent.
  • Langfuse: records the shape and health of AI runs, such as agent role, model, latency, token usage, retries and failures. The text of prompts, diffs and generated output is excluded by default.

Sentry handles error monitoring. Funnel and operational telemetry stay in Fullbeam's own Supabase and ClickHouse systems.

Bot attribution

When Fullbeam posts a comment or check to GitHub for you, it is labeled "via Fullbeam on behalf of @your-handle". The label is honest attribution, not cryptographic proof of who wrote it. You make the final review decision (approve, request changes, merge) yourself in GitHub, with your own credentials. Fullbeam never submits a GitHub review approval under your name.

Security review contactCurrent

Ask for the data-flow diagram, a permissions review, retention details or a security questionnaire through the contact form. In our reply, we'll say which controls we can show in our code, which have proof from the deployed system and which are still planned.

Private-preview terms

Fullbeam is invitation-only in private preview. Invited teams connect the repositories they choose and their own model provider keys, then set up a benchmark with a defined scope. We share any Fullbeam plan limits, what the results cover, retention and support terms before any paid commitment.

Model usage is billed to your own provider account. Creating a workspace does not give Fullbeam permission to deploy or enforce your coding-agent setup.

Help us improve Fullbeam

Allow privacy-safe product analytics. We do not send prompts, code, repository names, email addresses, or session replays.