Your coding agents can open a pull request in minutes. Getting that change in front of customers safely still takes a team of humans babysitting it all the way to production.
The companies closing that gap fastest are doing it with feature flags. Frontier teams already put agent-written changes behind flags so each one can be measured, released progressively, and rolled back the moment it regresses. Flags have become a critical safety layer for agent delivery, and we expect the rest of the industry to move in that direction over the next couple of years.
Using flags as a safety mechanism comes with its own cost, though. The more changes your agents ship, the more flags you need, and each one still requires a person to create it, watch its release, and clean it up afterward. At agent speed, that work has to be automated, or the safety layer becomes a new bottleneck.
With Release Autopilot, now generally available, you can take that work off your team’s plate. Based on your configuration, Release Autopilot decides whether a change needs a feature flag, creates or reuses the right flag, picks a release plan that fits the change, runs the release, rolls it back if production evidence says something is wrong, and opens a pull request to remove the flag when the work is done.
Your team decides what a good release looks like. Release Autopilot helps make sure it happens that way every time.
Flags are what make speed safe
The Claude Code team at Anthropic recently shared how they review code at agent scale, and one thing in particular stood out to us here at LaunchDarkly: Feature flags are an explicit part of the architecture that lets them move quickly without assuming every change will be safe.
New behavior typically ships behind a flag to Anthropic employees first. Low-risk changes can merge without mandatory human approval once the automated checks pass, and if something still manages to break, "flags turn off without a deploy." We agree with this as a best-in-class approach, but as our CPO Jonathan Nolen wrote in his recent post, doing all of that by hand doesn't hold up at agent volume. That’s why most changes never get a flag at all. Release Autopilot changes the economics of feature flags and makes the full release treatment easy to apply to every change that needs it, so rigor no longer depends on someone having time to set it up.

How Release Autopilot works
Release Autopilot brings five capabilities together across one release lifecycle: a change classifier, auto-flagging, release plans, guarded releases, and auto-cleanup. You can adopt them one at a time or connect all five, and they work the same way whether a change was written by a person, an agent, or both.
Step 1: Classify the change
When a pull request opens, Release Autopilot reads the diff, your repository's guidance, and the flags you already have in LaunchDarkly. The classifier works through the decision as a series of discrete questions, which means every answer can be measured, evaluated, and improved over time.
It then posts a clear recommendation on the pull request to do one of four things:
- Create a new flag.
- Reuse an existing flag.
- Leave the change as is because it’s already flagged.
- Ship it without a flag because adding one wouldn’t provide useful control.
The goal isn’t to maximize how many flags you create. The goal is to flag every change where a flag would meaningfully reduce risk, while letting changes that don’t benefit from one continue moving quickly. Every organization releases software a little differently, so you can also tune the classifier to reflect your own policies, risk tolerance, and release practices.

Step 2: Flag the change
Once you approve a recommendation that calls for a flag, auto-flagging takes care of the work someone would otherwise do by hand. It creates the flag in LaunchDarkly, or reuses the one the classifier pointed to. Then it pushes a commit to the pull request that wraps the new behavior in that flag.
Nothing gets flagged without your sign-off. Auto-flagging asks for approval first, and the commit lands on the same pull request your team is already reviewing, so the flag is reviewed right alongside the code it controls.
If the classifier recommends leaving the change as is or shipping it without a flag, auto-flagging stays out of the way and the change keeps moving.
Step 3: Start the release when the code lands
You get to continue merging and deploying the way you already do, while Release Autopilot waits until the change is actually live in an environment before starting that environment’s plan. Nobody has to watch the pipeline and manually kick off each release at exactly the right moment.
For changes moving through several environments, Release Autopilot keeps the entire plan coordinated so each environment starts only when it’s ready and the preceding steps are complete. If a deployment is delayed, or a release is paused, retried, or rolled back, the plan remembers exactly where it was, which means nobody has to reconstruct the release afterward from pipeline logs, dashboards, and Slack messages.
Step 4: Let production evidence guide the release
A minor bug fix and a new checkout flow need different treatment, so Release Autopilot supports three release strategies that let you match the release process to the actual risk of the change:
- An instant release turns the change on for everyone at once.
- A progressive release ramps the change through predefined traffic stages over time.
- A guarded release treats each stage as an experiment, comparing customers who receive the change against a control group to uncover any regressions.
During a guarded release, LaunchDarkly checks your guardrail metrics at every stage. If they remain healthy, the release continues moving forward; if one regresses, LaunchDarkly can roll the change back automatically before the problem reaches more customers.
Because the change classifier knows what kind of change it's looking at, it can match the release plan to the risk. A low-risk bug fix can ship immediately, while a high-impact change can move carefully through internal audiences, limited traffic, and a guarded release.
Those strategies live in your environment release plans, so you define your release patterns once and every change is designed to follow them consistently. That remains true whether the change came from your most senior engineer or from an agent working at 2 AM, because every change gets the amount of control it needs without creating unnecessary work for the team.

Step 5: Clean up the flag
A flag that sticks around forever becomes technical debt, so Release Autopilot makes cleanup part of the release lifecycle.
It uses flag lifecycle settings and evaluation signals to identify flags that are ready to come out of the code. Before touching anything, it runs safety checks across the relevant environments and confirms which behavior must be preserved, so removing the flag doesn’t accidentally change what your downstream customers receive.
Release Autopilot then removes the flag check and the dead code path while preserving whatever behavior production is serving today. The cleanup arrives as a pull request, giving your team a review point and leaving a clean audit trail behind.
Teams like Ramp are already building their software factory with LaunchDarkly to ship changes at a scale traditional workflows were never designed to support.
We’ve thought about individual pieces of this, but to have the whole flow from LaunchDarkly is going to let us make sure we’re not spending time on toil, and that things aren’t falling through the cracks.
Start where you are
Release Autopilot meets your team where its release habits are today and guides it toward best practice. As you're ready to hand over more of the work, it takes that on, too. A human-led team can use classification to flag changes more consistently, release plans to standardize how changes ship, or automated cleanup to pay down flag debt that has accumulated over time.
As your agent adoption grows, those same capabilities become the release infrastructure for your factory. The policies, plans, and safety mechanisms don’t have to be reinvented when the volume increases; they simply take on more of the work.
Closing the control gap
As agents take on more of the work involved in creating software, the controls around releasing that software have to keep up. Adding another manual approval to every step won’t get us there, because human attention can’t scale at the same rate as agent-generated code.
What will get us there is turning good release judgment into policies, plans, signals, and safety mechanisms that can run at the same speed as the changes they govern. Human judgment remains essential, but it should be spent defining how releases work and stepping in when something genuinely requires it, instead of repeatedly setting up flags, watching dashboards, and cleaning up afterward.
Release Autopilot helps human-led teams use flags more consistently, gives AI-assisted teams a safer path to production, and provides software factories with the measurement and control they need to become more autonomous over time.
Your agents are already writing the code. Now your releases can run themselves.
Get started with Release Autopilot.





