Skip to main content

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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
  7. 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.

  8. 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
the Autopilot loopFrom the docs ↗
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 merges

Who 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 features
  • Security review

    Findings grouped by severity, each with path and line, evidence, an exploit sketch and a fix. It runs nothing against live systems.

    Autopilot guide
  • Fixes for review comments

    The responder pushes to the PR’s own branch only, after your fast checks pass, and replies in each thread.

    Autopilot guide
  • Deterministic gates

    Forge’s lint, generated-code drift, migration safety and real-Postgres tests, with the same verdict locally and in CI.

    Test features
  • Multi-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 overview
  • Workflows 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 workflows
  • A 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 integration
  • Guardrails 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.

Autopilot guide ↗