An AI teammate that turns GitHub issues into pull requests, in your own cloud

Writing code stopped being the slow part of shipping. The slow part is verification: running the tests, reading the diff, deciding whether to trust it. quellbot is an AI dev teammate for that half of the loop. It takes a GitHub issue to a pull request in a throwaway machine in your own cloud, runs your test suite, passes a deterministic policy gate, and never merges.

The bottleneck moved

If you have used a coding agent for real work, you know where the day goes. Not into typing code. It goes into running the suite, reading a diff you did not write, chasing a red CI run, and deciding whether to ship. Code generation got cheap. Tests, review, CI and trust did not.

You probably carry a few scars. A review bot that commented on every line until the team muted it. A bill with no way to tell which run caused it. A permission prompt asking for every repo in the org, with no explanation of why.

quellbot is built for the verification half of that loop. It is a GitHub App plus a hosted console. The console holds settings and credentials. The App listens for issues, pull requests, failed workflow runs and mentions, and works where you already look: in comments and pull requests on your repos.

Four jobs, one teammate

Issue to pull request. Open an issue with a trigger slug, or comment /build on any issue, and quellbot plans, builds, tests, and opens a pull request. The rest of this post walks through that path.

Pull request review. Every new pull request (drafts excluded) gets a verdict, a summary, a per-file walkthrough, findings grouped by severity, and committable suggestion blocks. Push again and it re-reviews only the delta: fixed, still open, or new. It never repeats a finding. More in what a review bot has to get right.

CI triage. When a GitHub Actions run fails, quellbot reads the failed job, the step, the log tail and the diff, then posts what failed, the likely root cause, and a concrete next step. It is advisory only: it never reruns a workflow, never changes a status check, never edits CI. See red CI, explained.

Replies and release notes. Mention @quellbot on any thread and the answer cites file and line. When you publish a release, it drafts the release notes.

From issue to pull request, end to end

Trigger

A run starts from a new issue whose title, or any line of its body, begins with a trigger slug. The defaults are quell:, build: and fix:, and you can change them per account and per repo. You can also comment /build on any issue. Only someone with write, maintain or admin permission on the repo can start a run, so an issue from a stranger starts nothing.

Title: quell: date picker drops the timezone on save

Steps: open /settings/profile, pick a date, save, reload.
Expected: the saved date matches the one picked.
Actual: the date is one day earlier for users west of UTC.
Repro: test/profile/date.test.ts, currently marked skip.

Plan

Before it touches any code, quellbot posts a plan as a comment on the issue. The plan is reused, not regenerated. Edit or delete it and the next /build re-plans.

Auto-build is on by default: the run continues from plan to build, and reviewing the pull request is the approval. Turn auto-build off and the run stops at the plan until someone replies /build.

Build

The build runs in a throwaway Fly Machine in your own Fly.io account. quellbot clones the repo with a short-lived token scoped to that one repo, runs the real claude or codex CLI headless, runs your test suite, and produces a diff. Then the machine is destroyed. About a minute, start to finish.

Outbound network on that machine is deny-by-default: the model provider and GitHub are reachable, nothing else. Whatever an injected instruction asks the agent to do, there is nowhere else to send anything.

Policy gate

The diff then passes through a deterministic policy gate on the control plane. No model is involved; the same diff always gets the same answer. The rules:

• No changes under .github/workflows/, CODEOWNERS, funding files, or submodules. These cannot be allow-listed.
• No newly added secret-shaped strings.
• Size and file-count limits.
• No new symlinks or submodules.

If the diff is blocked, the branch is deleted and quellbot posts a comment naming the rule it hit. Nothing lands.

Pull request

If the diff passes, quellbot opens a pull request on a bot branch. From there it is an ordinary pull request: CI runs, reviewers read it, you merge or you do not.

Sometimes there is no fix it can verify. Then it does not open a pull request with a guess. It posts a no-fix comment: what it investigated, what it tried, and what a human could add. A clear no-fix is worth more than a plausible diff that fails quietly.

The sweet spot is well-scoped, reproducible bugs: a failing test, a clear repro, a small surface. It is not built for large features.

Your cloud, your code, your credentials

The control plane runs no model or CLI compute. What it does run: receiving webhooks, posting comments, running the policy gate, and holding your credentials, encrypted at rest with AES-256-GCM. The clone, the CLI and your test suite all run inside the machine in your Fly.io account. quellbot's servers never hold a copy of your code.

Three things quellbot never does: merge, push to a default branch, or edit .github/workflows. The last one is not a promise in a prompt. The GitHub App is not granted the workflows permission, so GitHub itself rejects the write. The reasoning behind the design is in why an AI coding agent should never merge, and the full list lives in the security section of the home page.

Two model lanes, your own account

quellbot runs on two model lanes, and they are peers. The Claude lane runs the Claude Code CLI with a Claude subscription token from claude setup-token, or an Anthropic API key. The Codex lane runs the OpenAI Codex CLI with a ChatGPT subscription approved through a device code, or an OpenAI API key.

Either way the credential is yours, and the model list is fetched live from the provider. You set the lane, the model and the reasoning effort once per account, and override any of them per repo.

What a run costs, and who sends the bill

There are three bills, and quellbot sends only one of them.

Public repos are free: unlimited, forever, every feature. Pro is $29 a month or $290 a year (the yearly plan bills ten months) for unlimited private repos and unlimited teammates. There is no per-seat pricing and no markup on model spend. There is a 14-day full refund. Dodo Payments is the merchant of record. Details are on the pricing page.

Model usage is billed by your model provider. Compute is billed by Fly.io, per second, at about a minute per run; Fly requires a card on file. A small fix on a mid-tier model usually costs a fraction of a dollar, and the run page shows the exact figure.

Budgets depend on the credential. On an API key, every model call is debited atomically at the model gateway against a per-run safety limit, and you set one monthly cap that covers every kind of work. On a subscription there is no dollar cap to set, so a runaway guard caps model calls per run instead. Either way you get an alert, plus one throttled email, when the credential dies or the cap is hit. The longer version is in what an AI dev teammate actually costs.

Set it up in one sitting

Four steps, all from the console at console.quellbot.dev:

1. Sign in with GitHub.
2. Install the App on the repos you want it in.
3. Connect a model credential: a Claude or ChatGPT subscription, or an API key.
4. Connect a Fly.io token. Paste it, or run npx quellbot-connect fly <code>.

The Get started page verifies each connection live, so you know it works before the first issue is filed. The fuller walkthrough is in the guide.

Writing the code was never the hard part. Checking it is, and that is the part quellbot takes.