Agent produces PR → CI passes → merge → deploy → observe

The full autonomous delivery loop - agent produces PR, CI passes, merge, deploy, observe - is the L5 state where code moves from conception to production without any required human action in the happy path. An AI agent receives a task specification, implements it, opens a PR, CI validates the implementation, the merge queue processes it, the CD pipeline deploys it progressively, and the observability system monitors the deployment for regressions. The human role in this loop is: write the specification, observe the outputs, and intervene when automation fails.

This is not a future state - it's the operational mode at organizations like Stripe today. The Minions model implements exactly this loop: senior engineers define tasks as structured specifications, agents implement them, and the resulting changes flow through fully automated pipelines to production. The human is in the loop at the start (specification) and available throughout (monitoring), but doesn't touch the middle (implementation, testing, merging, deploying).

Each step in the loop is a distinct automation problem that must be solved independently. The agent producing a good PR requires: good task specification, codebase context, and iteration capability. CI passing requires: fast, reliable CI with incremental builds and flaky test elimination. Merge requires: policy-based merge rules, merge queue, and auto-merge for approved categories. Deploy requires: automated CD pipeline with progressive rollout. Observe requires: instrumented services, anomaly detection, and trace-to-PR attribution. None of these steps can be skipped or done partially - the chain breaks at any weak link.

The "observe" step is what closes the loop and makes the system self-improving. When observability detects an anomaly post-deployment and traces it to a specific PR and agent session, that data feeds back into the specification quality for future tasks ("agent sessions that lack X context tend to produce Y class of errors"). This feedback loop is what allows autonomous agent workflows to improve in reliability and quality over time rather than degrading.

• The compound effect of full automation - each step that's automated compounds with the others; eliminating human touch at merge and deploy doesn't just speed up those steps, it removes the coordination overhead between steps that accounts for 50-70% of total cycle time
• Enables truly continuous delivery - when the full loop is automated, every completed agent task can be in production within minutes; time-to-production for a bug fix goes from hours (manual process) to 10-15 minutes (automated loop)
• Creates observable AI development - the automated loop generates a complete audit trail: which agent session produced which PR, what CI results it produced, when it merged, when it deployed, what production impact it had; this data is essential for understanding and improving AI development at scale
• Removes the human-as-bottleneck constraint - human developers scale linearly (more developers = more throughput, up to coordination limits); agent loops scale differently (more task specifications = more throughput, limited mainly by infrastructure); the full autonomous loop is the mechanism for this scaling
• Demonstrates organizational maturity - operating the full loop reliably requires every piece of engineering infrastructure to be robust; an organization that can sustain the full loop at scale has world-class delivery infrastructure regardless of AI

1. Map your current loop and identify the first broken link - draw the full loop: specification → agent → PR → CI → merge → deploy → observe. At each step, ask: is this automated? Is it reliable? Where does a human need to intervene? The first step that requires regular human intervention is your blocking constraint.
2. Build the observation infrastructure first - most teams start with automation (agent, CI, merge, deploy) and add observability later. This is backwards for the autonomous loop. Without observability, you can't know whether automated deployments are safe. Build trace-to-PR attribution before enabling automated deployment at scale.
3. Implement the specification-to-PR step with review - even in a fully autonomous loop, the first 30 days of running agent tasks should include human review of every PR. This is how you calibrate agent quality, identify specification gaps, and build confidence in the automation. Shift to selective review only after confirming that agent output quality meets your bar consistently.
4. Enable auto-merge for specific task categories first - don't enable the full autonomous loop for all task types simultaneously. Start with the lowest-risk category (documentation updates, test additions) and expand to feature tasks only after the infrastructure is proven. Each category expansion is a controlled experiment.
5. Define anomaly response procedures - the autonomous loop will produce anomalies: deployments that fail health checks, PRs that break CI repeatedly, agents that produce incorrect outputs. Define who gets notified, what they do, and how they escalate. The loop being autonomous doesn't mean anomalies are ignored - it means the routine cases are handled by automation and the exceptional cases are escalated to humans with full context.
6. Implement loop metrics - measure the full loop performance: specification-to-PR time, CI pass rate (first run), merge queue wait time, deploy time, mean-time-to-detect anomalies. These metrics tell you where the loop is performing well and where it's degrading. Publish them to the team as the primary health indicators for the autonomous delivery system.

Treating the loop as all-or-nothing. Teams hear "autonomous loop" and try to implement all six steps simultaneously. Each step introduces complexity and potential failure modes. The chain approach - implement one step at a time, stabilize it, then add the next - is slower but produces a more reliable system. The full loop is only as reliable as its weakest link.

No rollback in the loop. An autonomous loop without automated rollback is a risk accumulator. Every deployment that auto-deploys without a rollback mechanism is a potential production incident that waits for human detection and manual remediation. Automated rollback (triggered by health check failure) must be implemented before auto-deploy is enabled. The rollback is the safety net that makes autonomous deployment trustworthy.

Specification quality deterioration. In the autonomous loop, specifications are the primary human input. When specifications are vague ("fix the authentication bug") agents produce mediocre PRs that either fail CI repeatedly or introduce subtle regressions that pass CI but fail in production. Specification quality is the leverage point in the autonomous loop that determines output quality. Teams that invest in specification quality (templates, examples, context requirements) get dramatically better autonomous outputs.

Ignoring the feedback loop. The observe step generates data that should improve future specifications and agent prompts. If a category of agent tasks consistently produces a specific class of bug (missing null checks, incorrect error handling, inadequate test coverage), that pattern should be added to the task template as an explicit requirement. Without active feedback from observe to specification, the loop doesn't improve - it just runs the same quality indefinitely.

No human override mechanism. When the autonomous loop malfunctions - a rogue agent producing low-quality PRs, a merge queue jam, a CD pipeline in a bad state - humans need to be able to halt the loop quickly. Implement a "red button": a single action that pauses all auto-merges, stops all automated deployments, and notifies the team. This is the safety mechanism that makes autonomous operation safe to operate in the first place.