You can’t read the code your agent writes.
collabd tells you it’s safe to ship.
You describe what you want and approve a plan in plain English. The agent writes the code. Then an independent verdict — not the agent that wrote it — confirms the code did what you approved and renders one honest, SHA-bound call: safe to ship, needs your review, or do not ship. You stay in control at the one judgment you’re equipped for — is this what I want — and the machine handles the rest.
2 clicksSign in with your GitHub account, then install the app on the repos you choose — no password, no setup wizard. You land on your board.
Already building with collabd? Sign in to your board →
Three words. No dashboards to interpret, no score to second-guess.
The verdict is a fixed vocabulary — never a continuous "risk score" you have to calibrate. Every verdict is icon + word + color, so it survives grayscale, color-blindness, and other people’s UIs.
Everything else in the product is deliberately near-monochrome. When green, amber, or red appears, it is the machine’s judgment — nothing else on screen competes with it.
You approve the plan. The agent builds it. An independent verdict confirms it. You ship.
Describe the task you
One title and a paragraph of context, in plain English. Pick which AI model builds it — the choice is pinned for the whole run.
The agent proposes a plan agent
Numbered steps, files likely touched, a test plan, and its open questions — skimmable, never a markdown wall. No code is written yet.
You approve, redirect, or reject you
Rejecting requires a note, because your note becomes the agent’s next instruction. Answer its open questions inline; your answers travel into the build.
It builds on a branch and opens a PR agent
You watch live progress — the current step, elapsed time, the agent’s activity — and can stop it at any moment without losing the partial work.
An independent reviewer renders the verdict machine
A separate model — never the author reviewing itself — reads the diff, runs the tests, and renders safe / review / block with ranked, typed, line-pinned reasons.
You ship — or you don’t you
Ship is the one committal action in the product: it unlocks only on a safe verdict (or your written acknowledgment) and merges exactly the SHA that was reviewed.
Already have an agent opening PRs? Point the same verdict at those.
Step 5 above doesn’t need steps 1–4. If something else is already opening pull requests on your repo — Devin, Copilot, Claude Code, your own harness, or a human — collabd can review those PRs and post the same three-word verdict as a GitHub check. Same reviewer, same SHA-bound evidence, pointed at code collabd didn’t write.
A separate app that never writes to your code
Reviewing is a different GitHub App from the one that authors code for you (Security, below, describes that one). This one asks for contents:read and pull_requests:read to read the diff, and checks:write to post its own check. Every write permission it holds writes to that check and nowhere else — it cannot push a commit, open a PR, or merge anything.
It reports; it doesn’t block your merge button
The check is advisory unless you make it required in your branch protection. collabd renders the call and pins the evidence — what it decided to do about it stays your choice.
Same honesty rules as the loop
Every review verdict is bound to the exact SHA it judged, states what it did and didn’t check, and carries a content-addressed evidence bundle (sha256:…) you can export and recompute.
You pick the repos. GitHub sends you back to collabd to switch the verdict on — one short form, no waiting on us. Until you do, PRs show a neutral “connect to activate” check, never a false pass or fail.
Honest by construction, not by promise.
Verdicts are bound to a SHA
A verdict belongs to the exact commit it judged. If the PR head moves afterward, the verdict goes loudly STALE and Ship locks — it can never quietly vouch for code it hasn’t read.
Blind spots are stated
Every verdict says what was checked and what wasn’t. An infrastructure failure reads "indeterminate" — never dressed up as a pass or a fail.
Evidence you can take with you
Each verdict carries a content-addressed, secret-redacted evidence bundle (sha256:…). Export it, recompute it, audit it.
Author ≠ reviewer
The provenance line names who wrote the code and who judged it — two different models, recorded on every verdict.
Your agent writes code on your behalf — safely, and on a tight leash.
This section is about the app that authors code — the loop above. (The review app is separate and never writes to your code.) The agent pushes to a working branch and opens a PR — the merge happens only when you click Ship. The security posture is structural — least privilege, short-lived tokens, isolation, redaction, and an audit trail bound to you — not a promise in a policy page.
Least-privilege GitHub App, scoped to author
The app writes to a working branch and opens a PR — contents:write, pull_requests:write, metadata — and nothing more. It merges only the reviewed SHA, and only when you click Ship. Every push, PR, and merge is made with a short-lived installation token, authored as collabd-app-authoring[bot] and audited to the person who asked for it. The permission set is frozen and version-controlled; widening it would require your org to explicitly re-consent.
Builds and reviews run sandboxed, never with your secrets
The agent builds, and the independent reviewer reads the diff, inside an isolated sandbox — never with your production secrets. Untrusted code is treated as untrusted by construction; when trust can’t be established, collabd errs on the safe path — the cost is an extra sandbox, never a wrong trust call.
Secrets are redacted before anything leaves
Every payload posted to a surface collabd doesn’t control — check summaries, evidence bundles, notifications — is secret-redacted first. collabd never controls the bytes once they’re posted, so nothing sensitive is in them.
Every action is attributed and audited
Approvals, overrides, re-runs, and ships — and every push the agent makes on your behalf — are recorded with the acting human and a required reason. Verdicts are bound to the exact SHA they judged, and each carries a content-addressed evidence bundle (sha256:…) you can export and recompute.
Access is default-deny: partner sessions see only their own tenant’s runs, and new surfaces are unreachable until explicitly allowed — hiding is a courtesy, never the security boundary.
Early access is hands-on, on purpose.
collabd is onboarding a small set of design partners — people building real products with AI agents who want to ship without reading the diff. We install with you, get your first run from plan approval to Ship, and tune the verdict against your actual work.
Become a design partner
Install the GitHub App on your repos and sign in to your board — setup is self-serve. Or write to us first: tell us what you’re building and how you’re using AI agents today, and we’ll onboard you hands-on.