An agent that fixes CI, answers review comments and keeps each pull request fresh, then hands one reviewer the evidence to approve.
Free, and writes nothing to code until you turn the dial. Observe runs today on GitHub.com; fixing CI and answering review comments come with Act, which is built and not yet verified, and so are GitLab and Bitbucket Cloud. Another host? Join the waitlist. What runs today
policystored in MergeReady# every repo starts at observe version: 1 default: level: observe authors: agent: { detect: [claude-code, codex, cursor] } human-trusted: { members: [priya-k, amit-s] } paths: - name: protected match: [".github/**", "**/*.lock"] protected: true # never edited - name: sensitive match: ["src/auth/**", "src/billing/**"] level: propose # you apply - name: source match: ["src/**", "tests/**"] authors: [agent, human-trusted] level: act # verified fixes - name: docs match: ["docs/**", "**/*.md"] level: approve approve: { veto_window: 24h, max_risk: low }
Agentic PRs wait for their first review: 17.6 hours at P75, against 3.4 for people. LinearB 2026 Benchmarks, 8.1M PRs
Median time in review grew fivefold as teams adopted AI coding tools. Faros AI, Q2 2026
Share of AI-generated PRs merged within 30 days, against 84.4% of manual PRs. LinearB 2026 Benchmarks
Of 600 rejected agent PRs studied by Ehsani et al. at MSR 2026, this share was abandoned before anyone reviewed it. Another 17% failed on CI.
Main-branch CI success, the lowest in five years. The typical team needs 72 minutes to get back to green. CircleCI 2026 State of Software Delivery
“The cost to create has dropped but the cost to review has not.”
CI sees a red run. Review bots see a diff. Reviewers see a notification, and the merge queue sees the end. Between them, someone stitches the pieces together by hand, or nobody does and the PR sits.
A red run, four bot comments, an open thread and a base branch that moved, each in a different tool.
One agent holds the whole PR. It reads the run, answers the thread, rebases, and stops to ask when it should. Answering threads and rebasing are built and not yet verified.
One comment and one check, and one named reviewer with a pack they can approve in minutes.
What MergeReady knows about a PR lives in one comment on the PR, edited in place as the work happens. It never posts a second pack; a question gets a comment of its own only when a person must decide.
Running 38 affected tests before CI.
Within a minute: size and risk. Duplicates, the linked issue’s criteria and the PRs it collides with come in the same pack, and are not yet verified on live PRs.
CI running on b77d013; ETA 14 min.
mr-payments-apiAt Act, red runs are classified first, and the classes your policy allows are fixed, verified on the full suite and committed through your host. Act is built and not yet verified.
Ready for review. Nothing is waiting on the author.
.github/workflows/ci.yml: protected path (rule 1)source, level actApprove on GitHubOpen the diff since my last look
One reviewer is asked by name and reads what changed since their last look. Merging stays theirs. Reconciling other bots is built and not yet verified.
How far MergeReady may go is set in the policy, per path and per author. It is stored in MergeReady, not in your repository, so no pull request can change it, and only an owner or admin does, on the app's Policy page. Try the switches below.
Run the affected tests before CI.
On PR #412, 38 tests in 41 seconds found both failures before CI did.
Fix formatting, lint and test failures.
At Act it commits verified fixes; at Propose it opens a stacked PR for a person to apply. Flaky tests are quarantined, never edited.
Resolve the threads it answers.
At Act it makes the change a clear comment asks for, replies and asks the reviewer again. Switched on, it also resolves the thread; off, the reviewer does.
Cancel the runs its own push replaced.
On PR #412, run 1187 was cancelled and 11 CI minutes saved. A push by a person cancels nothing.
Approve docs-only PRs after a veto window.
Only with your org’s allowance, a 24-hour veto window and a kill switch. It never approves a PR it pushed to, and merging stays yours.
This is the policy as MergeReady stores it, and as an owner or admin saves it.
Each switch above writes the keys highlighted on the right. Rules are matched per changed file, most specific first, and a PR runs at the lowest level any of its files allows. Every key is valid today; which behaviour behind them is verified is on What runs today.
The policy’s JSON Schema, every key with its default
policy4 of 5 switched onversion: 1 default: level: observe attempts_per_pr: 3 spend_cap_usd: 5 authors: # the classes a rule names agent: detect: [claude-code, codex, cursor, copilot] human-trusted: members: [priya-k, amit-s] paths: - name: protected match: [".github/**", "**/*.lock"] protected: true - name: sensitive match: ["src/auth/**", "src/billing/**"] level: propose - name: source match: ["src/**", "tests/**"] authors: [agent, human-trusted] level: act - name: docs match: ["docs/**", "**/*.md"] level: act ci: preflight: true cancel_superseded_runs: true fixes: classes: formatting: fix lint: fix test: fix flake: quarantine # never edited review: resolve_threads_when_addressed: true ask_on_ambiguity: true
| Approve or merge a PR | Off by default. Turning either on takes your org’s allowance, a veto window and a kill switch; Merge also needs a spend cap. Both are built and not yet verified. |
|---|---|
| Approve a PR it pushed commits to | Never, at any level. |
| Guess what an ambiguous comment means | It stops, asks one person with options, and waits for the answer. |
| Edit a flaky test | Never, at any level: the test stays as it is. Quarantining and rerunning flakes is built and not yet verified. |
| Edit CI files, CODEOWNERS or agent config | The built-in protected set. Your policy can add to it and never remove from it. |
| Read its rules from the PR branch | The policy is kept in MergeReady, not in the repository, and agent config comes from the default branch, so a PR cannot rewrite its own rules. |
| Commit tests to the author’s branch | Missing tests arrive as a stacked PR for a person to apply. |
| Act above Propose on a fork or a first-time contribution | Forks get suggested patches only. First-time contributions, and any PR that changes agent config, get stacked PRs or suggested patches at most. |
| Write review comments of its own | Your people and bots review. It acts on what they say and reports what it ignored, with reasons. |
| Reply where a comment can trigger infrastructure | Replies are muted in repos that run Atlantis or Terraform Cloud from comments. |
| Model calls past a PR’s cap | When a PR’s spend reaches its cap with attempts left, its new model calls stop, and it asks you to raise the cap or hands the PR back. A step already under way is priced when it ends. |
Each PR gets its own virtual machine. Host tokens, model keys and secrets stay outside it, and so does the commit.
Host tokens live only in a credential proxy. When a fix passes the full suite, a deterministic gate checks the diff for secrets, protected paths and new dependencies, and a model from a different family checks it against the plan. Only then does the proxy ask your host to create the commit from that exact tree, so GitHub signs it. The proxy checks that the host’s commit has the same tree as the sandbox’s, and the audit log records both commit SHAs. A merge commit from a resolved conflict, or a rare diff the host’s API cannot take, leaves through a one-time push credential that exists for that single push, and the pack says so.
CI logs are fetched and distilled outside the sandbox, so a raw log never reaches a frontier model. Outbound traffic from the sandbox is routed to the proxy, which allows your repo’s registries and lists anything it blocked in the pack. Until the sandbox provider enforces network rules itself, that routing is a second line behind holding no credentials.
| Permission | Access | Used for |
|---|---|---|
| Metadata | Read | Finding the repositories |
| Pull requests | Read and write | The pack comment, reviewer requests, labels |
| Checks | Write | The Merge readiness check |
| Contents | Read and write | Reading code; commits only where your policy allows |
| Actions | Read and write | Logs; reruns and stopping superseded runs, only where your policy allows |
| Issues | Read and write | The issue a PR links to, labels |
| Members | Read | CODEOWNERS teams |
| Deployments | Read | A merge’s deployments |
| Merge queues | Read | When a PR enters and leaves the merge queue |
| Email addresses, for sign-in | Read | Signing you in with GitHub, and whether your address is verified |
| Workflows | Never | |
| Administration and secrets | Never |
Ready for review. Nothing is waiting on the author.
#409 needs you. Mei asked to “move validation to the service layer”, which reads two ways.
CardService; 4 files, thin controllersReady for review.
$ mergeready run 412 --apply --until ready ▸ Policy rule source · level act · 3 attempts · $5.00 cap policy: server (repository revision 5) ▸ Triage +212 −38 · risk medium · no duplicates ▸ Preflight 38 affected tests · 41 s · 2 failed ▸ Fix attempt 1/3 · full suite 142 passed push a41c9e2, b77d013 ▸ CI green ▸ Pack reviewer priya-k · state ready ✓ Done in 19 m 04 s · $0.84 · attempts 1/3
> check my change before I open the PR ⟶ mergeready_preflight(repo, baseRef: "main", diff) ⟵ tests: 14 selected, 1 failed (test_refund_limit) changedLineCoverage: null unavailable: coverage, duplicates, intent map > fix the failure, then open the PR ⟶ mergeready_status(#436, waitFor: "ready") ⟵ ready: Nothing is waiting on the author.
One pack comment per PR, edited in place, and one Merge readiness check. The check never fails a PR on the agent’s opinion.
It recognises an agent by its bot login, a co-author trailer or a branch prefix. When it cannot tell, it treats the author as a person. This is built and not yet verified on a live agent’s PR.
At Act, the review bots you already run are reconciled: duplicate findings are merged, findings below your severity floor are listed as ignored with the reason, and the rest are acted on. On a PR Devin wrote, Devin Review’s findings go to a person instead. This is built and not yet verified.
$343a week
120 PRs × $2.86: the $2 beta price, plus $0.86 of model spend on your own keys, the midpoint of our cost model’s $0.40 to $1.32 for a typical agent PR. That range includes the sandbox, which the $2 covers, so the figure errs high. A PR’s cap, $5 unless you set another, stops its new model calls; a step under way is priced when it ends. During the beta, nothing is invoiced.
The range is MergeReady’s cost model, sections 2 and 5, which is not yet published.
Start free on every repo. Pay per PR once it does more than observe on it. During the beta, nothing is invoiced.
For every repo, from the first day.
Triage, the evidence pack, the Merge readiness check and one named reviewer. Pre-flight’s affected tests, duplicate detection, the linked issue’s criteria and nudges run at Observe too, and are not yet verified. It reads and reports, and writes nothing to code.
$0
Free on public repos, always. Free on private repos during the beta.
For teams that want red PRs fixed and threads answered.
Everything in Observe, plus split proposals and proposed tests as stacked PRs, which are verified; and verified fixes for the failure classes you allow, review comments addressed and rebases, which are built and not yet verified. Bring your own model keys and set caps per PR, per repo and per month.
$2
Beta price per PR it works on, from Propose up. Your model provider bills tokens on your own keys.
Every capability, its class and its evidence. The release record, published with the launch decision.
Enterprise. Annual terms; audit export and running it in your own CI or VPC, which are built and not yet verified; and SSO and SCIM, which are planned. Write to us.
Every fix runs the full suite in a clean sandbox before anything is pushed, and a deterministic gate and a second model check the diff first. Your host makes the commit from that exact tree, and the pack lists it as the agent’s.
Act ships only after it clears our first bar: at least 30% of 200 replayed real CI failures fixed, with zero bad pushes. That bar is not yet measured, so Act is not yet verified; the release record will say when it is.
It is one App, installed once, and it asks for contents and actions write when you install it, with everything else it needs. It uses them only where your policy sets a path to Propose or above, and only an owner or admin changes the policy, in MergeReady. Every repository starts at Observe, where it writes no code: it reads code, keeps one pack comment and one check per PR, adds labels and requests a reviewer.
At Observe it can also close an agent’s PR: a duplicate after a notice, if your policy turns that on and once the duplicate detector has cleared its precision bar (no deployment closes a duplicate today: the precision is not yet measured), or, by default, one left 14 days waiting on an answer or a review. Closing is built and not yet verified. It never asks for workflows, administration or secrets.
Only if your org turns that on. Approve and Merge ship off, and both are built and not yet verified. Enabling either takes an org-level allowance, a veto window and a kill switch, and Merge also needs a spend cap. It never approves a PR it pushed commits to.
Any author: Claude Code, Codex, Cursor, Copilot, Devin, Jules, OpenHands or a person. The beta runs on GitHub.com. GitLab (GitLab.com or a self-managed instance), Bitbucket Cloud and, on the self-hosted control plane, GitHub Enterprise Server in observe are built and not yet verified: each is offered once it passes its live check.
It writes no review comments of its own. It acts on the ones your people and bots leave, merges duplicates across bots, and lists what it ignored and why. What you get is a PR that is green and answered, plus one comment that explains it. Acting on comments comes with Act, and is built and not yet verified.
From Propose up they are recorded, tracked in a quarantine issue and rerun; this is built and not yet verified. The agent never edits a flaky test, and never skips, disables or deletes a test.
It stops. One person gets a question with the options and the trade-offs of each, and the PR waits until they answer or say they will handle it themselves.
In three ways, each built and not yet verified. The CLI runs the same agent on your machine with your own model keys, inside the repo’s policy; it is not yet published. It runs inside your own CI as a read-only job and an apply job, so credentials never leave your runner. And a self-hosted control plane runs in your VPC.
Observe is free: on public repos always, and on private repos during the beta. From Propose up, the beta price is $2 per PR it works on, counted once, in the month it first proposes a change, attempts one, pushes, asks you about that work, approves or enqueues the PR. A PR it only observes is free. The $2 covers the sandbox.
Model tokens are billed by your own provider, on your own keys: MergeReady never resells them. Our cost model puts a typical agent PR at $0.40 to $1.32 of model and sandbox spend together, and caps per PR, per repo and per month stop new work when they are reached; a step already under way is priced when it ends. Running it in your own CI or VPC, built and not yet verified, and enterprise terms are by arrangement. During the beta, nothing is invoiced.
Opens setup with that repository chosen, or with the install to put MergeReady on it first. It starts reading and reporting on the next PR, and writes nothing to code until an owner or admin raises a path in MergeReady.