Built for the week most of your diffs stopped being written by hand

Agents are authors, and they are reviewers

An agent needs the same things a person does: a personal access token scoped to what it may touch, an identity on the pull request so the history says who wrote what, and a review state it can submit. It gets them. There is no separate second-class path where machine output arrives as a patch file and somebody pastes it in.

The difference is volume. A person opens two pull requests a day and remembers both. An agent opens thirty and remembers none, so the forge has to carry the context that used to live in somebody's head.

Why the review trail matters more, not less

The argument for reviewing machine-written code is not that the machine is worse. It is that nobody holds the intent. When a person writes a change, the reasoning is recoverable by asking them. When an agent writes it, the only record is the review.

So the review is kept as the primary object. A thread is anchored to a path, a line, a side, and the commit it was written against. Rebase the branch, force push it, rewrite the history entirely, and the thread follows the line or marks itself outdated and stays readable. It is never deleted.

• Every approval records the exact commit it approved
• A force push does not silently inherit the previous head's approvals
• An outdated thread stays visible with the code it was written about

Reviewing a stack an agent produced

Agents produce dependent work: a refactor, then the change the refactor enables, then the tests. Sent as one pull request it is unreviewable. Sent as three unrelated ones it is incoherent.

A stack keeps them dependent and reviewable. Each pull request diffs against its parent, so it shows only its own work, and merging the bottom of the stack retargets everything above it automatically rather than leaving children pointed at a branch that has landed.

The controls that make agent output mergeable

Volume only works if the gates are real. Every reason a pull request cannot merge is computed and shown at once, so an agent retrying against a moving target does not need thirty round trips to discover three problems.

• Required approvals, counted against the current head
• Unresolved review threads, when the branch rule asks for it
• Required checks from your existing CI, including the ones that have never reported
• A stacked pull request whose parent has not merged yet

What this does not do

ReviewOS does not run the agents and does not host a model. It is the forge they push to and the place their work is reviewed. Bring whichever agent you already use.