Skip to main content

Overview

Apps is where you manage authorized external applications. Each external application appears as a card — you authorize it, manage its installations, and enable / disable or revoke it right from its card. Apps includes GitHub, GitLab, and Kubernetes Apps. GitHub and GitLab authorize access to code repositories. AI SRE can read code and investigate changes, commits, and PRs (MRs on GitLab). When asked, it can fix a bug or open a PR / MR or issue. A Kubernetes App connects a selected Kubernetes cluster to AI SRE and limits the agent to the configured namespaces and permission level.

Main scenario: Letting the cloud Sandbox reach your repositories

AI SRE sessions run in a Flashduty cloud sandbox by default. The sandbox is a clean, isolated, ephemeral environment that carries none of your git credentials — which is exactly what an App solves. After you authorize the GitHub App or the GitLab App, the agent in the sandbox can clone your repositories, read diffs, and open PRs / MRs. You don’t hand it any password or token. Its access is limited to the repositories you granted, with only the least privilege needed to do the work. This is what both Apps are mainly for.
BYOC (self-hosted Runner) generally doesn’t need it. A Runner runs on your own machine. That machine usually already has gh / glab / git credentials configured, because you work with repositories on it every day. In that case the agent uses the host’s own credentials — no App authorization needed. (If the host happens to have no credentials configured, authorizing the App lets BYOC sessions use it too.) For the differences between environments, see Environments (BYOC).
A RUM application can also record the repositories that build it. You can link several; the first one is the primary. AI then goes straight to the code when it analyzes a RUM problem. See Application Management · Code repositories. Linking a repository there grants no access by itself: what a cloud AI session can read is still only what is authorized for the account here.

Where to find it

Go to AI SRE → Customize → Plugins → Apps. The Plugins group in the Customize sidebar lists Overview / Apps / Skill / MCP / Agents in that order, and clicking Customize opens Overview by default.
Viewing the Apps page requires the appropriate permission; without it, the entry is hidden from the sidebar. Authorizing, disconnecting / revoking, and enabling / disabling each require their own action permission — when you lack one, the corresponding button is shown disabled.

Kubernetes Apps

A Kubernetes App connects an in-cluster agent to AI SRE. After installation, AI SRE can query cluster information and use the available Kubernetes tools within the namespaces and permission boundaries you configure.

Create and install

1

Create a Kubernetes App

Go to Customize → Plugins → Apps → Kubernetes Apps and click Create Kubernetes App. Enter a cluster name and choose its scope: Shared is available to all sessions in the account. Team is available to that team’s sessions and to personal sessions of its members. Cluster names must be unique within a scope.
2

Set namespace access

Choose All namespaces or Specific namespaces, then pick a permission level. If you list no specific namespaces, the agent can read only basic cluster metadata. For what each level allows, see Permission details below. For the complete RBAC rules, open View Kubernetes RBAC details in the form.
3

Run the installation command

Save the App, copy the generated installation command, and run it in the target cluster. Installation commands expire; reopen the installation setup or view the manifest to generate a new command without rotating the token.
After changing namespace access or permissions, run the installation command again so the in-cluster RBAC is updated. Before choosing Read + limited modifications, confirm that AI SRE is allowed to perform those actions in the namespace. Full access is a high-risk option: on a specific namespace it lets this App read, create, modify, and delete every resource in that namespace. All namespaces + Full access escalates to cluster administrator access (cluster-admin), so choose it with care.

Permission details

The following boundaries apply to all levels:
  • Every level can read cluster information, nodes, Pods, events, logs, and non-sensitive resources such as ConfigMaps
  • No level supports entering a container (exec), Attach, port forwarding, or watch and real-time log following (-f). This is a limitation of the access method, not of the permission level
Operations that differ between levels:
  • Read-only: read access within the authorized namespaces is bound to Kubernetes’ built-in view role. It covers Pods, logs, workloads, events, ConfigMaps, and similar resources, but never Secrets; CRDs that cluster components mark as view-readable are included as well. It also grants read-only access to cluster-level nodes, namespaces, persistentvolumes, storageclasses, and ingressclasses.
  • Read + limited modifications: adds three abilities to read-only. It can evict Pods (pods/eviction) and scale Deployments and StatefulSets (deployments/scale, statefulsets/scale). It can also adjust HPA replica bounds (horizontalpodautoscalers). These rules can only change a workload’s replica count and rebuild Pods from the same configuration. They can’t change any Pod’s image, startup command, environment variables, identity, or mounts. As a result, Kubernetes denies kubectl rollout restart and kubectl rollout undo, because both are patches to the workload. To restart a workload, evict its Pods one at a time. For rollbacks, AI SRE derives the target revision from the ReplicaSet history and gives you the complete kubectl rollout undo --to-revision=N command to run in your cluster.
  • Full access: can read Secrets, modify ConfigMaps and Secrets, modify workload configurations, create or delete resources, and modify RBAC within the namespace. All namespaces + Full access additionally grants cluster-admin through a ClusterRoleBinding, covering cluster-scoped resources and cluster RBAC.

