Skip to main content
This topic explains how to install the LaunchDarkly GitHub app, choose the repositories Release Autopilot runs on, and configure how it releases flags. It also explains how to turn off Release Autopilot and uninstall the GitHub app. To set up Release Autopilot, an administrator first installs the GitHub app. In each LaunchDarkly project, a project administrator then turns on capabilities for the project’s repositories. Each developer then connects their GitHub account. The remaining sections cover common configuration tasks that teams generally complete during setup:
  • Using your own AI model key
  • Controlling how releases move between environments
  • Migrating from release policies to release plans
Release Autopilot does not require GitHub. The GitHub app is how Release Autopilot works on pull requests. Without the app, you can classify changes and add flags from your own coding agent with LaunchDarkly agent skills, such as should-flag-change. To learn more, read LaunchDarkly agent skills.

Prerequisites

To set up Release Autopilot, you need:
  • The Release Autopilot add-on for your LaunchDarkly account. Without the add-on, a project’s Automations page shows only the “Inference,” “Your GitHub repositories,” “Your GitHub access,” “Pull request details,” and “Automatic archival” sections.
  • A LaunchDarkly role that allows the updateFactoryRepoSettings action on the project, to turn on auto-flagging and auto-releasing for repositories, and to change the project’s AI provider. To change pull request details, the role must also allow the updateObservabilitySettings action. To turn on automated flag cleanup, it must allow the updateLifecycleSettings action. To learn more, read Role actions.
  • A GitHub organization administrator who can approve the GitHub app installation, if you use the GitHub app.
  • One or more private GitHub repositories, if you use the GitHub app. Release Autopilot does not run in public repositories, even if the GitHub app has access to them.
  • Access to Vega, the LaunchDarkly AI agent, if you use auto-flagging or automated flag cleanup. These capabilities use AI. To get access, accept the LaunchDarkly AI features terms. With an Enterprise plan, you can add your own AI model key instead. With your own key, you do not need to accept the AI features terms. To learn more, read Vega AI providers.
  • A LaunchDarkly role for each developer whose pull requests Release Autopilot works on that allows the talkToVega action. To use auto-releasing, the role must also allow the createAutomatedRolloutConfig action. To learn more, read What Release Autopilot can do on your behalf.
  • A default environment release plan for each environment that Release Autopilot releases flags to, if you use auto-releasing. To learn more, read Set default environment release plans.
  • A default flag release plan for each project, if you use auto-releasing. You create it with the flag release plans API or the LaunchDarkly Model Context Protocol (MCP) server. To learn how, read Configure a flag release plan.
  • To sign the LaunchDarkly Generative AI Terms, if you have not already done so.

Install the GitHub app

To get started, learn how Release Autopilot settings work, then install the GitHub app and turn on Release Autopilot for your repositories.
Agent skill availableIf you use an AI coding agent, you can use the LaunchDarkly launchdarkly-release-autopilot-onboarding agent skill to set up Release Autopilot. It walks you through choosing capabilities, installing the GitHub app, turning on capabilities for repositories, choosing an AI provider, preparing environment release plans, and turning on scheduled flag cleanup and automatic archival. It requires the LaunchDarkly hosted Model Context Protocol (MCP) server.To install the skill, run npx skills add https://github.com/launchdarkly/ai-tooling --skill launchdarkly-release-autopilot-onboarding. Then connect the hosted MCP server. To learn how, read Configure the MCP server.In Claude Code, you can install the LaunchDarkly plugin instead. The plugin includes every LaunchDarkly agent skill and connects the hosted MCP server. To install it, run /plugin marketplace add launchdarkly/ai-tooling, then /plugin install launchdarkly@launchdarkly-ai-tooling.To learn more, read LaunchDarkly agent skills.

Understand Release Autopilot settings

Release Autopilot has three capabilities:
  • Auto-flagging: Proposes a feature flag for new code in a pull request. After a developer approves the plan, Release Autopilot creates the flag and wraps the code.
  • Auto-releasing: Releases the flag automatically, environment by environment, after the pull request merges. It uses the project’s default release plans.
  • Automated flag cleanup: Opens pull requests that remove flags from your code after they are ready for code removal. To learn more, read Auto-cleanup.
