Merged Is Not Released

Merging code and exposing it to users are two decisions, and a first release path should be deterministic automation plus two human approvals.

Rick Hightower

Cover image for “Merged Is Not Released” by Rick Hightower

Keep merge and release as separate decisions. The release path can be boring automation plus two human approvals, and it may need no agent at all.

Landing the pull request feels like the finish, and customers still cannot see the change. The moment that counts is a second, deliberate decision to expose a known version.

In this article: Merged, deployed, and released are different states. Only the last means people can use the change. The path uses two human approvals, agents that draft but never promote, and a record the pipeline writes.

Stages that write or review code put an agent in the middle. Release can run on deterministic automation plus authorized people, with no model making a decision.

Running without an agent is not timidity. A named person has already approved planned, built, tested, and independently reviewed work. What remains is auditable promotion of a known artifact, which pipelines do reliably and agents do not.

A factory that merges ten times as many changes needs a boring release path. It is the safety net under every other stage's speed.

Agree on the word first

Ask product and engineering, before any automation: when a feature is released, what is true?

Engineering often means merged to main, or deployed to production. Product means customers can use it. Sales may mean a demo is possible. A faster factory leaves more changes in each of those four gaps.

"Released," "in production," and "GA" should mean one thing: people can use it now. Merged means merged. A deploy behind a disabled flag means deployed. Neither is released.

Merged, deployed behind a disabled flag, and released are different. Released means people can use it now.

Benefit checks and incident reviews both need to know what customers could use. Agree on the word before you automate.

Two human approvals

Table: Part, Release. Rows: Trigger; Work; Independent check; Memory; Stop condition.

Release's loop has five parts. The Part column names each part, and the Release column says what that part is for this stage.

  • Trigger. Release runs when reviewed changes are ready for release checks.
  • Work. It tags, builds artifacts, burns in outside production, promotes, rolls out, and watches health.
  • Independent check. A production authorizer approves the version, environment, and rollout scope.
  • Memory. It recalls past failures, rollback notes, and why a release was held.
  • Stop condition. It ends with an authorized release, a hold, or a recovery decision.

Shrinks for the human: writing change records and notes by hand. Grows for the human: the production approval, and one shared definition of released.

Merging code and exposing behavior are separate decisions. The engineering maintainer authorizes the merge and tags the release. A production authorizer approves a specific version, environment, and rollout scope. One role may hold both jobs on a small team, but the second decision is still deliberate. The human merge stays.

DORA finds that change approval works best as peer review inside the development platform, not as an external board. Put it in branch protection, environment rules, and named approvers the pipeline checks.

The release path, two human approvals: "Tag", "Same artifact burns in", "Maintainer", "Production authorizer", and "Flag, then exposure".

The path also includes burn-in outside production on the same artifact that will ship, plus infrastructure, configuration, and the compliance record. A new environment variable or permission is part of the release, under the same approval.

A disabled flag splits two risks: whether the deploy breaks something, and whether the feature does. The code can sit in production while no user sees it.

Draft, never decide

Nothing on the path may depend on an agent. Drafting is allowed. Deciding is not.

An agent can draft release notes from merged pull requests and tickets, for people rather than as a commit log, and each release should publish notes and API docs on its own. It can assemble what changed, which approvals and tests it traces to, and the rollback. During rollout it can summarize health. An example of that sentence, not a measurement: error rates steady, latency up 4% on the export endpoint, no new alerts. A person still decides, including on any drafted rollback.

An agent never promotes a build, turns a customer flag on, approves any change record, or holds production credentials.

Drafting covers notes, records, summaries, and rollback proposals. Promotion, customer flags, record approval, and production credentials stay off limits.

Give the pipeline its own identity, and do not let an agent identity trigger a production deploy. OpenAI's "agentic deploy" agents, which shepherd rollouts, fit only very mature release systems and are the wrong start where the law requires segregation of duties.

Gates, flags, and the record

Toll gates are checks every change must pass, whoever wrote it: security scans, coverage thresholds, license checks, pipeline results. Make them fast and identical for every author.

A merge queue sits in front of main because two changes can pass alone and fail together. It rechecks each one against the latest target and whatever is already queued.

Rule tools can require no personal data in logs, encryption at rest on every new store, no agent signature on an audit or a change record, and a data classification on every service that handles customer data. They run before any agent's opinion.