Edit and revoke

You can edit the cluster name, scope, and namespace access from the Kubernetes App list. Changing the scope to Shared has the same gate as creating a Shared App: only the account owner or admins can do it. A regular member can’t do it even for their own team’s App. Regular members can only move an App to teams they belong to. Revoking immediately invalidates the connection and token, but it does not remove the in-cluster agent or RBAC automatically. Run the uninstall command shown by the console in the target cluster. It removes only resources for this Kubernetes App and preserves the shared flashduty namespace.

The GitHub App

The following walks through GitHub first — authorization, installation management, and adjusting repository access; GitLab follows in the next section.

Connecting a GitHub organization

Authorization happens on GitHub’s official install page, opened in a popup.
1

Start the authorization

Click Authorize on the GitHub card (More repositories if the App is already installed) and continue on the GitHub install page that pops up.
2

Pick the organization and repositories on GitHub

Choose the organization (or personal account) to install into, and grant a repository scope — All repositories or Only select repositories. The set of granted repositories determines which repositories AI SRE can access afterward.
3

Authorize Flashduty on GitHub

After you pick the organization and repositories, GitHub takes the browser to the Flashduty App’s OAuth Authorize page; confirm it and the browser returns to Flashduty on its own. This step is what proves the installation belongs to you: Flashduty binds the installation to your account only once the authorizing GitHub user is shown to have access to it, so an installation nobody can access is never bound. A private deployment must set the GitHub App’s Callback URL to the install callback address and fill in the OAuth client id and secret; without them, installations do not take effect.
4

Auto-refresh after you confirm

After you confirm on GitHub, the popup closes and the new organization appears in the installation list.
If you are not an owner of the organization, GitHub sends the request to the organization owner for approval; the installation takes effect once approved.

Managing installations

Each authorized organization adds a row under the GitHub card, showing the organization name, status (Connected, Suspended, Revoked) and the number of repositories granted.
The toggle in the top-right of the card switches between Enabled and Disabled. Disable = suspend: while the App is suspended, the agent can’t reach those repositories. The GitHub installation itself stays in place, so you can re-enable it with one click and skip the GitHub authorization. An App counts as “enabled” as long as it has at least one Connected installation.
Click Revoke on a row; after you confirm, the installation is set to Revoked and AI SRE can no longer access that organization’s repositories. A revoked installation is hidden from the card; re-authorizing the same organization restores it.
Suspend versus Revoke: suspend turns it off temporarily, keeps the GitHub installation, and resumes with one click. Revoke disconnects this authorization and requires going through the GitHub authorization again to use it.

Adding or adjusting repository access

The organization is already connected, but you want AI SRE to reach more of its repositories — you don’t need to revoke and reconnect. In Customize → Plugins → Apps, click More repositories again for that organization (or open the App’s Configure page on GitHub directly). GitHub shows the Repository access screen. Select the additional repositories and save, and AI SRE re-syncs the granted repository list automatically — the new repositories become available without re-creating the connection.
Fallback: a newly added repository might still report “cannot access / 404 / 403” in a session. In that case, open the App’s page on GitHub (for example, github.com/apps/flashduty). Then go to Configure → select the organization → Danger zone → Uninstall. Then return to Customize → Plugins → Apps in Flashduty and authorize the organization again, granting all the repositories you need in one pass.

The GitLab App

The GitLab App connects GitLab.com, JihuLab (jihulab.com SaaS or a private deployment), and any other self-managed instance. The steps are the same for all: register an OAuth application on the instance, then authorize. AI SRE can then read code and investigate changes / MRs in the authorized repositories, and file issues or open MRs when you ask. As with GitHub, you never paste a personal token; Flashduty provisions a dedicated bot identity for your account.

Connecting a GitLab instance

1

Choose the GitLab instance to connect

Click Connect on the GitLab card and pick one of three options:
  • GitLab.com — the address is fixed to https://gitlab.com; nothing to fill in.
  • JihuLab — the address is fixed to https://jihulab.com; nothing to fill in.
  • Self-managed — enter the instance’s root address: the part of the URL before the group / project path, for example https://gitlab.example.com. If the instance is deployed under a subpath, include it, for example https://example.com/gitlab.
2

Choose the connection environment

Network requests for connecting and re-authorizing GitLab are issued from the environment selected here. Public instances such as GitLab.com and JihuLab can use the default cloud environment. For a self-managed instance reachable only from a private network, choose the BYOC Runner that can reach it. The system does not automatically switch environments when a Runner is offline or unreachable; choose an available environment and start the connection or authorization again.
3

