1. Who we are
SeedQ Launch (“SeedQ”, “we”, “us”) is a GitHub App and hosted dashboard operated by SeedQ. We provide repository scans that report launch-readiness, agentic-readiness, integration and GDPR-readiness findings for the repositories you connect.
For data we handle about you, the data controller is SeedQ, c/o Postflex, Emsdettener Str. 10, 48268 Greven, Germany. You can reach us about privacy at privacy@seedq.dev.
2. Our two roles
We act in two capacities, and which one applies depends on the data:
- Controller — for the account & identity data of the people who sign in to and administer SeedQ (your GitHub profile, sessions, team membership, billing). We decide how that data is used.
- Processor — for the contents of the repositories we analyse on your organisation’s behalf, and for the bug reports, feedback and feature suggestions about your app — whether the people using it send them through the report widget, your connected Sentry project sends them to us, or an admin hands us an issue your own team wrote (section 3), and for the release notes you choose to publish about your app. Your organisation is the controller of that material; we process it only to produce your scans (and, if your admins turn it on, the AI logic review in section 3) and show you those reports. Because we have no relationship with the people who file them, a request about a report goes to you rather than to us — you can dismiss any report, and erasing your installation deletes all of them. Business customers can request a Data Processing Agreement (DPA) at privacy@seedq.dev.
3. What we collect
Account & identity (from GitHub)
When you sign in with GitHub OAuth we store your GitHub user ID, login, display name, email address and avatar URL. We use installation tokens for all repository access; your personal OAuth token is used once at sign-in to confirm identity and is not stored. We also record when you last used the app — a coarse timestamp, updated at most a few times a day — so we know whether your account is active. We also keep which version of our Terms of Service you accepted and when you accepted it, and whether you chose “Don’t email me” for the email we send when a check you started finishes.
Authentication & security
We keep server-side session records containing the session’s expiry, your IP address and browser user-agent, so we can keep you signed in and let you revoke sessions. See our cookie notice for the cookies involved.
Team, access & audit
Roles and memberships per installation, invitations (the invitee’s email address; invite tokens are stored only as a one-way hash), and — if you joined through a beta invite link — when you claimed it and which version of our beta tester agreement you accepted, and when, and append-only audit logs that record the GitHub login of who made governance changes (connectors, members, routines and other settings) and when. If we remove someone from SeedQ, we record their GitHub user id and login, the reason, and which of our staff removed them, so they can’t sign back in.
Feedback you post
If you post or upvote an idea on the shared Feedback board, we store the idea text and your vote linked to your account. Ideas are shown to other users anonymously — the author link is used only for rate limiting and moderation. Deleting your account deletes your ideas and votes with it.
If our staff accept an idea, we may send its text to our AI provider (Anthropic, §6) to sort it into work for our own engineering board — only the idea’s title and body, never who wrote it. That step is not switched on today; the provider is named in §6 so it is disclosed before we ever turn it on.
Support requests
If you raise a support ticket, we store the ticket (its category, subject and the messages in its thread) linked to your account and your workspace. We also save the page you sent it from — the path only, never the query string. Tickets are visible to you, your workspace’s owners and admins, and our support staff — never to other workspaces. Our replies may also be emailed to you as a copy. Deleting your account deletes your tickets and replies; a workspace’s tickets are deleted with the workspace.
Staff access you switch on
An owner or admin can let SeedQ staff view your workspace, read only, for 14 days — for example while we help with a support request. We store who switched it on, when, and when it ends or was ended, and for every staff visit, which staff member it was and when it started and ended. While viewing, staff see what a viewer in your workspace sees and can’t change anything. The visits are listed on your workspace’s Members page. Without that switch, our staff never open your workspace. These records are deleted with the workspace; if you delete your account, the switch you made stays on record without your name.
Builder tokens
Where we have switched the builder connector on for your workspace, you can make a token that lets your builder or coding agent sign in to SeedQ as you, in that workspace only. We store the name you give it, which tool you said it is for, when you made it, when it was last used, when it expires and when you revoked it, and a one-way fingerprint of the token — never the token itself, which we show you once. Only you can see or revoke your tokens. They are deleted with the workspace; if you delete your account, your tokens stop working at once and the record stays without your name. If you choose which of your connected builders SeedQ’s buttons use, we store that choice for you in that workspace; only you see it, and it is deleted with the workspace or your account.
If you connect SeedQ to your builder, the builder can read what you see in SeedQ about the apps in that workspace: their names, when each was last checked and what the check found (problem titles, plain explanations, fix prompts and counts, and the file and line each problem is in), your launch checklist and your own steps before launch (which it can also add to and tick off, as you), what is waiting for your decision, the monthly counts of what SeedQ did for you (changes checked, problems spotted, fixes shipped, decisions answered and agent work merged), what Guardian recorded about your pull requests, issues, builds and bug reports, SeedQ’s AI reviews of your pull requests (the verdict, each point the review raised and the fix it suggests, never a file path or line number), and the bug reports and ideas your users sent (their titles, how many people sent each, when and on which page, and for a bug the number of the GitHub issue we filed for it), and your themes and the open tasks not sorted into one (their titles and the start of their text, read from GitHub and not kept), for which it can suggest a theme, as you, that waits in SeedQ until you accept it. It never receives your files, commit messages or anyone’s email address. On a free plan it sees only the titles of locked areas, as you do. To disconnect it, revoke its token under Settings › Connect › Your builder; it stops working at once.
If your builder marks something it is working on as taken, we store which of your tokens took it, what it took and when, so your other sessions and your teammates can see it is taken. The mark lapses after 4 hours, or as soon as that item moves on, and is deleted with the workspace.
When an idea is made, we give it a short code of two everyday words, so you can start work on it in Claude by typing the code in place of pasting a prompt. We store the code, the app and idea it stands for, and which member made the idea. A code is not a secret: it only opens anything for a signed-in member of your workspace. If you delete your account, your name comes off the code; the code is deleted with the workspace.
Each token stops working 90 days after you make it. It can only read unless you tick Let it make changes when you make it; only then can your builder do the things above that change something in SeedQ, as you: start a check, mark an item as taken, add or tick off your own steps, suggest a theme, save your answers in Review (see Answers and label changes you save in Review), and run an idea’s Plan steps (below). We store each token’s expiry date and whether it may make changes with the rest of its record.
Where an idea’s Plan steps are your coding agent’s, your builder can run them through SeedQ, as you. For each step we make one-time passes for its helpers and keep only a one-way fingerprint of each, never the pass itself; a pass works once, and stops working when the step moves on or after a day. We keep what your agent sends: the claims its research found, each with the source it names; each reviewer’s verdict on each claim, with its one-line reason; and its rating judgement (scores with a line of why, a recommendation and the cheapest next check), marked as your agent’s. Until all four research helpers have sent theirs, each one’s claims wait with its pass. It is visible only inside your workspace, never sent to GitHub, and deleted with your workspace.
When you open a bug report whose GitHub issue we filed, Reports reads that issue’s text from GitHub to show which parts it holds, and checks whether the files a builder named in it exist in your repository. We store neither. Your builder, not SeedQ, edits the issue, with its own access.
If you connect SeedQ in the Claude app or in Lovable, that app asks you to sign in to SeedQ and choose one workspace. We store which workspace you chose, which app asked (for example claude.ai or api.lovable.dev), when you connected, when it was last used and when you disconnected it, and one-way fingerprints of the sign-in codes the app holds — never the codes themselves. The app can then read what a connected builder can (above), as you, in that workspace only. Disconnect it under Settings › Connect › Your builder; it stops working at once.
Beta feedback
If you joined through a beta invite link, you can answer our beta feedback questions in SeedQ. We store your answers linked to your account: what you built and who uses it, how you use SeedQ, what you would pay, and anything you type. We save them each time you move to another step, so you can finish later, and we record when you send them. From your second week, or after your third scan, SeedQ asks for them on your Overview; we record when we first asked and when you chose “In 3 days”, so we ask again at the right time and stop once you have sent them. Your answers are read only by you and the SeedQ team — never by your workspace’s owners or admins, and never by other workspaces — and they are never sent to a coding agent or to GitHub. We email ourselves a notice when you send them, without your answers. Deleting your account deletes your answers, and they are included in the copy of your data you can download.
Your open questions
When you go through what waits on you one card at a time, you can ask a question instead of answering. We store your question, which item of your Inbox it is about (its title as you saw it, and the app), when you asked it and when you marked it answered. Only you see it — never your workspace’s owners or admins, never other workspaces — and it is never sent to GitHub or to a coding agent. We also record that a question was asked or marked answered, by whom and when, without its words. Deleting your account deletes your questions and removes your name from that record; your questions are included in the copy of your data you can download. Removing SeedQ from your account deletes them all.
Decisions about findings
If an admin marks a finding as intended, an accepted risk or a false positive, we store that decision, who made it, the reason they typed, which finding and app it is about, and when it was made. If a decision is removed, we record who removed it and when. The reason is free text written by that person. It is visible only inside your workspace, never to other workspaces, and it is not used to train or measure anything. If you delete your account, the decisions you made stay with the workspace but are no longer linked to you; the reasons you wrote are included in the copy of your data you can download. A workspace’s decisions are deleted with the workspace. If your builder proposes that a finding is a false alarm or intended, we store the proposal, the reason it wrote (up to 500 characters), which finding and app it is about, which member’s token it used and when; nothing changes until an admin confirms or rejects it, and it is kept and deleted exactly like a decision.
Labels on findings
If an admin confirms a finding is correct, or marks it as a false positive or intended, we also store a label: which finding and app it is about, which check raised it, the answer, an optional reason chosen from a short fixed list, who gave it and when. A “correct” answer can carry an optional note the admin types; we clear that note after 90 days. We count labels and their reasons to measure how often each of our checks is right; the notes are never used for that and are visible only inside your workspace. If you delete your account, the labels you gave stay with the workspace but are no longer linked to you, and they are included in the copy of your data you can download. A workspace’s labels are deleted with the workspace.
AI logic review (beta, invitation only)
Our scans never use AI. When your workspace hands a task to a coding agent, that agent’s AI model reads the task text; section 6 describes those hand-offs. Separately, a workspace we have invited to the beta can choose an AI logic review: an optional check, run when an admin of that workspace starts it, that looks for problems in how an app works (for example a paid feature anyone can unlock) which fixed rules cannot see. It never runs unless we have switched it on for your workspace and one of your admins has agreed, and an admin can withdraw that agreement at any time.
When you start an AI logic review, SeedQ gives our AI provider, Anthropic, read access to your repository for the length of that review. Anthropic checks it out into a sandbox it runs on our behalf, and deletes it when the review ends; it is never copied to SeedQ’s own servers. The model reads your source code there, whatever the size of your app. We instruct it never to open environment files, keys, database dumps, data files or logs, and we record every file it opens or searches; if it opens one of those files anyway, we mark the review and drop anything it says about that file. Secrets in the files the model opens are not masked before it reads them; we remove any we can detect from what the review reports. For a second, blind check, our servers read the few files each finding points at through the GitHub API and send the lines around it to Anthropic once more. Anthropic processes this on our behalf and does not use it to train its models. You can switch the review off at any time. On SeedQ Guardian, with AI review on for an app, SeedQ also re-checks the parts that changed after each push to its main branch.
Pull request reviews. Where AI review is on, it can also review a single pull request that someone has labelled seedq-review on GitHub, in the same kind of sandbox, checked out at that pull request’s latest commit. When a pull request is labelled for review, Anthropic also receives that pull request’s title, description and changes, and the model may run your app’s own lint and test commands on it in the sandbox. Where AI review is on, and an admin of your workspace has chosen automatic reviews or SeedQ has switched them on for your workspace at your request, a pull request nobody labelled is reviewed the same way as it is opened, reopened or marked ready for review, up to the number of pull requests set for your workspace, or with no limit where SeedQ has set that at your request, and Anthropic receives the same for it. With them we send a map of which of your files use the changed ones (file paths and names only, never their contents), and, when an earlier review of the same pull request left findings open, those findings in our own words, so the newer review can say which look addressed. With each of those findings we also send the replies people wrote on its conversation on GitHub (the GitHub username of whoever wrote each and up to the first 600 characters of what they said, from the three newest; never our own replies) and whether a member of your workspace marked it not a problem in SeedQ, and on any later review we send the messages of the commits pushed to that pull request since the last commit we reviewed (or of all its commits, if its history was rewritten since), so the review does not raise again a point someone has answered. We read these from GitHub when the review starts and do not keep them. Where the model runs your checks, it tells us which passed and, for one that failed, the name of the failing test and why in a sentence; we never fetch or keep the output. We keep what the review said — its verdict, a summary and up to five findings, each with its file path and line numbers, never your code — with the pull request’s number and title, the commit reviewed, the GitHub username of whoever added the label, and the tokens and cost of the review. For each finding we also keep the GitHub conversation its comment started, whether that conversation was resolved, when, and by whom (a GitHub username, or the member of your workspace who marked it not a problem in SeedQ). That record is deleted with your workspace.
Only secrets are replaced, and only in what the review reports: if the files the model opens contain other personal data, for example names in test data, it is read and sent as written. We do not keep the files.
We store what the review found (a title, an explanation, the file path and line, an estimated severity and a suggested fix), which commit was reviewed, the paths of the files the model opened or searched during the review, or that were sent to it up front (paths only, never the contents), and the tokens and cost of the review. We keep this record for 90 days, like the review itself, and delete it earlier if you delete the review or uninstall the app. So that the next review only rechecks what changed, we keep a record of each element the review checked: its file path, line number and the verdict (for example, whether a route checks sign-in), never the code itself. We keep this record for 90 days, like the review, and delete it earlier when you delete the review, turn AI review off, or delete the workspace or uninstall the app. If an admin answers a finding (for example “not a problem”), we store the answer, the reason they gave, and who gave it. We also keep a record of the admin who agreed to the review and when, and of any withdrawal. The results are shown only inside your workspace, marked as an AI estimate. When AI review is on, its findings appear with your scan results and count among the things to fix before launch; an admin can mark any of them as not a problem. They never change any Guardian check.
The core review. On any plan, including the free plan, an admin or owner of your workspace can choose, for each app, how SeedQ reviews its pull requests: Off, Core review or AI review. Nothing changes for an app until someone chooses, apart from the one case described below, and on the free plan the choice covers your workspace’s one app. With the core review on for an app, SeedQ reviews every pull request on that app, with no label and no limit, and again on each new commit. SeedQ’s own fixed rules read it, and we send nothing to Anthropic or any other model provider. It uses no AI tokens. We read the pull request’s latest commit in memory, the way a scan does, with the list of files the pull request changed and whether your app’s own checks passed, and we keep none of your files. Where an AI review of a pull request was asked for, by the seedq-review label or by automatic reviews, and the AI review cannot run (there are no AI tokens, AI is paused, or your plan does not cover it), that pull request gets the core review instead, and the review says why. This applies to an app set to AI review and to an app nobody has chosen for, and on the free plan to your workspace’s one app; an app set to Off gets no review at all. Where SeedQ staff have switched on both reviews side by side for your workspace, at its request, an app set to AI review also gets the core review on every pull request and each new commit, beside the AI review. We keep what the core review said — a summary and its findings, each with its file path and line numbers, never your code — with the pull request’s number and title and the commit reviewed, and we keep which review was chosen for each app, who chose it and when. For each finding we also keep the GitHub conversation its comment started, whether that conversation was resolved, when, and by whom (a GitHub username, or the admin or owner of your workspace who marked it not a problem in SeedQ). Marking a core review finding not a problem also records that decision for your app’s rule checks, with who decided and when, the way a decision made on the Rule checks page is recorded. That record is deleted with your workspace.
On Guardian, where an admin chose SeedQ to run a stage of a task’s or an intent’s workflow, SeedQ sends Anthropic what that stage needs, for that stage only, and writes the stage’s record from what comes back. For a task’s stage (Triage, Plan first, Verify, Release notes) that is the task’s issue text, or the report’s or idea’s text where no issue exists yet, and Anthropic checks the repository out into a sandbox for the length of that stage, as it does for a review; no stage changes the repository. For an intent’s stage (Shape review, Research, Evaluate, Rate) it is the intent’s text and its evidence, and no repository. For Research, the model may also search the public web and read public pages through Anthropic: the searches, which the model writes about the intent’s subject, are run by Anthropic, and the pages are fetched by Anthropic, never from SeedQ’s own servers. What a page says is kept only as the claims Research writes from it, each naming the page it came from.
Launch waitlist (“Keep me posted”)
If you ask to be told when a plan opens, we record which plan and how to reach you: if you asked while signed in, that is your account; if you gave an email address on our website, that address is all we store — no name, no IP address, no cookie. We use it for one email, sent when that plan becomes available, and nothing else. Basis: your consent, which you can withdraw at any time via the unsubscribe link in that email (which deletes the address) or by emailing us. Addresses given on the website are deleted within 30 days of that email being sent, and within 180 days if the plan hasn’t opened by then.
Billing
If you subscribe to any paid plan, our payment processor (Stripe) handles your card details — your card number never reaches our servers. We store the Stripe customer and subscription identifiers, subscription status, and trial / renewal dates so we know what you’re entitled to.
If you buy AI tokens, Stripe takes the payment and keeps the card. We store a reference to that card: Stripe’s id for it, the card brand and its last four digits. That is what lets Billing show which card a top-up uses, and lets auto top-up charge it if you turn that on. We also keep a ledger of your workspace’s tokens: every purchase, run, refund and addition by SeedQ, with the amount, the Stripe payment and charge ids, the time, and the member or system that made each change. Each top-up’s entry also keeps the link to its Stripe receipt and the brand and last four digits of the card that paid for it, read from Stripe once when you pay, so the token history can show them for that top-up even after you change cards. Both are kept for the life of the workspace and erased with it.
If auto top-up is on, each time it adds tokens we email the address Stripe holds for the card: how many tokens were added, what was charged, your balance now and where to turn auto top-up off. We also email it when an auto top-up charge doesn’t go through. We read that address from Stripe each time we send.
Repository data we analyse
Our scans read your repository through the GitHub API. SeedQ’s own servers never clone it, and we write your application code only where an admin has chosen to have SeedQ build an app’s tasks, or in a revert of a task’s change, where an admin has switched Roll back on (below). During a scan we read your repository in memory and keep none of its files. We read the file tree and the files our checks look at, detect your stack, and store the resulting findings: the file path, the line number, a severity, and our own description of what we found and how to fix it. We do not keep the contents of your files. For a pull request review we also keep, for each commit we review and for 30 days, a map of which of your code files imports which (file paths only) and a short brief of the repository (its script names, its Node version and the path of its rules file). Neither holds the text of your files. Each scan also keeps a readout of what it worked out about your app (its stack and package manager, its CI workflows, its tests and core paths, which agent instruction files it has and how old they are, its lint and TypeScript settings, and the services it is connected to): names, paths, counts and dates only, never the text of a file, kept as long as scan results. They are read to run the checks and discarded when the scan finishes. We do not intend to collect personal data from repositories; if your files contain personal data or secrets, that data is processed while the scan runs, and what remains afterwards is the finding — for example “this file appears to contain a secret, at this line” — not the value itself. The one exception to ‘never a copy’ is the AI logic review described above.
If a scan finds what looks like a key for Stripe, GitHub, OpenAI or Anthropic, anyone in a workspace on a paid plan can press Check if it’s live on that finding. SeedQ then asks the service that issued the key whether it is still active, and doing so sends the key to that service. The check runs only when you press it on that finding, never on its own. We read the key from your repository at that moment and do not store it.
What we write back to your repository
On the SeedQ Guardian plan we also publish results onto the GitHub surfaces you work in. On every paid plan, an admin can also ask us to file a problem as a GitHub issue (below). On any plan, including the free plan, an admin can turn the core review on for an app, which posts a check run on each of that app’s pull requests (below). We write your application code only where an admin has chosen to have SeedQ build an app’s tasks, or in a revert of a task’s change, where an admin has switched Roll back on (below). We change your default branch only when a workspace admin presses Approve & ship or Let these in to merge a pull request. The one exception: an admin can choose to have SeedQ let an agent’s change in on its own when the review finds nothing to stop it and the checks are green. What we publish is:
- Check runs on pull requests — a score for the changes in that pull request. Advisory by default; you can choose to make it a required check, in which case it can prevent a merge until it passes.
- Inline notes on the changed lines — where a finding belongs to a specific line the pull request touched, that check run also marks the line in the “Files changed” view, so you can see it in place. These are part of the check run, not comments on your code, and they disappear with it. We only mark lines for findings the pull request itself introduced.
- A comment on issues — a structural quality score with concrete suggestions, updated in place when the issue is edited rather than added again. Always advisory.
- A check run on pushes to your default branch — a neutral warning when the same files are being rewritten repeatedly. It never blocks anything; the push has already landed.
- A check run on an update you pushed — the same score we’d give a pull request, published on the commit itself, for apps whose changes go straight to a branch rather than through pull requests. It names what that update introduced and how to fix it. It can never block anything — your change has already landed by the time we look, so it is always advisory. You can switch it off, or tell us you work through pull requests instead, in your Guardian settings.
- A workflow file you asked us to propose — an admin can ask us to open a proposed change adding a GitHub Actions workflow: one that runs your checks when a scan finds nothing does, the fix workflow for Claude Code, a test-proof workflow that runs the tests your coding agent wrote against its own changes, or the SeedQ Loop workflow that runs your coding agent on your ready issues on a schedule. A workflow file is only ever written inside
.github/workflows/, only on a new branch, and only as a proposed change you choose to merge. We never commit a file to your main branch, and outside a build or a revert an admin chose (above) we write no other file. Nothing happens unless an admin asks for it, and the feature is off entirely unless your workspace has approved the permission. - An issue you asked us to file — on any paid plan, from a scan report, a finding's own page, Everything found or your work plan, an admin can file a single finding into your repository's issues as a work order: what it is, why it matters, and the paste-ready fix prompt, so your own coding agent can pick the work up — and, on Guardian, can ask us to hand it to that agent, in the way described below. It carries no labels and touches nothing else in your repository. An admin can switch filing off for the workspace under Scan settings, and we never offer it for a repository whose Issues are switched off on GitHub. We never file an issue on our own unless an admin in your workspace has switched on creating issues after each scheduled check. With it off, an issue is filed only when an admin presses the button: one issue for the finding they chose, or, from a scan report or Everything found, one issue for each finding they picked, at most 100 per press, and never a second issue for a finding that already has one. The scheduled setting is available on any paid plan; it is off for every workspace until somebody there turns it on, it is admin-only, it works only while filing is switched on, and we record who changed it and when. With it on, each scheduled scan files at most five findings that are new or came back since the last scan, at the level the admin chose and above — never one already filed or sent, or marked as intended, an accepted risk or a false positive — and, on Guardian with a coding agent connected, hands each to that agent. A scan somebody starts by hand never does. Closing it does not tell us anything; only the next scan can confirm the work is done, by re-reading your code.
- An incident you asked us to file — on any paid plan, where your workspace collects bug reports through SeedQ (the report widget or your error tracker), an admin can file one incident into your repository's issues: our plain-English summary of what was reported, the reporter's account with links, formatting and anything instruction-shaped already stripped out — shown only inside a code block — and what “fixed” would mean. It carries no labels unless an admin picked some, on Pro or Studio, from the labels already in your repository — we never create a label — and touches nothing else in your repository. We never file an issue on our own unless an admin in your workspace has switched automatic filing on. On Guardian that is the automatic filing setting; on Pro and Studio it is choosing “Every new one” for bug reports under Reports → Integrations. Both are off for every workspace until somebody there turns them on, they are admin-only, and we record who changed them and when. With them off, filing is one issue per click, on the incident you chose — and on Pro and Studio an admin can also keep bug reports in SeedQ altogether. With it on, every report we can read anything out of becomes an issue by itself — reports left empty after we strip them never are. The issue is yours once filed; we do not edit or close it, and it says itself that nobody has confirmed the report reproduces.
- An idea or feedback you chose to file — on Pro and Studio, where an admin has set ideas or feedback to go to GitHub under Reports → Integrations, we file each one as a single issue in that app’s repository, on a click or as it arrives, whichever they chose: our rewritten version of what was sent, inside a code block, and the page it came from. It carries only labels an admin picked from those already in your repository, and touches nothing else. Both kinds stay in SeedQ until an admin changes that. The issue is yours once filed; we do not edit or close it. When it is closed or reopened on GitHub, we move the report in SeedQ to match.
- A hand-over to your own coding agent — on the Guardian plan only, on an incident or a work order you have already filed (or the widget install issue described below), an admin can ask us to hand it to the coding agent your workspace uses. For a work order the instructions also tell the agent to check the finding is real first, and to say so on the issue rather than change anything if it isn't. We post one comment on that issue with the instructions (work on a branch named for the issue, open a pull request that closes it, do not touch workflow files, environment files or lockfiles, do not add dependencies) and we assign the issue to that agent. Everything after that is the agent working in your repository, on your provider and your plan, under your own permissions — not ours. We never hand work over on our own unless an admin in your workspace has switched automatic hand-over on, or chosen your agent for a stage of a task’s workflow (described below). That setting is off for every workspace until somebody there turns it on, it is admin-only, it applies only to incidents at the level they choose and above (a work order is handed over without a click only through the scheduled-scan setting described above), and we record who changed it and when. With it on, an attempt that runs out of time is tried again a small number of times; after that we stop and leave it to you. We never write that code. If we review the pull request it opens, our review is posted as a comment, either an AI estimate or what SeedQ’s own rules found, never an approval. The same hand-over can also start from a pull request you asked us to review whose own checks have failed or whose review found something to fix: when someone on your team asks for it, in SeedQ or, for failing checks, with a comment on that pull request, we post one comment on that pull request with the instructions and the name of its branch, and assign nothing. For what the review found, that comment lists each problem it found that still needs fixing, with the file and line it points at and the fix the review suggests, and asks your agent to check each one is real first; a problem someone on your team marked not a problem here, or one a question to you still hangs on, is left out. Your agent then fixes the failing checks, or the real problems, and pushes the fix to that branch itself, in your own GitHub Actions, under your own account and with tokens you provide, never ours. A pull request is handed over at most twice in all. SeedQ never pushes to your branch. No setting starts this without someone asking, with one exception on SeedQ Guardian: Fix on its own, a setting for one app that is off by default and that SeedQ switches on only at your workspace’s request. With it on, when our review of a pull request your coding agent opened finds a problem at the level chosen (serious problems only, unless the setting says otherwise) or a check the review ran fails, SeedQ posts that same one comment on its own. It never does so on a pull request from a fork, one someone on your team has pushed commits to, one the review has a question to you on, or one that has had its two hand-overs, and it posts at most one for each commit. On Pro and Studio there is no hand-over of an issue: what you file stays an issue for you to act on.
- An answer you send to your coding agent — on any paid plan, where your coding agent has asked a question on one of your issues, a member of your workspace can type the answer in SeedQ and press Send to your agent. We then post one comment on that issue: the question it answers and the answer as the member wrote it (a mention of another GitHub user is posted as plain text, so it notifies no one), headed with their GitHub username, so everyone on the issue can see who answered. The issue may be one your own team wrote rather than one we filed. We post nothing else, change nothing else on the issue, and never post an answer on our own: one press is one comment. We keep a record of who sent an answer, to which issue and when, but not the answer itself (it is on GitHub), and that record is deleted with your workspace.
- A record of each stage of a task’s workflow — on Guardian, only where SeedQ staff have switched task workflows on for your workspace and an admin has saved a workflow for the app, each stage of a task that finishes (such as triage, or building it) posts one short comment on the task’s issue saying what that stage found, so the issue reads as the task’s record.The words come from a fixed set, filled in from a person’s answer in SeedQ, from our own health check’s reading of a problem it found, from what your own coding agent reported for a stage it was handed (below), or from what SeedQ’s own AI wrote for a stage an admin chose it to run; a mention of a GitHub user or an issue number is posted as plain text, so it notifies no one and closes nothing. If a stage runs again, the same comment is updated in place, never a second one for the same stage. We never change the issue’s labels, edit it or close it. We keep what each stage recorded, and delete it 90 days after the stage finished, apart from the commit a change went in as and the time it was marked small, which the task keeps. An admin can also have a task start on its own when a pull request is opened or an issue gets a label in the app’s repository. Both are off until an admin switches them on; a label SeedQ itself adds never starts one, and nor does a pull request from a fork or from someone your repository does not trust. Such a task starts part-way, at the stage the admin chose. For a pull request, its records go on the pull request’s own conversation, and the first says the stages before it were recorded from what was already there. Where an admin chose your agent for a stage of the app’s workflow, we hand that stage to your own coding agent in the same way as the hand-over described above (one comment with the instructions, and for Copilot the same assignee): to triage the task, plan it, build it or check it once merged. For triage, a plan or a check it is asked to change no code and to write nothing but one comment on the issue saying what it found. We read the issue’s comments to find that one, and take it only from your agent or someone your repository already trusts. We never post its comment again as it was written: we post the stage’s record described above, with any mention or issue number in it made plain text.
- Answers and label changes you save in Review — on any paid plan, a member of your workspace can go through the issues waiting on a person from an AI assistant connected to SeedQ (such as Claude) and save their answers at the end. We then post one comment per issue, exactly as for an answer sent from SeedQ, and change that issue’s labels the way your app’s Review settings say: by default we take off
needs-human,needs-evidenceorlikely-redundantand addagent-ready. We change labels only on an issue that carried one of the waiting labels in those settings, only after its answer is posted, and only when that member saves; an administrator can change the labels or switch label changes off per app. We record which labels we took off and added with the record of the answer, and we keep each app’s Review settings, with the login of whoever last changed them and what they changed. Both are deleted with your workspace. - A widget install you asked us to send — on the Guardian plan, right after an admin creates a report-widget key, they can ask us to file one issue in that key's repository titled “Install the SeedQ report widget”, carrying the install instructions and the widget key (which is public by design), and hand it to the coding agent your workspace uses, in the way described above. On Pro and Studio we file nothing: we show the same instructions for you to copy into your own builder. It carries no labels and touches nothing else in your repository. We never send one on our own — one issue per click, per key, and no setting turns it on. The issue is yours once filed; we do not edit or close it. Your agent writes the change and opens a pull request for you to merge.
- A feature request you accepted — when a member of your team suggests a feature from inside SeedQ, an admin can accept it by writing up, in their own words, what should be built, and ask us to file that write-up as one issue in the repository and hand it to your coding agent in the way described above. It carries no labels and touches nothing else in your repository. A suggestion becomes an issue only after an admin accepts it, and no setting skips that step. If an admin turns on sending on accept, the accept press is also the send. Your agent is given the admin’s write-up, never what was originally suggested. The issue is yours once filed; we do not edit or close it.
- Release notes set-up you asked us to send — on an app's Release notes page, while release notes are on, an admin can ask us to file one issue in that app's repository titled “Set up release notes” and hand it to the coding agent your workspace uses, in the way described above. It asks the agent to add a pull request template with a Release notes section, and a rule telling coding agents to fill it in. The instructions are the same for every customer. It carries no labels and touches nothing else in your repository. We never send one on our own — one issue per press, once for each app, and no setting turns it on. The issue is yours once filed; we do not edit or close it.
- An “add tests” task you asked us to send — on an app's Live page, when we have seen no automatic tests run, an admin can ask us to file one issue in that app's repository titled “Add automated tests” and hand it to the coding agent your workspace uses, in the way described above. It asks the agent to add tests and a workflow that runs them. The instructions are the same for every customer. It carries no labels and touches nothing else in your repository. We never send one on our own — one issue per press, once for each app, and no setting turns it on. The issue is yours once filed; we do not edit or close it.
- An AI review finding you asked us to send — where the AI logic review is turned on, an admin can ask us to file one issue in that app's repository for a problem the review estimated, titled “AI review:” and the finding, and hand it to the coding agent your workspace uses, in the way described above. It carries what the review stored about that problem — its title, explanation, the file and line, and its suggested fix — marked as an AI estimate, and tells the agent to check whether the problem is real before changing anything. It carries no labels and touches nothing else in your repository. We never send one on our own — one issue per press, once for each finding, and no setting turns it on. The issue is yours once filed; we do not edit or close it.
- A step you added before launch, until 27 October 2026 — a step a member typed on the Before launch page was filed as one issue in that app's repository, titled with what they typed, with no labels and no hand-over to a coding agent. We no longer file them: steps added now stay in SeedQ (see “Your own steps before launch” below). The issues already filed are yours; we do not edit or close them.
- A check run for SeedQ’s checks on a pull request SeedQ started, saying which checks went through. It never blocks a merge.
- An AI review on a pull request you asked us to look at — on a paid plan, where AI review is on for your workspace and an admin has agreed to it, and only on a pull request that someone has labelled
seedq-reviewon GitHub (adding a label needs triage or write access to the repository) or, where an admin of your workspace has chosen automatic reviews or SeedQ has switched them on for your workspace at your request, on pull requests nobody labelled, up to the number set for your workspace, or with no limit where SeedQ has set that at your request, we post a check run named “SeedQ / AI review” and one GitHub pull-request review: a plain-English summary and comments on at most five of the lines that pull request changed, marked as an AI estimate. A mention of a GitHub user in it is posted as plain text, so it notifies no one. While the label stays on, each new commit pushed to the pull request is reviewed again; taking the label off stops it. A pull request reviewed automatically is reviewed again for each new commit while automatic reviews stay on. When someone adds that label and the AI review cannot run, for example because your plan does not cover it (the free plan does not), AI review is not on for your workspace or there are no AI tokens, we still post that check run, on any plan, as a neutral notice saying why, and no review, unless that pull request gets the core review instead, as described in the next item. It is only ever posted as a comment: it never approves the pull request or requests changes, its check never fails, and it never blocks a merge. When the checks on that pull request finish, or when we have looked into a point the review was not sure of, we bring our own review up to date in place, with a line in it saying so: its answer and the lines under it change, never what it found or its line comments, and GitHub marks the review as edited. We keep one review live on a pull request: when a new commit’s review has the same answer and nothing was found either time, we update the review already there instead of posting another; when we post a new one, we cut the review it replaces down to one line naming the newer commit and hide it on GitHub as outdated, where anyone can still open it, and leave its line comments as they are. We do not dismiss or delete a review once it is posted, so it stays on the pull request; GitHub marks its line comments as outdated once those lines change. Its links only open SeedQ: handing what it found to your coding agent is the hand-over described above, and needs an admin’s press in SeedQ, unless Fix on its own is on for that app, in which case the review’s check says it was sent on its own. We do resolve the conversations on our own review comments, with a one-line reply saying why, in two cases only: when a newer review of the same pull request finds the problem gone (“Looks addressed in…”), and when a member of your workspace marks a finding not a problem in SeedQ (“Marked not a problem by… in SeedQ.”). We never resolve a conversation someone else started and never reopen one a person resolved. When someone resolves or reopens one of our conversations on GitHub, SeedQ records that. No pull request is reviewed unless someone adds that label, an admin of your workspace has chosen automatic reviews or turned the core review on for that app, or SeedQ has switched automatic reviews on for your workspace at your request, and no setting adds the label for you. What the review sends to Anthropic and what we keep are described under “AI logic review” above. - A core review on every pull request of an app you turned it on for — on any plan, including the free plan, where an admin or owner of your workspace has chosen Core review for that app (it is off until someone chooses), we post a check run named “SeedQ / Core review” on every pull request of that app, with no label and no limit, and again on each new commit. We also post one GitHub pull-request review on that pull request: a plain-English summary of what SeedQ’s rules found, or that they found nothing new, and, where they found something, comments on at most five of the lines that pull request changed. It gives facts and a count, never an answer on whether to merge. A mention of a GitHub user in it is posted as plain text, so it notifies no one. It is only ever posted as a comment: it never approves the pull request or requests changes, its check is only ever a pass or a neutral notice and never fails, and it never blocks a merge. SeedQ’s own fixed rules read the pull request, and we send nothing to Anthropic or any other model provider. We keep one core review on a pull request, bring it up to date in place, and hide one it replaces on GitHub as outdated, exactly as described for the AI review above. Where an AI review of a pull request was asked for and cannot run, on an app set to AI review or on one nobody has chosen for, that pull request gets the core review instead, saying why. Where SeedQ staff have switched on both reviews side by side for your workspace, at its request, an app set to AI review gets this check run and review too, beside the AI review’s, so the pull request carries one live review of each. When an admin or owner of your workspace marks one of its findings not a problem in SeedQ, we resolve the conversation on our own comment for that finding, with a one-line reply saying who marked it (“Marked not a problem by… in SeedQ.”). That is the only time SeedQ resolves a core review’s conversation, and only one SeedQ started that nobody has resolved already. Choosing Off for that app stops the core review.
- A pull request that takes a change back out — if an admin has switched Roll back on in an app’s Build workflow, and the check SeedQ runs after a task’s change goes live fails even after SeedQ has built it once more, SeedQ opens one pull request that reverts that task’s own pull request, at the commit it merged. It goes in only when someone in your workspace approves it in SeedQ: SeedQ never merges it on its own and never deploys. We record who switched Roll back on, and each pull request we open.
- A pull request holding a change SeedQ built — If an admin chooses to have SeedQ build an app’s tasks, SeedQ’s own agent builds each one in a sandbox run by Anthropic on SeedQ’s account and runs its build and tests there. SeedQ then pushes a new branch and opens a pull request for it. Your code is checked out there for the length of that build and nowhere on SeedQ’s servers. We never merge on our own. If an admin chooses to have SeedQ build an app’s tasks, Anthropic also checks the repository out for the length of each build, and SeedQ’s agent writes the change there; SeedQ then opens it as a pull request, which only a person merges.
- A merge you approved — when your coding agent has opened a pull request, an admin can press Approve & ship on its incident, or Let these in on the changes they ticked in the Inbox or on Waiting on you, and we merge each one into your default branch on GitHub. This is the one thing we do that changes what your app runs. Nothing merges unless somebody presses one of those buttons or an admin has switched this setting on for that app: Let changes in on their own — each press authorises only the pull requests it names, each at the exact commit you were shown, and cannot be re-used. If a branch has moved since the page you read was loaded, we refuse that one and tell you, and the others in that press still go in. The merge commit records that you approved it and names you. We record every one on our side: who, when, which repository, which pull request and the resulting commit. The code being merged is your agent’s, not ours — we write your application code only where an admin has chosen to have SeedQ build an app’s tasks, or in a revert of a task’s change, where an admin has switched Roll back on — and merging it does not mean we have confirmed the original report is fixed.
And one thing we can take back out. If you ask us to — by email, and only then — we will delete the issue comments we posted, across your repositories. We only ever remove comments we wrote ourselves, we never touch your own comments or anyone else’s, and we tell you how many went. We do not close or delete the issues you asked us to file, and we do not close proposed changes: those are yours to decide about. Check runs and their inline notes cannot be removed by anyone, including us — GitHub provides no way to delete a check once it has been published, so those stay attached to the commit they looked at. Every removal we run is recorded on our side with who asked and what was removed.
Each of the three can be set to Off, Warn or Block for the whole workspace or per repository, in the app under Guardian. If you leave the Guardian plan, one behaviour deliberately continues: a repository that has already had a pull-request check from us keeps receiving an automatic pass. Without it, a check you had made required would simply never arrive and every open pull request would be stuck behind it. That automatic pass involves no scan and no reading of your code.
Bug reports from the people who use your app
On any paid plan (SeedQ Launch Pro, SeedQ Launch Studio and SeedQ Guardian) you can turn on a report widget: a small form you embed in your own app so the people using it can tell you when something is broken and, if you switch them on, send you feedback or suggest a feature. If they do, what they type reaches us — a title, a description, the address of the page they were on and, for a problem, the steps they took and any error your app had already logged in their browser. We hold it so we can show it to you, and group repeats of the same problem together.
You can also let a problem report carry two more things, each off until you switch it on. A screenshot: the reporter’s browser asks them what to share, and they drag a box round the part they want to send, so we receive only the picture they chose. And technical details, sent only if the reporter ticks a box: recent errors on the page, the addresses the page loaded in the last five minutes with everything after a “?” removed, and their browser and screen size. Both are shown only to members of your workspace, never go into the GitHub issue or to a coding agent, and are deleted after 30 days. A screenshot shows whatever was on their screen, so make sure your own privacy notice covers it before you switch it on.
Three things about that text, because none of them is obvious. The people writing it have no account with us and may never have heard of us, so we treat it as yours, not ours: you are the controller of those reports and we process them on your behalf (see section 2), and a request about one goes to you. We rewrite it before it is used — the version shown on the report card, and the version any coding agent ever sees, is a stripped-down rewrite with links, markup and anything shaped like an instruction removed, because that text arrives from strangers and is a route into tools that can change your code. The original is kept beside it, clearly marked as unverified, and it is the shortest-lived thing we store — 30 days (see section 7). We ask for no name, no email and no account, and we deliberately do not record the reporter’s IP address.
Each widget carries a key that identifies your workspace and the repository its reports belong to. That key is designed to be public — it sits in your page where anyone can read it — so it grants nothing beyond filing a report, is capped so it cannot be used to flood us, and you can revoke it at any time.
When a page carrying the widget loads, the widget asks us which of those kinds of message your workspace has switched on, so a change you make reaches it without anyone editing your site. That request carries the widget key and nothing about the person on the page: no cookie, no referrer, and nothing is stored in their browser. It also carries the version number of the widget code on your site, and that number is the one thing we keep from it: we record the oldest version we have seen for each key over the last 30 days, so your settings can tell you when a copy on your site is out of date. It describes the code you pasted, not the person on the page, and we don’t log the request. Like any request over the internet it reaches our hosting provider from the visitor’s IP address, and the answer is cached there so the same question from many visitors does not reach our systems each time. If you use your own button instead of the widget’s, the request is not made at all.
If you choose to show your published release notes in the widget, it gains a “What’s new” tab. Only when someone on your site opens that tab does the widget ask us for your app’s published release notes. That request carries the widget key and nothing about the person on the page: no cookie, no referrer, and nothing is stored in their browser — the widget keeps no record of what they have read, so there is no unread marker. We don’t log the request. Like the request above, it reaches our hosting provider from the visitor’s IP address, and the answer is cached there for up to five minutes.
Your own team can file a report the same way, from inside SeedQ. That one is not anonymous — we record which member filed it, the same way we record who does anything else in your workspace — but the report itself is handled identically: rewritten before it is shown or acted on, grouped with matching reports from your users, and the original kept for 30 days. An admin can also change the wording of a bug report in SeedQ; we show their wording from then on, record who changed it and when, and keep the original as it was sent for its 30 days.
Error reports from your Sentry project
If you connect a Sentry project, Sentry sends us a report when it groups a new error in your app and when an error you had fixed comes back. What arrives is Sentry’s own summary: the error’s title and type, where in your code it happened, how severe Sentry judged it, the address of the page involved, and Sentry’s identifier for the error group. We treat it exactly like a widget report — rewritten before anything acts on it, the original kept 30 days, repeats grouped onto one card — and when Sentry says a fixed error has returned, we mark the report as having come back rather than opening a new one. We accept these deliveries only when they carry a valid signature made with the signing secret you give us, which we store encrypted at rest with AES-256-GCM, like the credentials below; disconnecting deletes that secret immediately.
Issues you hand to your coding agent
On the Guardian plan an admin can adopt an issue that already exists in your repository — one your own team wrote — so it can be handed to your coding agent through the same route as a bug report. When that button is pressed we read the issue from GitHub as it stands, and we keep a rewritten copy of its title and body beside the original snapshot, exactly as we do for a report from one of your users. Adopting an issue changes nothing in your repository: we do not edit it, label it, comment on it or close it, and the issue was there before we looked.
Two limits are worth stating, because both are refusals you may meet. We only adopt an issue opened by somebody inside your team — an owner, a member of your organisation, or a collaborator on the repository — so an issue filed by a passer-by is declined rather than put in front of something that can change your code. And we decline an issue with too little in it for an agent to work from, telling you what is missing instead. Nothing is adopted unless an admin in your workspace presses the button on that issue; there is no setting that adopts issues automatically.
Feedback and feature suggestions from your team
On the Guardian plan, members of your workspace can send feedback or suggest a feature for one of your apps from inside SeedQ. If they do, we keep what they wrote — a title, a description and, if they add one, the address of a page — rewritten in the same way as a bug report, with the original kept beside it for 30 days (see section 7), and we record which member sent it so your admins know who to ask. Feedback stays in your workspace for your team to read; it is never sent to a coding agent.
A feature suggestion reaches your coding agent only after an admin accepts it, and accepting it means writing up what should be built in their own words. We keep that write-up with the suggestion, and it is the only text about a suggestion we ever hand to an agent — never what was originally suggested.
If you switch them on, the same two kinds can come from the people who use your app, through the report widget, on any paid plan. Those are collected like a bug report from the widget — no name, no email, no IP address recorded, rewritten, with the original kept for 30 days. Feedback is never sent to a coding agent, and a suggestion reaches one only through an admin’s own write-up, which is part of the Guardian plan. On Pro and Studio an admin can choose to file ideas and feedback as issues in your repository (see “An idea or feedback you chose to file” above); otherwise they stay in SeedQ.
Slack and your own webhook (Guardian, optional)
Slack. If an owner or admin of your workspace saves a Slack incoming-webhook address, we keep that address encrypted and use it only to post short messages to that one channel when a task or an idea in your workflow needs someone or something happens to it. Each message carries what happened, the task’s or idea’s title, the app’s and the workspace’s names and a link to it in SeedQ: never a description, the rest of a report or code. Slack receives and stores those messages under your own Slack agreement. We do not read anything from Slack.
Your own webhook. If an owner or admin of your workspace gives us a webhook address, we keep that address and a signing secret encrypted, and use them only to call that address when a task or an idea in your workflow needs someone or something happens to it. Each call carries what happened, the task’s or idea’s title, its state, the app’s and the workspace’s names, ids and a link to it in SeedQ: never a description, the rest of a report or code. We only call addresses on the public internet, and we do not read anything back but whether the call was accepted. The service at that address is yours or your provider’s, and what it does with the call is governed by your agreement with them, not by us.
Where a title comes from. A task’s title is its GitHub issue’s title. Whoever opened the issue wrote it, and on a public repository that can be someone outside your team; where we filed the issue from a bug report, the title is taken from what the person who sent the report wrote. An idea’s title is written by your team or accepted from your coding agent’s suggestion, and an idea made from an item in your Inbox starts with that item’s title, which your app’s users or your own tool may have sent. Both the Slack message and the call send the title trimmed to 200 characters and with invisible characters removed, and nothing else that anyone wrote.
Items your own tool sends us. If an owner or admin makes a webhook address for an app, a tool of yours can send us an idea or feedback for that app, with the secret we gave you. We treat what arrives as untrusted text: it is cleaned before it is shown in your Inbox, and the original is kept for 30 days and then deleted, as with reports from the report button. Calls without the secret are refused and stored nowhere.
Roadmap themes your admins write
If an admin on a paid plan defines roadmap themes, we keep what they write: each theme’s name, its one-line goal, the optional lines on why it matters, what must not break and when it is done, and the issue labels that belong to it, with the login of the admin who last changed it. They are text your team writes, visible only inside your workspace, and deleted with your workspace. We never write a goal for you, and nothing about a theme is sent to GitHub. When a member ticks one of a theme’s “done when” lines, we keep the tick: the theme, which line, the login of whoever ticked it and when. A tick is deleted with its theme or with your workspace, and is never sent to GitHub. When a member marks a theme’s goal reached, we keep who did and when, on the theme, until someone answers “Not yet”. When a member’s builder suggests a theme for a task through SeedQ, we keep the suggestion: the repository, the issue number, the theme (or the new theme’s name and goal), its one-line reason and which member’s connection sent it. It changes nothing until a member accepts it, is deleted when the task gets a theme, with its theme or with your workspace, and is never sent to GitHub. When a member picks a theme for a task, we also keep that pick: the repository, the issue number and the theme, with the login of whoever picked it, never the issue’s text. A pick is deleted with its theme or with your workspace, and nothing about a pick is sent to GitHub. A theme also keeps when it comes on your roadmap (now, next or later). When a member adds a label to a task in SeedQ, we keep that label the same way: the repository, the issue number, the label and the login of whoever added it, never the issue’s text. A label added in SeedQ is never written to GitHub, and it is deleted with your workspace. When a member sets the order of an app’s agent queue on the Roadmap, we keep that order the same way: the repository, the issue number and its place, with the login of whoever added or last moved a task there and when, never the issue’s text. The order is never written to GitHub, and it is deleted with your workspace. When a member names the tags your agents use to mark work they have taken, and the agent each tag stands for, we keep those tags and names per app, with the login of whoever last changed them and what they changed. To show what each agent has taken, we read your open issues’ labels and assignees, and which open pull requests close them, live from GitHub, and store none of that. Reading them, we never set or remove a label, assign anyone or change a pull request (the one time we change a label is when a member saves an answer in Review, described above), and the tags and names are deleted with your workspace.
Your own steps before launch
On a paid plan, when a member adds a step of their own on the Before launch page (“Ask a friend to try the sign-up”), we keep what they typed, which app it is for, who added it and when, and who marked it done and when. It is visible only inside your workspace, never sent to GitHub, and deleted with your workspace. If a member is erased, their name comes off the steps and the steps stay for the rest of your team.
Release notes you publish
On the Guardian plan, if you turn on release notes for an app and publish them, we show the release notes you published at a public address you choose. Anyone with the address can read them, as a web page you can link to from your own site or as a JSON feed your site can display. Search engines may list the page unless you choose to hide it from them. We publish only the releases you choose to publish — never drafts, never which pull request or person a line came from — and hiding a release, or switching the page or the feed off, takes it off that address. Because they are public, a copy may be kept by browsers and by our content delivery network for up to five minutes. You decide what your release notes say, and we publish them as your processor (section 2).
If you add our optional release-notes rewrite workflow to a repository, it runs on your own GitHub Actions: it reads that app’s draft release notes from us, sends them to your own Claude account to be rewritten in plain English, and returns the rewrite to us. It uses your Claude plan token or Anthropic key, set as a secret in your repository; we never see it. We send nothing to a model provider ourselves. The rewrite is checked like any line an admin types, and it is published only if you chose to publish that app’s release notes automatically; otherwise it waits as a draft for you.
If you choose SeedQ to write your release notes, we send the release notes section of your pull requests and the titles of the pull requests in a release to the model provider you chose, using the API key you gave us.
SeedQ Loop run reports
If you turn on SeedQ Loop, each run reports back what it did, as a routine name, an outcome from a fixed list, an issue and pull request number and its running time. We keep these for 90 days.
Usage counts
We record daily counts of the work each workspace and repository makes our servers do, such as how many background jobs ran and how long they took. Counts only: no file contents, no person and no text.
Credentials you choose to give us
If you connect a read-only integration (Supabase, Vercel, Neon, Stripe, Cloudflare), the API key or token you provide is encrypted at rest with AES-256-GCM. With a Stripe key we read your webhook endpoints, whether your account is activated for charges and payouts, and your customer portal settings; we never read your customers, payments or balances. With a Supabase key we can count how many rows of a table someone holding your app’s public key could read — a number, counted inside a transaction that is then rolled back; we never read the rows themselves. We also count how many rows a freshly signed-up user of your app could read, using a made-up user id; we create no account and read no rows. With a Neon key we also read, where Neon lets us, whether a spending limit is set and how much of it has been used this billing cycle; we store that as of the last check and never read invoices or payment details.
On SeedQ Guardian, if you choose a coding agent that needs one, the key you give us for it is encrypted at rest with AES-256-GCM in the same way. We use it only to hand an incident you have chosen to send to that provider, and disconnecting deletes it immediately rather than at the end of any retention window. One of the agents we support needs no key at all — Claude Code runs in your own repository on a key only your workflow can read, and we never see it. Whoever’s key it is, is who the provider bills and whose name appears on the work.
When the fix workflow we propose for Claude Code runs in your repository, it can tell us how the run went: that Claude started on an issue, and how the run ended — the number of the pull request it opened, or a short outcome such as “stopped without a pull request” or “couldn’t sign in”. It sends this from your own GitHub runner to our servers, proving which run it is with a short-lived token GitHub issues to that run, so it needs no key of yours. We also read how the same run finished from the notice GitHub already sends us when a run completes. Where a stage of a task’s workflow was handed to Claude, the run also tells us which stage it was (triage, plan, build or check), the id we gave that stage and, for a check, whether it passed. The run also tells us what it cost, as Claude reports it at the end, and we store that figure with the run; we keep it only when Claude signed in with your API key, because a run on your Claude plan has no separate cost. We never receive Claude’s messages, its logs or your code this way. When an admin presses Check it now on the Claude Code setup card, we start that workflow’s self-test in your repository, a short run that only checks Claude can sign in, and we do nothing else with that run. If your workspace has granted SeedQ permission to save repository secrets, an admin can also paste a Claude token on that card. Your browser encrypts it with your repository’s public key before it leaves the page, so only GitHub can read it, and we save it in that repository as one secret, CLAUDE_CODE_OAUTH_TOKEN, only when an admin pastes it. We write no other secret.
If you add the SeedQ Loop workflow we propose — one file, .github/workflows/seedq-loop.yml, opened as a proposed change you choose to merge — it runs your coding agent in your own GitHub account, on your own runner minutes, with your own Claude plan and your own tokens. SeedQ does not run the agent and can read neither the Claude token nor the GitHub token the workflow uses. Before each run the workflow asks us whether to go, and it reports back what it did. When an admin presses Check it now on the SeedQ Loop setup card, we start that workflow’s self-test in your repository, a short run that only checks Claude can sign in and that the workflow can ask us whether to go, and we do nothing else with that run.
If you add the test-proof workflow we propose — one file, .github/workflows/seedq-proof.yml, opened as a proposed change you choose to merge — it runs on your own runner whenever your coding agent’s change includes a test. It tells us, for each test file the change touched, whether the tests passed with the change and whether they failed without it. It names each file by a one-way fingerprint of its path, never the path itself, and we match that against the change’s list of files, which we already read. Like the fix workflow, it proves which run it is with a short-lived token GitHub issues to that run, so it needs no key of yours. We never receive test names, test output, logs or your code this way. If you also turn on before-and-after pictures, the same workflow opens the pages your coding agent names, on your preview deployment and your live site, and saves the pictures in your own GitHub. It only opens those pages; it never clicks, types or submits anything. We learn only whether each picture was taken, never the picture itself. If you give it a test login so it can open signed-in pages, that login is stored as a secret in your repository and is never sent to us.
Checks on your preview, if an admin turns them on. When a pull request SeedQ started has a preview deployment, we open your app on that preview in a Vercel Sandbox, a short-lived computer Vercel runs for us, and follow the steps in your tests/core check files: signing in, saving something, paying with a test card. We copy only those check files into the sandbox, never the rest of your code, and the sandbox is deleted when the run ends. We never check a pull request a person wrote. The browser sees whatever your preview shows, including any data in it. We keep only which steps went through and which one stopped, never the pages, their text or a picture of them. To get past your host’s preview protection and to sign in, you can give us a preview bypass secret and a test login. We store both encrypted at rest with AES-256-GCM, use them only for these runs, never show them again, and delete them when you remove them or uninstall. Use a test account, never a real person’s. If an admin also turns on checks on your live site, after each deploy to production we open the first and last page of each of those steps on your live site, in the same kind of sandbox, without clicking, typing or signing in, and keep only whether each page answered.
Product analytics
To understand how the product is used we record a small set of usage events (for example “a scan completed”, “a subscription changed”) with PostHog, hosted in the EU. Product events run server-side; page-view analytics on our website runs in PostHog’s cookieless mode. Neither sets cookies or stores anything in your browser; the identifier attached to events is a one-way hash, never your login, email or repository name, and events never include repository content or finding text. Basis: legitimate interests (improving the service).
Session recording, for beta testers who opt in. We ask beta testers, and only them, whether PostHog may record how they use SeedQ (where they click, what they open, where they get stuck, and errors and page speed) so we can see what to fix. It is off unless you say yes. Everything you type is hidden, and code, fix prompts, keys and report text are blocked from the recording. The recording is keyed to the same one-way hash, never your login or email. While it is on, PostHog keeps an identifier and its settings in your browser’s local and session storage, never in a cookie. We keep a record of each answer you give. You can stop at any time from your account page: recording ends at once, the storage is removed from your browser, and we ask PostHog to delete what it recorded. Basis: consent.
4. How and why we use it (legal bases)
- To provide the service — run scans, show results, manage your team and repositories. Basis: performance of a contract.
- Security, abuse prevention & audit — verify sessions, keep audit trails, protect the service. Basis: legitimate interests (and, for the data we process for you, your organisation’s instructions).
- Billing — manage subscriptions and payments. Basis: contract and legal obligation (e.g. tax/accounting records).
- Transactional communication — invitations and service notices. Basis: contract / legitimate interests. We do not send marketing email without your consent.
- The AI logic review (section 3), if your workspace uses it — send selected files to our AI provider and show you what it found. Basis: your organisation’s instructions, given by an admin agreeing before the first review; we keep a record of that agreement.
- Telling you a plan has opened — if, and only if, you asked us to. Basis: consent. It is a single email per request, and asking never signs you up to anything else.
7. Retention and deletion
- Sessions expire on a sliding window (about 30 days) and can be revoked at any time by signing out.
- Webhook and job records — the delivery payloads we receive from GitHub to run scans and routines — are deleted automatically after at most 30 days, and an installation’s queued payloads are removed as part of its erasure. These records keep the event data as GitHub sends it, so they can include commit author names and emails and the text of pull requests and issues.
- Scan results — the findings, the history of when each one appeared, was fixed, or came back, and each scan’s readout of your app — are kept while the app is installed so you can see history and trends, and deleted about 30 days after you uninstall it. An owner or admin can download this history at any time, as JSON or CSV, from the Settings page of Health check; the download holds titles, paths and dates, never your files’ contents.
- Push activity — when a push happens on your default branch, we record its shape: the branch, the commit references, and which file paths were added, changed or removed. On SeedQ Guardian we also store each changed path's file version identifier (its blob SHA), never its contents, so we can tell you when a file went back to a version it had before. This is what lets us tell you what changed between two scans. We do not store commit messages or the name, login or email of whoever made the commit in these records. We keep only whether each push, and each pull request update we check, came from a builder, a coding agent or a person. The event data GitHub sends us (see webhook and job records above) can include messages and names for up to 30 days. When a page shows which change a problem first appeared after, that change's title and who made it are read from GitHub as the page loads and not stored. These records are deleted automatically after 90 days.
- Deployment state — if you connect a hosting provider for the Integrations scan, we record where your app is served (its address) and how its last deploy went: whether the build succeeded, when it ran, the commit reference it was built from, and a link to your provider’s own build log. We never fetch or store your build logs — we keep the link so you can open them yourself. We hold the most recent reading only, and it is replaced each time a scan looks again; disconnecting the integration stops us reading it. Separately, once your installation lets us read your repositories’ deployments on GitHub, we keep a history of your production deploy statuses as GitHub reports them: the repository, the environment, the state, the commit reference, GitHub’s timestamp and the host’s link — never build logs or deploy descriptions. Each is deleted automatically after 90 days. All of it is erased with your installation.
- What your connected services showed us — when the Integrations scan reads a Stripe, Cloudflare or Supabase connection, we keep the one fact the stack-health panel or a cross-check needs: how many live Stripe webhook endpoints you have, which SSL mode your Cloudflare zone uses, or, from a Supabase project, the host its sign-in emails link to (the host alone, such as
app.example.com, with no path or query). A number, a setting name or that one host only — never an endpoint address, the events it receives, or an account id. We hold the most recent reading only, and it is replaced each time a scan looks again. A reading no scan has refreshed is deleted automatically after 90 days, and all of it is erased with your installation. - Your Supabase project’s region — a short code such as
eu-central-1, read from Supabase when a check runs and kept with your scan results, so the launch checklist can name the country your data sits in. Like the readings above, it is replaced each time a scan looks again and deleted automatically after 90 days if no scan refreshes it. It is deleted with the workspace. - Your Neon project’s spending limits — whether a limit is set, each limit and how much of it has been used this billing cycle, as numbers, read from Neon when a scan runs and kept with your scan results as of the last check. Never an invoice or payment details. Like the readings above, it is replaced each time a scan looks again and deleted automatically after 90 days if no scan refreshes it. It is deleted with the workspace.
- Usage counts — the daily counts of the work each workspace and repository makes our servers do are kept for 13 months, and erased with your installation.
- If you turn on SeedQ Loop, we keep a short record of which issue or routine each run has locked, for seven days.
- When your builder checks a branch before a pull request, we keep the new problems that check found (their titles, check ids and fix prompts) for seven days, then delete them automatically.
- If you turn on SeedQ Loop, each run reports back what it did, as a routine name, an outcome from a fixed list, an issue and pull request number and its running time. We keep these for 90 days.
- Where task workflows are switched on, we keep what each finished stage of a task recorded (the same words as its comment on the issue) for 90 days after that stage finished, then delete it automatically. Which stage ran, and when, the commit a change went in as and the time it was marked small stay with the task until your workspace is deleted.
- Where task workflows are switched on, we keep a record of each moment worth telling someone about (a task needs you, a stage went wrong, a change went live) and of who we told and how, for 90 days, then delete it automatically. The emails carry the task’s title, the app’s name and a link, nothing else. How each person chose to be told is kept while they are a member of the workspace.
- The Slack address and the webhook addresses and secrets your workspace saves are kept until an owner or admin removes them or you uninstall, and the record of each save, removal and test is kept until you uninstall.
- Whether your app answered — when we know your app’s address, a scan asks it for its response headers. We record what came back: the status code, how long it took, and if it failed, our own short reason (for example “timed out”). We never store the page itself, its content, or anything about your visitors. These are spot checks taken when a scan runs, not continuous monitoring, and each record is deleted automatically after 90 days. They are erased with your installation.
- Build results — on the Guardian plan, when an automated check finishes on your repository we record how it went: which app produced it (GitHub Actions, your host’s preview build, and so on), the workflow’s name, the commit reference, the branch, whether it passed or failed, how long it took, and — when you re-run a workflow — which attempt each result belongs to. If a workspace admin asks us to pull in past runs, we fetch the same details for up to 90 days of history from GitHub, once, on that click. We never fetch or store your build logs — that is a promise we keep by policy: our permission to read your run history could technically reach them, and we don’t. There is one narrow exception, and only when a check fails: GitHub attaches a short note to a failed check, and we read that note to see whether it says GitHub refused to start the jobs because of a billing problem — a freeze that otherwise looks exactly like broken code. We keep only our own yes/no answer to that question, never the text of the note itself. These records are deleted automatically after 90 days and are erased with your installation.
- What your coding agent’s runs did — on the Guardian plan, for each run of the fix workflow we propose: which issue it worked on, when it started and finished, how it ended (a word from a short fixed list, such as “opened a pull request” or “couldn’t sign in”), the pull request’s number if it opened one, and what the run cost as Claude reported it, for runs that used your API key. Never Claude’s messages, logs or code. These records are deleted automatically after 90 days and are erased with your installation.
- Test results from your coding agent’s changes — on the Guardian plan, for each run of the test-proof workflow: the pull request and commit it ran on, and for each test file a fingerprint of its path with one word for how it ran with the change and without it (“passed”, “failed”, “didn’t load” or “didn’t run”). Never test names, test output, logs or code. These records are deleted automatically after 90 days and are erased with your installation.
- Preview check secrets — kept, encrypted, until you remove them or uninstall.
- Preview check results (which steps went through, never the page) — 90 days.
- Live-site check results (whether each page answered, never the page) — 90 days.
- When we first saw your Claude token work — if you run Claude Code with a token you made yourself, the date SeedQ first saw the token sign in successfully (from a self-test or a run report), kept for each repository’s token, so we can email your admins once for each repository, about 11 months later, before a one-year token runs out. It is when we first saw it work, not when the token was made, and we never hold the token itself (if an admin pastes it into SeedQ, their browser encrypts it so only GitHub can read it). We keep it, and a note of whether the email went, for as long as the connection exists, and delete it when you disconnect your coding agent or leave. If a sign-in in a repository fails, we forget that repository’s date. Only a sign-in with the token counts, not one with an API key.
- Guardian records — where the Guardian plan publishes to your pull requests, issues and pushes (see section 3), we keep a minimal record of what we published so we don’t repeat ourselves: counts from each pull-request check, an issue’s score and which structural signals it met (a number and yes/no flags), and a fingerprint of each repeat-edit warning so the same one isn’t posted twice. We also keep the title of each pull request and issue we score, and the label names on those issues — never the body, comments, or code, so the Guardian pages can show you which one we mean, and whether it is a bug or a chore, without sending you to GitHub to find out. Scoring an issue never stores its body. There is one deliberate exception, and it takes an admin’s click: if an admin adopts one of your issues to hand it to your coding agent (see section 3), we keep a rewritten copy of that issue’s text so the incident card and the agent’s briefing have something to work from. That copy is covered by the bug-report clocks in the entry below, not by this one. Labels are the names you gave them and nothing else: no colours, no descriptions, and only the first few of them. None of it contains your code or finding text. We also keep how many issues are open on each repository — a number and the time we counted it, nothing else — so we can tell you what is still outstanding beside a scan result. When you open the list of those issues in SeedQ, it is read from GitHub as the page loads and not stored: what you see there leaves us as soon as the page is sent. These are deleted automatically after 90 days, with one exception: the most recent pull-request check per repository is kept, because it is what tells us to keep sending an automatic pass after you leave the plan rather than leaving a required check permanently unanswered. For any app where you turn release notes on, we also keep the lines in the “Release notes” section of each pull request merged into that app’s main branch, plus one line when that merge ships a feature request your admin accepted (the first line of the admin’s write-up) or fixes a reported incident (the incident’s title) — never the rest of the pull request’s description. Lines waiting to go into a release, and releases that were never published, are deleted after 90 days; a release that was published is kept for as long as your workspace exists.
- If you give us a model API key for release notes, we keep it encrypted until you remove it or uninstall; we never show it again.
- Decisions about findings (see section 3) are kept until your installation is erased; there is no separate clock. Removing a decision stops it applying, and an accepted risk lapses after 90 days and must be decided again, but in both cases the record of it, including the reason, stays until then.
- Labels on findings (see section 3) are kept until your installation is erased. The optional note on a “correct” answer is cleared automatically after 90 days; the label itself stays.
- AI logic review results (see section 3) — the findings, the answers your admins give them, and each review’s file count, tokens and cost — are deleted automatically 90 days after the review ran. The record of an admin agreeing to the review, and of any withdrawal, is kept while your installation exists, because it is our evidence of permission to send the files; withdrawing does not delete it. Both are erased with your installation. The files we send are not stored by us; Anthropic deletes them as described in section 6.
- Bug reports from the people who use your app (see section 3) — and the snapshot of any issue an admin adopts — are kept on two different clocks, and the shorter one covers the part a stranger actually typed. The original text is deleted after 30 days, whatever state the report is in — the rewritten version we show you outlives it, and after that the card carries our rewrite alone. A screenshot or the technical details a reporter sent go at the same 30 days, and a screenshot no report ever claimed within a day of upload is deleted then. The report itself, with its history, is deleted 90 days after you close it; one you have not closed is a problem you still have, so we keep it until you do or until your installation is erased. A revoked widget key or Sentry connection is deleted 90 days after you revoke it — and revoking a Sentry connection deletes its signing secret at that moment, not at the end of the 90 days. All of it is erased with your installation, and erasing a workspace deletes its widget keys and Sentry connections immediately, so a widget still embedded in a page can no longer file anything.
- Feedback and feature suggestions (see section 3), whether your team or the people using your app sent them, keep their original text for 30 days, after which the rewritten version stands alone. One you close, or merge into another, is deleted 90 days after that. One nobody has decided about yet, and one an admin accepted, is kept for as long as your installation exists — an accepted suggestion, with its write-up, is the record of what was handed to your coding agent. All of it is erased with your installation, and a member who asks to be erased stops being named on the suggestions they sent.
- A disconnected coding agent — the record that your workspace used one, and when you switched it off — is deleted 90 days after you disconnect it. Any key we held for it is gone the moment you disconnect, so what remains for those 90 days holds no credential. A connection you are still using is kept while you use it, and everything here is erased with your installation — immediately, rather than waiting for the window.
- Beta feedback (see section 3) — answers you have not sent are deleted 90 days after you last saved them, and answers you sent are deleted 12 months after you sent them. Deleting your account deletes them at once.
- Launch-waitlist addresses given on our website are deleted within 30 days of the “it’s open” email going out, and within 180 days if the plan hasn’t opened by then. The unsubscribe link deletes the address immediately. A waitlist request made while signed in lives with your workspace and is erased with it.
- Audit and billing records are retained for as long as needed for security and to meet legal/accounting obligations.
- AI token records — the token ledger, the balance, your token settings and the card reference (brand and last four) — are kept while the workspace exists and erased with it.
- Removals — if we remove someone from SeedQ, the record of it (their GitHub user id and login, the reason and who removed them) is kept for as long as the removal stands, including after their account is erased, because it is what stops them signing back in. If we lift a removal, the record is deleted 90 days later. When we remove someone we may also remove the SeedQ App from their GitHub account, which starts the automatic erasure described below.
- Uninstalling the GitHub App stops further processing and removes your repository selection immediately. Everything else we hold for the installation — scans, findings, stored credentials, billing records — is then erased automatically about 30 days after uninstall (the grace window covers a regretted uninstall or a support conversation). Uninstalling does not, by itself, cancel a paid subscription — cancel from the Billing page first if you’re leaving; as a backstop, any subscription still active when the erasure runs is cancelled at the same time, so you are never billed for an erased workspace.
- Erasure on request — need it gone sooner, or without uninstalling? You or your organisation can ask us to delete your installation’s data (including stored credentials). We action verified requests within 30 days, except where we must retain limited records by law.
8. Your rights
Under UK/EU GDPR you have the right to:
- access a copy of your personal data;
- have inaccurate data corrected;
- have your data erased (“right to be forgotten”);
- restrict or object to certain processing;
- data portability; and
- withdraw consent where we rely on it.
Signed-in users can exercise access and erasure directly, without emailing us: the Account page offers a self-serve data export (“Download my data”) and account deletion (“Delete my account”); the product guide walks through both.
To exercise any of these, email privacy@seedq.dev. If you believe we have mishandled your data you can complain to your supervisory authority.
9. How we protect your data
We apply technical and organisational measures appropriate to the risk (UK/EU GDPR Art. 32): encryption in transit (HTTPS), AES-256-GCM encryption at rest for stored credentials, HMAC-verified webhooks, server-side revocable sessions, GitHub permissions limited to what our features need, role-based access control, and append-only audit logs. Our security practices and how to report a vulnerability are described on our security page.
10. Children
SeedQ is a tool for software developers and is not directed at children. You must be at least 18 to use it, and we do not knowingly collect data from anyone under 18. If we learn that an account belongs to someone under 18, we close it and delete its data.
11. Changes to this policy
We may update this policy as the product evolves. We’ll change the “last updated” date above and, for material changes, give prominent notice.
12. Contact
Questions about this policy or your data: privacy@seedq.dev. See also our Terms of Service and Cookie Notice.