---
title: "LaunchDarkly Release Autopilot: How AI Agents Manage Flags"
url: "https://goremy.ai/blog/articles/launchdarkly-release-autopilot-ai-agents-feature-flags"
author: Luis Chavez-Mattos
editor: Luis Chavez-Mattos
editor_title: Director, Product
published: "2026-11-17T21:20:09.352Z"
updated: "2026-11-17T21:20:09.352Z"
topic: Coding and DevOps with AI
description: "Agents classify risk, add feature flags, run canary releases and clean up flags in LaunchDarkly's Release Autopilot, with human approval on the pull request."
---

# LaunchDarkly Release Autopilot: How AI Agents Manage Flags

> Agents classify risk, add feature flags, run canary releases and clean up flags in LaunchDarkly's Release Autopilot, with human approval on the pull request.

Edited by Luis Chavez-Mattos, Director, Product · Published 2026-11-17

## What is LaunchDarkly Release Autopilot?

Release Autopilot is a LaunchDarkly feature that lets AI agents handle the feature flag work around a code change. A feature flag is a switch in the code that controls who sees a change. The agent works out how risky a change is, proposes a flag on the pull request, sets up success metrics, and plans a gradual rollout that starts with a small group of users. A human still has to approve the flag before anything changes. The idea is to let agents merge code quickly without sending every change to all users at once.

## TL;DR

- **Passing tests is not the same as working in production.** Tests and code reviews tell you a change looks right, not how it behaves with real users.
- **Feature flags have been the standard fix for years**, but a person had to add each flag by hand, so many teams never did it consistently.
- **Agents opening pull requests at scale break that manual habit.** Nobody can hand-flag every change when software is writing the changes.
- **Release Autopilot covers five jobs:** risk classification, success metrics, a canary release plan, feature-level observability, and flag cleanup.
- **A human approves the flag on the pull request.** Nothing changes until someone says yes.
- **The goal is not to trust the agent more.** It is to check each change on a small group of real users before everyone gets it.

*Note: the main demonstration of this feature came from a sponsored video, so treat the description below as what the vendor says it does, not as an independent test.*

## Why do tests and reviews leave a gap before production?

Many teams now run agents that write code, open pull requests, review each other's work and merge. Some builders stop that pipeline at a staging environment (a private copy of the app) so a person can look things over before it goes live.

That caution makes sense. Automated tests and agent code reviews answer one question: does this code look right? They cannot tell you what happens when thousands of real people use it. A change can pass every check and still slow a page down, break a checkout flow for one browser, or confuse customers.

You only learn those things in production. So the gap is this: everything before production is a guess about the real world, and the real world is where the damage happens.

## What is a feature flag, and why does it close that gap?

A feature flag wraps a change in a condition. If the flag is on for a user, they get the new behavior. If it is off, they get the old one.

That gives you three things:

1. **A small first audience.** Release the change to 1% of users, or to internal staff, before anyone else.
2. **Time to watch.** You can compare the new behavior against the old one using real traffic.
3. **An instant off switch.** If something goes wrong, you turn the flag off. You do not need to redeploy or roll back code.

Teams have known this for years. The problem is labor. An engineer has to decide a change needs a flag, write the flag into the code, choose who sees it first, and remember to remove it later. Under deadline pressure, many teams skip it for all but the biggest changes.

## Why does this matter more when agents write the code?

When people write a few pull requests a day, a manual flagging habit is annoying but possible. When agents open pull requests at massive scale, it stops being possible. There is no engineer with enough hours to add flags to every change.

So teams face a bad choice. Either they slow the agents down so humans can review everything, or they let changes go to production with only test results behind them. Release Autopilot is LaunchDarkly's attempt at a third option: have an agent do the flag work too, and keep a human approval in the loop.

## How does Release Autopilot work step by step?

LaunchDarkly describes a sequence of five steps.

### 1. Risk classification

The system works out how risky a change is and whether it should be wrapped in a feature flag. A copy tweak on a settings page and a change to payment logic should not get the same treatment. Classifying risk first means the flag effort goes where it matters.

### 2. Success metrics

Next, it sets up how the change should perform in production. This is the step people often skip by hand. Without a defined measure (for example, error rates or a key user action), you cannot tell whether a rollout is going well. Deciding the measures up front gives the later steps something to check against.