Register an OAuth application on that instance

The connect wizard shows a copyable Redirect URI. Take it to the GitLab instance you entered and create an OAuth application: a group Owner does this under Group Settings → Applications. On GitLab.com, if you’re not the Owner of any group, a user-owned application under User Settings → Applications also works. An instance admin can also register one under Admin Area → Applications. Fill in the Redirect URI the wizard gave you, check Confidential, and check only the api scope. GitLab then issues an Application ID and a Secret — paste both back into the wizard.
4

Authorize in the popup

Confirm the instance and OAuth application to use (click Change OAuth application to switch), then sign in and confirm on the GitLab authorization page that pops up.
5

Pick the groups and projects to authorize

AI SRE shows a repository picker listing the groups where you have the Owner role and the projects where you have the Maintainer role. Select the groups / projects you want AI SRE to access and save — selecting a group covers all of its projects, including ones created later.
An account can connect only one GitLab instance at a time (GitLab.com or one self-managed instance). To switch to a different instance, disconnect the current one first.

Bot identity and permissions

After you save the repository selection, Flashduty provisions a dedicated bot for the account inside those groups / projects for AI SRE sessions to use. The bot is a service account where the instance supports it; otherwise Flashduty falls back to a group- or project-level access token. Either way, the bot’s permissions are capped at Developer level — the same minimum access you’d grant it in GitLab yourself. Tokens are rotated automatically before they expire; there’s nothing for you to manage. If the instance does not support service accounts, the bot uses a group- or project-level token instead, and you can select only one group or project.
One restriction on GitLab.com: GitLab’s own policy limits group- and project-level access tokens to paid (non-free, non-trial) namespaces. Connecting GitLab.com itself still works. However, if the group / project you authorize is in a free or trial namespace, bot provisioning fails. The UI then shows GitLab’s own explanation (“provisioning_denied”). Upgrade that namespace to a paid plan and re-authorize to resolve it.

Managing a connected instance

The GitLab card shows the connected instance’s address and status.
Reopens the repository picker so you can add newly needed groups / projects or remove ones you no longer need — AI SRE’s access updates as soon as you save.
Disconnects this instance. Flashduty makes a best effort to clean up the bot identity provisioned for the account and any tokens under it. If a cleanup step doesn’t succeed, the UI surfaces a warning. All access to the instance stops immediately after disconnecting, and reconnecting requires going through OAuth authorization again.

How AI SRE works inside a repository

After authorization, you need no extra configuration. When you ask AI SRE to work in a repository, it works like an engineer joining the project: understand first, then change, then verify. This behavior is governed by the built-in github Skill and gitlab Skill respectively. Typical actions
  • Enter the repository: clone it into its own workspace and read the repo’s own conventions first (CLAUDE.md, AGENTS.md, README, CONTRIBUTING).
  • Investigate changes / PRs / MRs: use git log. On GitHub, also use gh pr list / gh pr view / gh pr diff / gh search prs. On GitLab, use the equivalent glab mr list / glab mr view / glab mr diff. Use them to trace a PR / MR named in an incident or change ticket, see what a release shipped, or read a diff before deciding anything.
  • Change and propose: create a branch and make a minimal diff. Then open a reviewable PR / MR with gh pr create or glab mr create, or file an issue with gh issue create / glab issue create. Report the link back to you.
Hard guardrails — the agent never crosses these:
  • Never force-push (git push --force), and never push the default branch directly — always a branch + PR / MR.
  • One logical change per PR / MR, kept reviewable; if a change balloons beyond a focused diff, it stops and hands the analysis back to you.
  • Never delete branches, close others’ issues / PRs / MRs, or change repository settings; never commit secrets, credentials, or build artifacts.
If the agent reports that it can’t access a repository in a cloud session, check two things. Either the account hasn’t authorized the relevant App (GitHub or GitLab), or the App doesn’t have access to the target repository / group. Authorize and grant it under Customize → Plugins → Apps. The agent does not ask you for any token.

Permissions & scope

Authorizing and revoking / disconnecting the GitHub App and GitLab App are account-level operations. Any member with the relevant permission can do them, and all members share one authorization. Sessions access repositories through the account’s currently active installation. Teams are only an ownership tag; the account is the only security boundary. The two Apps’ scope models differ slightly: the GitHub App lets the same account install multiple organizations, each enabled / revoked independently. The GitLab App lets an account connect only one GitLab instance at a time — switching to a different instance requires disconnecting the current one first.

MCP (External Tools)

Connect external tools and data sources through the Model Context Protocol.

Console Chat

Watch the agent clone a repo, read a diff, and open a PR / MR during a session.

Environments (BYOC)

BYOC sessions use the runner host’s own credentials and generally don’t need the GitHub / GitLab App.

Skills

The built-in github / gitlab Skill governs how the agent works inside a repository.