Solutions · Automate PR review to merge
Automate pull request review to merge. Your rules decide what lands.
AI code review on every pull request: Autopilot reviews the code and its security, answers review comments and pushes fixes. Forge’s deterministic checks and your merge rules decide what lands. Autopilot never merges, approves or cuts a release; built-in merge and release workflows are coming.
The problem
Why agent-written pull requests pile up.
Agents open pull requests faster than people can read them. A bolt-on AI code review tool adds a comment to each, but it does not know your architecture, cannot fix what it finds, and leaves a person to shepherd every round of feedback.
A review is also only half the gate. On a stitched stack, “is this safe to merge?” is spread across a CI vendor, a linter config, a security scanner and someone’s memory of which migrations lock tables. An agent reading the diff sees none of it.
How it works
How it works on Reliant.
Multi-agent coding workflows where agents do the reading and writing, checks that come out the same every time, and a person at the merge.
- Agent
An agent opens the pull request
Label an issue agent:ready and the Autopilot issue worker writes a failing test and the fix, runs your fast checks, pushes an autopilot/* branch and opens a PR that closes the issue. Or open one yourself, from any agent.
- Forge · deterministic
Checks run the same way every time
In a Forge project, generated code must match its inputs, lint catches whole bug classes, every migration declares whether the previous release survives it, the API is checked for breaking changes, and tests run against real Postgres. A skipped check is never reported as a pass.
- Agent
Code review and security review
Autopilot PR review reads the diff and the code around it and posts one review. Security review threat-models the diff read-only, covering auth on new endpoints, injection, SSRF, secrets and dependency advisories, and marks each finding confirmed or suspected.
- Agent
Review comments get answered
On a PR an agent wrote, or one you label agent:respond, the review responder changes the code, pushes to that PR’s branch and replies in each thread. After three rounds it hands the PR back to a person.
- You
You set the rules, and a person merges
Today, branch protection, required checks and approvals decide what may merge. Set the agents to write as the Reliant bot and a person can approve and merge what they open. Autopilot has no merge action at all.
- Reliant · deterministicComing
Merge when the gate is green
A built-in workflow that merges a reviewed pull request only after the deterministic checks pass on it merged onto main, under the rules you set.
Review status - Forge · deterministic
Releases stay deterministic
After the merge, Forge builds the release once and promotes the same digest. A release gate can refuse prod until staging holds a pass for that release.
- Reliant · deterministicComing
Cut release candidates and promote after a soak
A built-in workflow that cuts a release candidate from main and promotes it once it has soaked and its release verdict is good.
Release status
issue labelled agent:ready
→ issue worker opens a PR (agent:authored)
PR opened or marked ready
→ PR review and security review post findings
review or comment submitted
→ review responder pushes fixes and replies
checks green and approved
→ a person mergesWho does each step
- Agent
- Forge · deterministic
- You
- Reliant · deterministic
Built in
What ships today, and what is coming.
Each built-in is off until you turn it on, and any of them can be the start of a workflow of your own in YAML.
Built-in: Autopilot
PR review, security review, issue worker and review responder (plus on-call), each turned on separately, for the GitHub repositories you pick.
Built-in: Get It Right
Implement, check, review and retry until the change passes, for work where one attempt is not enough.
Built-in: Best of Three
Three agents build in separate worktrees; a reviewer picks the best result or combines them.
Coming
Merge, release-candidate and soak workflows
Built-ins that merge a reviewed PR on a green gate, cut release candidates and promote them after a soak. Until they ship, Autopilot neither merges nor cuts releases, and your merge rules decide what lands.
Release status
What you get
What you get.
Review, repair and gates in one loop, on the models you choose.
AI code review on every PR
One review per pull request, by a different model tag from the author’s by default. Opt PRs out with a label, or ask for another pass.
Review featuresSecurity review
Findings grouped by severity, each with path and line, evidence, an exploit sketch and a fix. It runs nothing against live systems.
Autopilot guideFixes for review comments
The responder pushes to the PR’s own branch only, after your fast checks pass, and replies in each thread.
Autopilot guideDeterministic gates
Forge’s lint, generated-code drift, migration safety and real-Postgres tests, with the same verdict locally and in CI.
Test featuresMulti-agent workflows in YAML
Mix agents with shell steps, integration calls, conditions and approvals. Pick the model, and how hard it thinks, for each step.
Workflows overviewWorkflows you can test
Scenario tests run a workflow deterministically before it goes live, and workflow lint catches ones that misbehave when nobody is watching.
Testing workflowsA bot identity for agent work
Agents write as the Reliant bot, never beyond what your own account can push, so their PRs are approved and merged by a person.
GitHub integrationGuardrails on every push
Agent shells run without credentials. Pushes are plain fast-forwards to agent branches, never to your default or a protected branch.
Autopilot guide
Why one platform
Why this takes one platform.
A reviewer that only sees the diff can tell you a line looks wrong. When the same platform generated the services, owns the lint and records the releases, the checks know which RPCs exist, which migration would lock a table and which release a change will ship in, and the agents that review and repair the change run on the same checks. Review stops being an opinion attached to a pull request and becomes part of a pipeline whose verdicts are deterministic.
Honest limits
What it does not do, and what stays yours.
The lines Autopilot does not cross are in the workflows themselves, not only in a prompt.
Autopilot never merges, never approves, never pushes to your default or a protected branch, and never cuts or promotes a release.
Reviews are of the code only. Security review runs nothing and is not a penetration test.
The deterministic gate is Forge’s. In a repository without Forge, Autopilot still reviews, but the checks are whatever your CI runs.
Built-in merge and release workflows are coming, not shipped. Today a person merges under your rules, and releases are promoted with Forge’s commands and gates.
Autopilot works on GitHub. Review runs on every non-draft PR by default, so in a busy repository use labels to opt PRs in and keep cost in check.
Questions
What people ask first.
Can Reliant merge my pull requests automatically?
Not today. No Autopilot workflow merges or approves, and the GitHub integration has no merge action, so your branch protection, required checks and approvals decide what merges and a person merges it. A built-in workflow that merges a reviewed pull request only after deterministic checks pass is coming.
How is this different from other AI code review tools?
Review is one step of a loop. An agent can also fix what review finds and answer each thread, and in a Forge project deterministic checks know your RPCs, schema and migrations. You choose the model for each step, and the reviewer defaults to a different model tag from the one that wrote the code.
Does it work on any repository?
Any GitHub repository the Reliant GitHub App is installed on, in any language. PR review needs no machine. For languages other than Go, set the fast-check command the issue worker and review responder run before they push.
What does it cost?
Each review and each fix is model usage on your account. Turn caps, review rounds and opt-in labels set the ceiling, and every finished run shows each model call’s cost.
Keep reading
Related.
- Start a new app
A production-shaped app from the first commit, deployed by your agent.
- Bring an existing app
Any language, any repo: environments, releases and monitoring without a rewrite.
- Turn alerts into fixes
An alert becomes an investigated issue; once a person approves, an agent opens the fix.
- Agents & Workflows
Multi-agent workflows in YAML, Autopilot and triggers, on any model.
- Forge
The open-source framework: codegen, checks, environments and releases.
- Why Reliant
One platform that knows every seam, so your agents can too.
- All features
Every capability by stage of the lifecycle, each with its status.
Put a reviewer on every pull request.
Turn on Autopilot in Reliant, one workflow at a time.