### 3. An automatic release plan with a canary release

A canary release sends a change to a small subset of users first. The name comes from the canary in a coal mine: a small early warning. Release Autopilot builds a plan that starts there and only expands to more users as long as the change stays within its guardrails. A guardrail is a limit you set in advance, such as "error rates must not rise above this level." If the change stays inside the limits, the rollout grows. If it does not, it stops growing.

### 4. Feature-level observability

Observability means being able to see what your software is doing in production. Here, each change is checked against live production signals at the level of the individual feature, not just the whole app. That matters because a problem caused by one change can disappear into overall averages. Watching the feature itself makes it easier to tie a problem to its cause.

### 5. Flag cleanup

Flags that stay in the code forever become clutter. Old flags make code harder to read and can hide forgotten branches of logic. Release Autopilot also assesses and cleans up flags in your codebase once they have done their job.

## Does a human still approve anything?

Yes. The flag is proposed directly on the pull request, and nothing actually changes until someone approves it.

This is the key design choice. The agent does the tedious part: spotting that a change is risky, drafting the flag, and planning the rollout. A person looks at the proposal in the same place they already review code, and says yes or no.

The approach avoids asking you to trust the agent more. The safety comes from the rollout itself. Each change proves itself on a small group of real users before it reaches everyone.

## How is this different from stopping at staging?

| | Staging-only workflow | Flag-based canary workflow |
|---|---|---|
| Where a human checks | Before production, in a copy of the app | On the pull request, then in live rollout signals |
| What you learn | Whether the change looks right | How it performs with real users |
| If something breaks | You find out after it ships to everyone | The affected group is small, and the flag turns it off |
| Effort per change | A person reviews everything | The agent proposes, a person approves |

Staging is still useful. It catches obvious problems cheaply. But it cannot tell you how real users react, and the canary approach is built to answer exactly that.

## What does this mean for you?

**If you are an engineer or engineering manager:** ask how many of your recent changes shipped behind a flag. If the honest answer is "only the big ones," that is the gap agents will widen. Decide which categories of change must always have a gradual rollout, and write down the guardrails before you automate anything.

**If you work in product, operations or support:** you are the people who feel a bad release first. Ask your engineering team three questions. Who sees a change first? What would make a rollout stop? How fast can it be switched off? Clear answers mean fewer surprises.

**If you are not technical at all:** the takeaway is the pattern, not the tool. Whenever software (or a person) makes changes faster than you can inspect them, the safe move is to release to a small group first, define "going badly" in advance, and keep an off switch.

**If you are evaluating tools:** because the main demonstration of Release Autopilot was sponsored, ask LaunchDarkly or your own team for a trial against a real repository. Check how risk is classified, how flags are removed, and what a rejected proposal looks like.

## Could you build a rollout tracker for your own team?

Not every team needs a feature-flag platform, but many need a clear record of what is rolling out, to whom, and who approved it. With [Remy](https://goremy.ai), you can describe an internal change-approval tracker in plain English: a request form, an owner and risk level for each change, a rollout stage field, a sign-off step, and a dashboard showing what is live. Remy builds and deploys it as a full-stack app with sign-in and a database, so you are not stretching a spreadsheet across several teams. It would sit beside your release tooling, not replace it.

## Frequently Asked Questions

### What is a canary release?

A canary release sends a new change to a small group of users before everyone else. You watch how it performs, and you expand only if it behaves well. If it does not, you stop or switch it off, and few people are affected.

### Does Release Autopilot let agents ship to production without approval?

No. According to the source material, the flag is proposed on the pull request and nothing changes until someone approves it. The agent handles the flag work, and a human makes the call.

### Why not just rely on automated tests?

Tests check that code behaves as expected in controlled conditions. They cannot fully predict how real users, real data and real traffic will interact with a change. A gradual rollout checks the change where it actually matters.

### Why does flag cleanup matter?

Flags are meant to be temporary for most changes. If they stay in the code after the rollout finishes, they add clutter and old logic paths that people have to read around. Cleaning them up keeps the codebase understandable.

### Do small teams need this?

The practice matters at any size: release small, measure, keep an off switch. Whether you need an automated agent workflow depends on how many changes you ship and how often agents open pull requests for you.