Auto-flagging is in betaAuto-flagging is in beta. Aspects of this capability may change without notice. Auto-releasing and automated flag cleanup are generally available. Auto-releasing uses the flag release plans API, which is in beta.
You configure all three capabilities on each project’s Automations settings page. Each project has its own settings, and no setting applies to your whole account. The Automations page has these sections, and each section has its own Save button:
  • Inference: The AI provider that Release Autopilot and Vega use in this project. To learn more, read Use your own AI model key.
  • Your GitHub repositories: The repositories that the GitHub app can access. The list includes public repositories, with a warning that automations work only in private repositories. This section is read-only. To change it, click Manage repository access.
  • Your GitHub access: Whether your own GitHub account is authorized and can access the GitHub app installation. To use a different GitHub account, click Switch GitHub account.
  • Pull request details: The prefix that LaunchDarkly adds to the titles of the pull requests it opens.
  • Auto-flagging, Auto-releasing, and Automated flag cleanup: A switch for the project and a switch for each repository. These sections appear only if your account has the Release Autopilot add-on.
  • Automatic archival: Whether LaunchDarkly archives flags that pass the readiness checks in your lifecycle settings. To learn more, read Auto-cleanup and automatic archival.
Two separate controls decide where these capabilities run:
  • GitHub app access decides which repositories Release Autopilot can read. You choose these repositories in GitHub when you install the app.
  • Repository switches decide which repositories each capability runs on. Release Autopilot never runs a capability on a repository where that capability is off, even if the GitHub app has access to the repository.
The project switch in each capability’s section turns that capability off for every repository in the project. Turning the project switch on shows the repository switches, but does not turn on any repository. When you save a change to a project switch, LaunchDarkly asks you to confirm and shows how many repositories the change affects. This count includes repositories your GitHub account cannot access. Turning off the project switch also turns off the capability in those repositories. A repository works in one project at a time. The first time you turn on a capability for a repository, LaunchDarkly assigns the repository to that project, and Release Autopilot creates its flags there. A project can have many repositories. In a repository with auto-flagging on, Release Autopilot runs automatically on every pull request that is not a draft. It runs when a pull request opens, reopens, or is marked ready for review. To run it on a draft pull request, comment @launchdarkly plan on the pull request. Each capability is off by default. Auto-flagging always asks a developer to approve its plan before it creates a flag.

Install the app

Release Autopilot works through the LaunchDarkly GitHub app, which also powers the Vega GitHub integration. If your organization already installed the app for Vega, click Manage repositories in the procedure below to confirm that the app has access to the repositories where you want Release Autopilot to run. To install the GitHub app:
  1. Click the gear icon in the left sidebar to view Organization settings.
  2. Click Integrations and search for “GitHub App.”
  3. Click Configure on the “GitHub App” integration. The “GitHub App integration” panel appears.
  4. Click Install GitHub App. The “Connect GitHub to LaunchDarkly” page appears and shows your LaunchDarkly account. If you belong to more than one LaunchDarkly account, you can click Switch account to connect a different one.
  5. Click Continue to GitHub. LaunchDarkly redirects you to GitHub.
  6. Choose the GitHub organization to install the app in.
  7. Choose All repositories or Only select repositories, and select the repositories that Release Autopilot can access.
  8. Click Install. GitHub redirects you to the “GitHub App integration” panel in LaunchDarkly.
  9. Click Authorize GitHub to connect your own GitHub account. GitHub asks you to authorize the LaunchDarkly GitHub app.
  10. Click Authorize. The panel shows “Your GitHub identity is connected.”
If you are not an owner of the GitHub organization, GitHub sends your installation to the organization’s owners as a request. LaunchDarkly shows “GitHub App not linked” and explains that an organization owner must approve the installation request. After an owner approves the request in GitHub, return to the “GitHub App integration” panel to finish linking the app. If GitHub reports that it could not confirm your access to the installation, ask a GitHub organization administrator to complete the installation.

Turn on capabilities for a project

