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.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).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.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
Create a Kubernetes App
Set namespace access
Run the installation command
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
- Read-only: read access within the authorized namespaces is bound to Kubernetes’ built-in
viewrole. 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 denieskubectl rollout restartandkubectl 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 completekubectl rollout undo --to-revision=Ncommand 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-adminthrough aClusterRoleBinding, 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 sharedflashduty 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.Start the authorization
Pick the organization and repositories on GitHub
Authorize Flashduty on GitHub
Auto-refresh after you confirm
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.Enable / Disable (suspend / resume)
Enable / Disable (suspend / resume)
Revoke
Revoke
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.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
Choose the GitLab instance to connect
- 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 examplehttps://example.com/gitlab.
Choose the connection environment
Register an OAuth application on that instance
Authorize in the popup
Pick the groups and projects to authorize
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.Managing a connected instance
The GitLab card shows the connected instance’s address and status.Manage repos
Manage repos
Disconnect
Disconnect
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-ingithub 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 usegh pr list/gh pr view/gh pr diff/gh search prs. On GitLab, use the equivalentglab 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 createorglab mr create, or file an issue withgh issue create/glab issue create. Report the link back to you.
- 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.