Hub / Guides / Release gates

Human-in-the-loop governance

Release gates for agents

Yes. An agent change ships when a reviewer records PASS against a brief written first and the floor checks are true. The outcome is a receipt, not the author's claim that the work is done. You get it by setting the gate list, posting the review on the pull request, and handing off the brief with a resume signal.

Why do agent releases slip through?

The agent that wrote the change is the voice that calls it done. Continuous integration goes green. Someone types an approval in chat. The merge lands. A wording nit starts a second review round. A security change gets the same glance as a comment edit. The public channel hears that it shipped because the build went green.

Release gates for agents exist so the eval is outside the author. The acceptance was written earlier. The reviewer scores the diff against it. The receipt is a recorded verdict or a live proof, and chat is neither.

What has to be true before an agent change ships?

Done is a receipt

A live URL, a package-registry view, a release URL, or a reviewer PASS recorded on the pull request. Green continuous integration is the first gate. It is the floor, not the receipt. The brief's acceptance lines are the eval. Code review checks the diff against that brief, so write the brief before code. Ownership and policy for the fleet sit on the agentic control plane.

The floor, and what you add

Every merge needs green checks and docs that match the change. Add install proof when a package has to install on the machines where people actually run it. That install proof runs on the human owner's machine, because the role machines do not carry every environment. Add live proof when you publish: a fresh install and an upgrade. A tag pushed by itself is not live proof. The implementer sets this list on the brief. The reviewer may raise it and may not lower it. The list locks when review starts.

How deep the review is

Light and normal review still need the reviewer's pass and green checks before merge. The strict tier is reserved for a change that ships, touches production, security, or identity. Documentation copy uses the normal tier. A doc-only edit skips tests and CI when no code, test, or generated output depends on those docs. The first review lists every blocker and labels each finding as a blocker, a nit, or unverified. A re-review checks the blockers. Nits do not open a new round.

The reviewer writes PASS or FIX and posts it as a review on the pull request, as the role, not as a personal account. A chat sentence is not that review. A hotfix is the exception that merges on green checks, with the review after, and it does not merge before the checks are green. A few-line production fix can be deployed by the shipping role once tests are green. Anything larger is a cloud run, covered in model spend.

A must-fix finding is for wrong live behavior, for security, spend, or payment risk, or for a procedure line that would send the next role the wrong way. Wording and nits are an approval plus a later linked ticket.

Advance request and handoff

An advance request asks the implementer to open or move the work the ticket already names. On a cluster of same-path tickets, the accountable person asks this way and does not open the pull request. The person who does the work opens it. The advance request is not the brief, not the handoff, and not a public post. The handoff is still the brief plus a resume signal on that ticket. Public language is a different lane, in the build versus go-to-market guide.

We call the strict review tier Strict, and the advance request a tip. Both are in the glossary.

How do you run a release gate?

  1. Write acceptance on the brief before any code. Scope, files, docs touched, tests, and what is out of scope. Get a pass on that brief, then implement against it.
  2. Set the gate list. Green checks and matching docs on every merge. Add install proof and live proof when the scope needs them.
  3. Pick the review tier from the scope. Use the strict tier for ship, production, security, or identity. Use the normal tier for doc copy. Light or normal still needs green checks before merge.
  4. Record PASS or FIX on the pull request. List blockers once. Re-review those blockers only.
  5. Merge on that recorded pass plus the floor. A hotfix merges on green checks and is reviewed after. It does not merge on a red build.
  6. Call it done only when the receipt exists. If another role owes the next cut, deliver the brief and the resume signal together.

Where do release gates fail?

How do you request a consult?

Bring the queue you have, the role list, and what should ship next week. A consult maps the gaps and the first gate.

Request a consult

What else do operators ask?

What is a release gate for an agent change?

A release gate is a check that has to be true before merge or publish. On every merge, continuous integration is green and the docs match the change. Heavier changes add install proof and a live proof after publish.

What counts as done?

A receipt: a live URL, a package registry view, a release URL, or a reviewer PASS recorded on the pull request. A green build is the first gate, not the receipt.

When is the review strict?

Use the strict tier when the change ships, touches production, security, or identity. Ordinary code review can be lighter. Documentation copy uses the normal tier. The reviewer writes PASS or FIX and posts it as a review on the pull request.

What should we hand the next role?

The brief and a resume signal that point at the same ticket. The next owner is named on the brief. A room message does not complete the handoff.

Who records the ship decision?

The implementer writes the change. A different role records PASS or FIX as a review on the pull request. A sentence in chat is not that record.