After you install the GitHub app, turn on the capabilities you want in each project, and choose the repositories where each one runs.
Agent skill availableIf you use an AI coding agent, you can use the LaunchDarkly launchdarkly-release-autopilot-settings agent skill for this task. It reads Release Autopilot settings, turns capabilities on for repositories, and explains why Release Autopilot did not run on a pull request. It requires the LaunchDarkly hosted MCP server.To install the skill, run npx skills add https://github.com/launchdarkly/ai-tooling --skill launchdarkly-release-autopilot-settings.To learn more, read LaunchDarkly agent skills.
To turn on a capability for a project:
  1. Click the project dropdown and select Project settings.
  2. Select Automations. The “Automations” page appears.
  3. Turn on the switch in the “Auto-flagging” or “Auto-releasing” section. The section lists the private repositories that the GitHub app can access.
  4. Turn on the switch for each repository where the capability should run. To find a repository, enter its name in the Search private repositories field.
  5. Click Save in the section.
Repeat these steps for the other capability. To turn on automated flag cleanup, read Turn on automated flag cleanup. If another project already uses a repository, a warning appears below the repository when you turn it on. Turning it on in this project turns off its automations in the other project. Click Enable here to move the repository to this project, or click Undo to leave it in the other project. You cannot save the section until you choose one or the other for each repository. If your role does not allow the updateFactoryRepoSettings action, the switches are read-only. If the GitHub app is not installed, the Automations page shows “Install GitHub App to use automations” instead of the repository and capability sections. Click Install GitHub App, or read Install the app. If the app is installed but the sections do not list any repositories, the “Your GitHub repositories” section shows a button that depends on your GitHub connection:
  • Authorize GitHub: You have not authorized your own GitHub account. Click Authorize GitHub to load the repositories you can access.
  • Connect another GitHub organization and Switch GitHub account: Your GitHub account cannot access the GitHub organization where the app is installed. Connect an organization you belong to, or switch to a GitHub account that has access.
Public repositories never appear in the list, because Release Autopilot works only in private repositories. If a private repository is missing from the list, give the GitHub app access to it in GitHub. To do this, click Manage repository access in the “Your GitHub repositories” section. If auto-releasing is on, each project needs a default flag release plan before Release Autopilot can release flags. Also set default environment release plans, for releases that do not name a plan. To learn more, read Set default environment release plans and Configure a flag release plan.

Accounts and authentication

Release Autopilot acts on behalf of a LaunchDarkly member. To do that, it must match the GitHub account that owns a pull request to a LaunchDarkly member. Each developer connects their GitHub account to LaunchDarkly once, and the connection applies to every repository Release Autopilot runs on. The member who installs the GitHub app connects their account during installation. Other developers connect from a pull request. When Release Autopilot cannot match a pull request’s owner to a member, it adds a “Connect your GitHub account to LaunchDarkly” check and a comment to the pull request. To connect your GitHub account from a pull request:
  1. Click Connect your GitHub account in the check or comment. If you are not logged in, LaunchDarkly asks you to log in.
  2. Authorize the LaunchDarkly GitHub app in GitHub. LaunchDarkly returns you to the pull request.
You can also connect your account before you open a pull request. Navigate to the “GitHub App” integration in Organization settings, click Configure, then click Authorize GitHub. Until the pull request owner connects their account, Release Autopilot suggests flags based on the code alone. Using your project’s flags and environments, creating flags, and releasing flags all require a connected account. Every @launchdarkly command except @launchdarkly help also requires a connected account.

What Release Autopilot can do on your behalf