Flags also let an agent-built feature sit merged and burned in for days before anyone exposes it. Turning a flag on for all customers is a release, even when no code moved.

A regulated team will be asked, for a production change, to show the requirement, who approved it, which agent and model version wrote the code, who approved the merge, which tests ran, and who approved the release. Link the agreed need, the ready ticket, the decision to start, the task breakdown, the pull request, the review approval, and the release record by ID.

The pipeline writes the record, not the agent. An agent may draft a change record for a person. It must not write the authoritative account of what it did. Approvals, attestations, and release manifests come from systems the agent cannot write.

Every pull request carries the requirement ID, the risk tier, the agent and model version, and the test evidence, so reverts can be measured by tier. SLSA build provenance extends that chain to the artifact. At its highest source level, SLSA requires two trusted persons to agree to every change on a protected branch.

The EU AI Act requires automatic event logs and effective human oversight for high-risk systems. NIST's generative AI profile asks for provenance such as creator, timestamp, sources, and modifications. One recent critique argues that no major framework yet specifies a runtime record strong enough for a legal finding. A fixed evidence record, written for every generation, check, and approval, closes most of that gap:

Table: Field, What it holds. Rows: Actor; Time and environment; Inputs; Output; Check result; Links.

The evidence record has six fields. The Field column names each one, and the What it holds column says what goes in it.

  • Actor. It names the agent identity or the named person.
  • Time and environment. It records when and where the step ran.
  • Inputs. It holds references to earlier records, not copies.
  • Output. It records the artifact produced, or the claim made.
  • Check result. It records pass or fail, the criteria, and a pointer to the evidence.
  • Links. These are typed links: derived from, checked by, escalated to, and approved by.

The pipeline writes the record. A named person approves it. The agent does not.

No tool found in this research enforces that chain end to end. Wire it with commit trailers, pull request templates, and release manifests. WikiTicket, as one example, already links each ticket to its plan and its pull request. The release that shipped it is one more link.

Start with the boring path

Evidence for agents inside release is weak. OpenAI has described deploy-shepherding agents, but the detailed account is paywalled and unaudited. Anthropic describes staged releases with fast rollback as one layer of review. Nobody has published release outcomes for an agent-driven Release stage an outsider can check.

Merge queues, protected environments, progressive delivery, signed provenance, and change management already work, whoever wrote the code. Swap in GitHub environments and protection rules, merge queues, progressive delivery, SLSA build provenance, and your feature-flag platform.

Do not build a Release agent first. Stand up tags, the same artifact in a non-production environment, a named production approver, and flags for customer-facing work. Then add one drafting job: a GitHub Action on each tag that opens release notes for a person to edit. Measure release cadence and change failure rate from day one.

A fictional workspace export

The export pull request, filter corrected, has already merged under a person. The story is fictional. The maintainer tags. The pipeline builds the artifact and runs it in staging for two days against a copy of the pilot group's workspace structure.

Fictional export: tag, two days on the same artifact, a production authorizer, then a person turns the flag on for the pilot.

A drafting agent writes the change record: the agreed need, two tickets and their dependency, the review finding and the fix, the tests, and a rollback that is turning the flag off. The notes include the export size limit so support is not surprised.

The production authorizer approves production, behind a flag, for the pilot admins only. The pipeline deploys with the flag off. The next morning the app owner turns it on for that group. The flag is the moment the feature is released, and the moment the success measure starts. No agent pressed a button customers could feel.

Do this today

  • Ask product and engineering separately what "released" means, and compare the answers.
  • Keep two decisions: maintainer for the merge and the tag, production authorizer for version, environment, and scope.
  • Burn in the same artifact outside production. Put customer-facing work behind a flag a person turns on.
  • Let the pipeline write the evidence record. Do not give an agent production credentials.
  • Measure release cadence and change failure rate before any deploy agent.

Boring is the safety net

Fast writing needs a dull release: one known artifact, the same bits in burn-in, two named approvals, and a flag a person turns on. Merged is not released, and neither is a disabled flag in production. Released means people can use it now, recorded by the pipeline.

Does your team have one definition of "released"? Ask the two sides separately.


This is Part 8 of "AI Software Factory Series," a 17-part guide to building an AI software factory with human gates.