Release Autopilot acts as the pull request’s owner. It can create flags, start releases, and clean up flags, and only where the owner’s own LaunchDarkly role allows those actions. It cannot do anything the owner’s role does not allow. The owner’s role must also allow the talkToVega action on the project’s Vega resource, proj/PROJECT_KEY:vega/*. This is one of the Vega actions. Release Autopilot needs it to analyze the pull request, save its plan for auto-flagging, and record auto-releasing results. Auto-releasing also requires the createAutomatedRolloutConfig action on the project. The Reader, Writer, Admin, and Owner roles include talkToVega. A custom role also includes it if its base role is Reader, or if it is a copy of a LaunchDarkly preset role, unless the role explicitly denies it. A custom role with a No access base role must allow talkToVega itself. A custom role must allow createAutomatedRolloutConfig itself. If the owner’s role does not allow the talkToVega action, Release Autopilot does not analyze the pull request. The “LaunchDarkly / Account connection” check shows “Ask a LaunchDarkly admin for Vega access,” and Release Autopilot posts a comment on the pull request. The comment asks a LaunchDarkly admin to allow talkToVega on proj/PROJECT_KEY:vega/*, where PROJECT_KEY is your project key. If Release Autopilot already started a run, the comment says that LaunchDarkly could not save the result of the run. Release Autopilot treats the pull request author as the owner. If the author is a bot or does not have a LaunchDarkly account, another member can take over the pull request. To take over a pull request, click Claim PR on the “LaunchDarkly / Account connection” check, or reply to the pull request with this comment:
After you claim a pull request, Release Autopilot uses your identity and permissions for its flag and release actions. You must have a connected GitHub account and a role other than Reader to claim a pull request. LaunchDarkly does not have a control for disconnecting your GitHub account. To stop Release Autopilot from acting on your behalf, revoke the LaunchDarkly GitHub app’s authorization in your GitHub account settings. Release Autopilot then comments on your pull requests with a link to reauthorize the app.

Account connection check results

Release Autopilot reports the connection status in a “LaunchDarkly / Account connection” check on each pull request. Here are the most common results:
Check titleWhat it means
GitHub account connected to LaunchDarklyThe owner’s account is connected. Release Autopilot can act on their behalf.
Connect your GitHub account to LaunchDarklyThe owner’s GitHub account is not connected. Release Autopilot suggests flags from the code alone until the owner connects their account or another member claims the pull request.
Reconnect your GitHub accountThe connection between the owner’s GitHub account and LaunchDarkly expired. The owner must connect their account again.
Reconnect your GitHub account to restore accessThe owner revoked the LaunchDarkly GitHub app’s authorization. The owner must connect their account again.
Ask a LaunchDarkly member with access to claim this PRThe owner’s role does not allow Release Autopilot’s actions. A member with a role other than Reader must claim the pull request. This result does not block merging.
Ask a LaunchDarkly admin for Vega accessThe owner’s account is connected, but their LaunchDarkly role does not include Vega access in this project. Release Autopilot did not run. This result does not block merging.
Ask a LaunchDarkly Owner or Admin to enable generative AIThe owner’s account is connected, but generative AI features are off for the LaunchDarkly account. Release Autopilot did not run. This result does not block merging. A LaunchDarkly Owner or Admin can turn on Enable generative AI use cases on the Security page of Organization settings. Turning it on accepts the AI terms.
Release Autopilot is turned off for this repositoryAuto-flagging and auto-releasing are both off for this repository. Release Autopilot did not run. This result does not block merging.
This repository isn’t set up for Release Autopilot yetThe repository is not in a LaunchDarkly project. Release Autopilot did not run. This result does not block merging. To add the repository to a project, read Turn on capabilities for a project.
Release Autopilot could not run. Reply @launchdarkly plan to retryAn internal error occurred. This result does not block merging.

Verify your setup

After you turn on auto-flagging for a repository and connect your GitHub account, confirm that Release Autopilot runs on a pull request. To verify your setup:
  1. Open a pull request that is not a draft in a repository with auto-flagging on. The “LaunchDarkly / Account connection” check appears on the pull request.
  2. Wait for Release Autopilot to comment with its plan. The plan can take up to about 10 minutes. If Release Autopilot finds nothing to flag, the comment says “LaunchDarkly suggests no changes.”
  3. (Optional) Comment @launchdarkly plan on the pull request to run Release Autopilot again.

Use your own AI model key

Release Autopilot uses the AI provider set in the “Inference” section of each project’s Automations page. By default, that is the managed AI provider from LaunchDarkly, which requires the AI features terms. With an Enterprise plan, you can use your own Anthropic or OpenAI API key instead. To do this, add it as a custom AI provider. Then select it from the Provider menu in the “Inference” section of each project where you use Release Autopilot. To learn how, read Vega AI providers.

Deploy signals and environments

Release Autopilot releases each flag using a flag release plan. A flag release plan lists the environments to release to, in order. For each environment, it sets the environment release plan to use and the signal that starts the release. To learn how Release Autopilot chooses an environment release plan, read Set default environment release plans. You configure flag release plans with the LaunchDarkly REST API or the LaunchDarkly MCP server. The LaunchDarkly UI does not yet support creating or editing flag release plans. LaunchDarkly does not provide a default flag release plan. Before you turn on auto-releasing for a project, create a flag release plan and make it the project’s default. To learn how, read Configure a flag release plan.
The flag release plans API is in betaThe flag release plans API is in beta. Aspects of this API may change without notice. To learn more, read Flag release plans (beta).

Choose a release trigger

Each environment in a flag release plan has a trigger that starts its release. Most environments use a deploy signal, which starts the release after your code deploys to that environment:
  • Flag evaluation (flag_eval): The release starts after an SDK evaluates the flag in the environment. This is the default deploy signal. LaunchDarkly processes evaluation data hourly. A release can start up to about an hour after the flag first evaluates.
  • Webhook (webhook): The release starts after your CI/CD system tells LaunchDarkly that a deploy finished. Use this signal if your application evaluates the flag before the code that uses it deploys, or if you want releases to follow your deployment pipeline exactly.
Flag release plans also support two triggers that do not wait for a deploy:
  • Manual (manual): The release waits until someone starts it. To start it, open the flag’s Release tab, click Start release for the environment, and then click Start release to confirm.
  • Promotion (promotion): The release starts when the previous environment’s release finishes.
You can use different triggers for different environments in the same flag release plan. For example, you can use flag evaluation for a staging environment and a webhook for production.

Configure a flag release plan

To set the release order and the deploy signal for each environment, create or update a flag release plan. Creating a flag release plan requires the createFlagReleasePlan action. Updating one requires the updateFlagReleasePlan action.
Agent skill availableIf you use an AI coding agent, you can use the LaunchDarkly launchdarkly-release-plans agent skill for this task. It lists, creates, edits, and deletes environment release plans and flag release plans, and sets the default plan. It requires the LaunchDarkly hosted MCP server.To install the skill, run npx skills add https://github.com/launchdarkly/ai-tooling --skill launchdarkly-release-plans.To learn more, read LaunchDarkly agent skills.
Here is an example that releases to staging and then to production, using a webhook signal in both environments:
Each entry in environments includes:
  • environmentKey: The key of the environment to release to.
  • environmentReleasePlanKey: The key of the environment release plan that defines the release in this environment. The plan must have only one phase. To learn more, read Set default environment release plans.
  • triggerType: What starts the release in this environment: flag_eval, webhook, manual, or promotion. This field is required for every environment, even if you use the default, flag_eval. To learn more, read Choose a release trigger.
To learn how the order of environments affects the release, read Order environments. Setting default to true makes the plan the project’s default flag release plan. If the project already has a default plan, a request to create another plan with default set fails. To replace the default plan, create the new plan without default, then update it with default set to true. Updating the plan removes the default from the previous plan.
An update replaces the whole flag release planA PUT request to update a flag release plan replaces the whole plan. When you edit the default plan, include "default": true in the request. If you omit default, the plan is no longer the default, and the project has no default flag release plan.

Send a deploy signal

If an environment uses the webhook signal, your deployment pipeline must send LaunchDarkly a deploy signal each time it deploys to that environment. Send one signal for each environment, after the deploy to that environment finishes. For example, if both staging and production use the webhook signal, send one signal after the staging deploy and another after the production deploy. Environments that use flag evaluation do not need a signal. Send the SHA of the most recent merged pull request in the deploy. LaunchDarkly records the merge commit of each pull request that merges to your repository’s default branch. A deploy signal tells LaunchDarkly that every pull request merged up to and including that commit has reached the environment. One signal releases the flags from every pull request in the deploy, not only the most recent one. The SHA must be the merge commit of a pull request. If you deploy a commit that did not come from a pull request, such as a direct push to the default branch, LaunchDarkly cannot match it and does not release anything. In that case, send the SHA of the most recent pull request merge that the deploy includes. To send a deploy signal, call the signal-deploy endpoint with an API access token. The token needs the updateAutomatedRolloutConfig action on the project. Here is an example:
The request body includes:
  • repoFullName: The repository that deployed, in owner/name format.
  • environmentKey: The key of the environment the code deployed to.
  • deploymentTrigger: The merge commit SHA, as described above. A short SHA works if it matches only one merge in the repository. If it matches more than one, LaunchDarkly returns pending, and you must send a longer SHA.
  • applicationKey: The key of the application that deployed. This field is optional. Include it if your flag release plan lists application keys. Each application then reports its own deploy, and a change that spans a frontend and a backend application waits until both deploy.
The response includes an outcome field:
  • recorded: LaunchDarkly matches the SHA and records the deploy. The release starts shortly afterward.
  • pending: LaunchDarkly has not yet recorded the merge for that SHA. This is usually temporary. Send the signal again after a short wait.

Send a deploy signal from GitHub Actions

If you deploy with GitHub Actions, add a step after your deploy step that sends the signal. In a workflow that runs on pushes to the default branch, GITHUB_SHA is the merge commit of the pull request that triggered the run. Here is an example step that sends a signal for the production environment and retries while the outcome is pending:
Store your API access token as a GitHub Actions secret named LD_API_TOKEN. To learn how, read Using secrets in GitHub Actions in the GitHub documentation.

Order environments

In a flag release plan that releases environments in sequence, Release Autopilot releases each environment in the order the plan lists them. The next environment starts only after the previous one finishes. This is the default execution mode, sequential.

Migrate from release policies to release plans

Environment release plans replace release policies. LaunchDarkly migrates your existing release policies to environment release plans automatically. Complete policies become environment release plans that are ready to use. Incomplete policies become incomplete plans, which cannot start a release and cannot be selected on the flag targeting page. Before the migration, review your release policies:
  • Complete any incomplete release policies. To learn how, read Complete an incomplete release policy.
  • Plan to replace any immediate release policies. Environment release plans support progressive releases, with optional metrics for automatic rollback, but not immediate releases. Immediate release policies do not migrate.
  • Plan to manage the migrated plans in the LaunchDarkly UI or REST API, if you manage release policies with Terraform. The LaunchDarkly Terraform provider does not support environment release plans. The provider’s launchdarkly_release_policy resource shows a deprecation warning.

Complete an incomplete release policy

A release policy migrates as an incomplete plan if any of these is true:
  • It is a guarded release policy with no metrics or metric groups.
  • It is a guarded release policy with no auto-rollback setting. A policy with auto-rollback turned off is complete.
  • It has no context kind to target by, and the project has no context kind that LaunchDarkly can use instead.
A policy without an environment is not incomplete for that reason alone. In the release policies list, a warning icon marks policies that are missing settings. To complete an incomplete release policy:
  1. Click the project dropdown and select Project settings.
  2. Select Release settings. If the page has tabs, click Release policies. The list of release policies appears.
  3. Click the name of a policy with a warning icon. The policy’s settings appear in a dialog.
  4. Add a context kind, if the policy has none. Click Add setting, select Context kind, and choose a context kind from the Target by menu.
  5. Add any missing metrics, if the policy uses a guarded release. Click Add setting, select Metrics, and choose one or more metrics or metric groups in the “Release guardrail metrics” field.
  6. Add the auto-rollback setting, if the policy uses a guarded release and the setting is missing. Click Add setting, select Auto-rollback, and choose whether to enable it.
  7. Click Save policy.
Repeat these steps for each policy with a warning icon. The fallback policy, which applies to all other environments, migrates as an environment release plan with no environment. Like any other policy, it migrates as a complete plan if its release settings are complete. After the migration, the list of environment release plans marks each incomplete plan with an “Incomplete” badge. To use an incomplete plan, open it, add the missing settings, and save it. The REST API leaves incomplete plans out of list results by default.

Set default environment release plans

Release Autopilot uses environment release plans to decide how to release a flag in each environment. An environment release plan defines the release for one environment, including its metrics and cleanup behavior. Each environment in a flag release plan names the environment release plan to use. Each environment can also have a default environment release plan. If a release does not name a plan for an environment, LaunchDarkly uses that environment’s default plan when the release starts there. For example, the LaunchDarkly agent skills release each environment with its default plan unless you choose a different one. Set a default environment release plan in each environment that Release Autopilot releases to. Releases that do not name a plan need a default to start. You cannot set an incomplete plan as the default. The default plan must also have only one phase. If it has more than one, releases that use it fail when they start in that environment. If your project had release policies, the migration sets defaults for you. In each environment, the plan migrated from your highest-priority release policy for that environment becomes the default. Review these defaults before you turn on auto-releasing. You create, edit, and set default environment release plans on the project’s Release settings page. In the list of environment release plans, each environment’s current default is marked. To set the default environment release plan for an environment:
  1. Click the project dropdown and select Project settings.
  2. Select Release settings. If the page has tabs, click Environment release plans. The list of environment release plans appears.
  3. Click the three-dot overflow menu for the environment release plan you want to use as the default.
  4. Select Set as default.
Repeat these steps for each environment that Release Autopilot releases to. To make a plan the default when you create or edit it, check Default for environment. You can also create environment release plans and set an environment’s default with the LaunchDarkly MCP server. You can also use an environment release plan when you release a flag yourself. On the flag’s Targeting page, click Ship it, and then choose an environment release plan. The environment’s default plan is marked “Default.” Review the release settings and start the release. LaunchDarkly records which plan the release used.

Pause or uninstall the GitHub app

You can turn off a capability for one repository or a whole project, pause the GitHub app, or uninstall it entirely. Pausing and uninstalling both stop Release Autopilot in every repository. Pausing is reversible and keeps your connection to GitHub. Neither one cancels releases that are in progress or removes your Release Autopilot settings. For a clean removal, complete the other steps in this section before you uninstall.

Turn off a capability

To turn off a capability:
  1. Click the project dropdown and select Project settings.
  2. Select Automations.
  3. Turn off the switch in the capability’s section to stop it in every repository in the project, or turn off a repository’s switch to stop it in that repository only.
  4. Click Save in the section.
Turning off the project switch turns off the capability for each repository in the project. If you turn the project switch back on later, turn on each repository again. To stop Release Autopilot in a repository completely, turn off the repository’s switch in each capability’s section. Repository settings remain in LaunchDarkly after you uninstall the GitHub app. If you reinstall the app later, every capability that is still on for a repository applies again. Turn off capabilities before you uninstall if you do not want them to apply after a reinstall. After you reinstall the app, authorize it again and make sure it has access to your repositories. You only need to turn on a capability for a repository again if you turned it off or the new installation does not include the repository.

Stop releases in progress

Pausing or uninstalling the GitHub app does not stop releases that Release Autopilot already started. LaunchDarkly continues those releases from their saved release configurations. However, a release that is still waiting for an event from GitHub, such as a pull request merge, cannot continue until you unsuspend or reinstall the app. Before you pause or uninstall the app, review the releases in progress on each flag’s Release tab and pause them or let them finish. To learn how to pause a release, read How auto-release works.

Pause the GitHub app

To stop Release Autopilot in every repository without removing anything, suspend the GitHub app in GitHub. While the app is suspended, Release Autopilot does not respond to pull requests or @launchdarkly commands. Your GitHub connection and Automations settings stay in place, and Release Autopilot resumes when you unsuspend the app. Suspending the GitHub app also pauses Vega’s access to GitHub, because Release Autopilot and Vega use the same app. Suspending the app does not stop releases that Release Autopilot already started. To learn more, read Stop releases in progress. You need to be a GitHub organization owner to suspend the app. To pause the GitHub app:
  1. Navigate to your GitHub organization’s Settings.
  2. Click GitHub Apps.
  3. Click Configure next to the LaunchDarkly GitHub app.
  4. Click Suspend and confirm.
To resume Release Autopilot, return to the same page and click Unsuspend.

Uninstall the GitHub app

Uninstall the GitHub app from your GitHub organization’s settings. You need to be a GitHub organization owner.
Uninstalling the GitHub app also disconnects Vega from GitHubRelease Autopilot and Vega use the same GitHub app. After you uninstall it, Vega can no longer read your code or open pull requests, including for flag cleanup.
To uninstall the GitHub app:
  1. Navigate to your GitHub organization’s Settings.
  2. Click GitHub Apps.
  3. Click Configure next to the LaunchDarkly GitHub app.
  4. Click Uninstall and confirm.
After you uninstall the app, LaunchDarkly disconnects the GitHub organization from your LaunchDarkly account, and Release Autopilot stops receiving pull request events. To stop Release Autopilot temporarily instead, read Pause the GitHub app.