Skip to main content

Overview

Agent is the resource category that connects AI SRE to external agent ecosystems. The currently supported type is A2A (Agent-to-Agent) — a standard protocol that lets different agents call one another. A2A works in two directions:

Outbound

Remote A2A agents registered in the list. AI SRE delegates tasks to them through the standard A2A protocol — for example, an external agent specializing in metrics analysis or integrated with an internal system.

Inbound

AI SRE itself is also an A2A agent and exposes an Agent Card. External A2A clients can fill in that Card URL to call Flashduty’s AI SRE in reverse, enabling incident / war-room integration and bidirectional event streams.
Delegation doesn’t make you wait. After AI SRE delegates a task to a remote agent, the conversation continues immediately. You can keep working or delegate several tasks at once. When the remote agent finishes, its result appears in the conversation as a new message. Each A2A delegation appears in the conversation stream as one line: a robot icon, “Dispatched” plus the remote agent name, and the task intent. On the right it shows the run status and usage metrics such as tool call count, tokens, and elapsed time. The run status is one of: initializing, in progress, awaiting input, awaiting authorization, completed, failed (including orphaned), interrupted, or killed. Click the line to view the full delegation trace in the right-hand panel; the A2A badge sits in that panel’s title, not on the line. A delegation running on a BYOC Runner survives a dropped connection or an AI SRE instance restart (another instance takes it over), while a delegation on a cloud environment ends with its instance — so the interrupted and failed (including orphaned) statuses mostly appear on cloud environments.
The instructions decide whether AI SRE picks this agent. Before delegating, AI SRE sees only one name: summary line per agent and uses it to decide. The summary comes from the summary: line at the top of the instructions. The body is delivered in full only on the first delegation, so it can be long and detailed. See Writing Instructions.
The A2A agent list and management entry point are on the Customize → Plugins → Agents page.
Agents covers two distinct concepts. This page (Agents) currently manages A2A Agents (external agent-to-agent calls). The other concept is the Subagent — a platform-built-in task executor that AI SRE dispatches on demand within a session. Subagents have no create / edit entry point; you only observe their behavior in sessions. See Subagent below.

Registering an outbound A2A Agent

On the A2A Agents list page, click Add A2A Agent and fill in the form:

Writing instructions

Instructions are a single document with up to two parts: an optional YAML frontmatter block at the top (a single summary field), followed by the body.
  • The summary drives routing. Every time AI SRE decides whether to delegate, all it sees is one line in the available-agent list: name: summary. That summary is exactly this field’s content. State clearly when to prefer this agent, what it excels at, and what it is not suited for. Use concrete capability words (product names, verbs, scenarios), not marketing slogans. Overlong summaries get truncated in the list, so front-load the important part.
  • The body is delivered on demand, not kept in the list. The body does not occupy AI SRE’s context all the time. It is sent to AI SRE in full only the first time it delegates to this agent (progressive loading). That means the body can be as long and detailed as you need — procedures, hard rules, examples — without bloating everyday conversations.
  • Plain text without a summary still works. Instructions that don’t start with --- count as plain text. AI SRE treats the whole content as the body and uses the truncated beginning as the summary. Older-style instructions keep working unchanged. Writing an explicit summary is still strongly recommended for more predictable routing.
  • Hard limits: the whole document (frontmatter + body) is at most 50 KB. summary is at most 1,024 characters and must not contain < or >. The body must be non-empty.
  • If the document starts with ---, that frontmatter block must be closed with another --- line, or saving fails.
The instructions used by Using the FlashAI Template below are a working example — see its structure for reference.

Using the FlashAI template

FlashAI is the observability analysis product in the Flashcat / 快猫星云 family. It can also be connected as a remote A2A agent for AI SRE. On the A2A Agents page, expand the Connect FlashAI observability analysis panel to create an A2A agent from the FlashAI template. The FlashAI template is not a blanket rule that sends every observability question to FlashAI. It configures FlashAI as the delegation target for Flashcat / 快猫星云-originated alert and incident investigation. For alerts or incidents from Flashcat products such as Event Wall / 事件墙, Firemap / 灭火图, and Polaris / 北极星, AI SRE should prefer delegating analysis to FlashAI. The template prefills instructions. The summary: line at the top lists the Flashcat / 快猫星云 products FlashAI covers, and the body gives the routing rules:
  • Prefer FlashAI when you are investigating an alert, incident, or alert group that clearly originates from Flashcat / 快猫星云 (Event Wall, Firemap, Polaris).
  • Do not use FlashAI for generic metrics, logs, traces, or performance questions that have no Flashcat / 快猫星云 alert context or product marker. Use the available tools or your own observability sources instead.
Prepare FlashAI first:
1

Confirm the version

FlashAI must be release-24 or later.
2

Configure FlashAI /config

Open /config in the FlashAI / Flashcat console (for example, https://demo.flashcat.cloud/config), add a2a_server_base_url, and set it to the current FlashAI access domain, for example https://demo.flashcat.cloud.
3

Confirm network reachability

If FlashAI uses a private-network address, only a BYOC Runner deployed in that network can reach it. If cloud Sandbox also needs to call FlashAI, use a publicly reachable domain and configure an allowlist as needed. This is the same network-reachability rule used for MCP SSE endpoints in Sandbox.
After FlashAI is prepared, enter the FlashAI domain in the panel (for example, demo.flashcat.cloud) and click Use this template. The page opens the Add A2A Agent form and prefills:
  • Name: generated from the domain, for example flashai-demo
  • Instructions: a summary: line plus a body — the body lists which Flashcat alerts/incidents should prefer FlashAI and which generic observability questions should not.
  • Card URL: generated from the domain:
The template prefills only common values; you still set the Scope (Shared or Team) and authentication in the form. The same FlashAI can be installed several times for different scopes, but agent names must be unique within the account, so change the name when installing it again.
Don’t remove the instructions that the FlashAI template generates, especially the summary: line at the top. Once registered, FlashAI always appears in the available-agent list. Whether AI SRE actually delegates to it depends on that summary line. When the instructions are too short or too generic, AI SRE may keep reasoning locally or incorrectly delegate ordinary metrics / logs questions to FlashAI.

Authorization modes

An A2A agent’s identity is determined by two independent axes, and both can be configured at the same time:
  • Service authorization: the identity AI SRE uses when calling the remote agent as a service. One credential shared account-wide. Choose none, Bearer Token, or custom Header + Key. The form marks it Recommended — configure it once and it covers every scenario.
  • Member authorization: the identity each member holds individually. Choose none, Secret (Header), or OAuth 2.1.
These two axes are not a three-way choice. You can set only the service authorization, only the member authorization, or both. When both are set, the identity resolution order below decides which one each scenario actually uses.

Identity resolution order

The “Identity resolution order” panel at the bottom of the form updates live as you change the two selects:
  • Service authorization only: all calls use the service authorization.
  • Member authorization only: IM group chats use the speaking member’s own authorization, turn by turn. If the remote system rejects several identities taking turns within one conversation (its identity check fails), add a service authorization.
  • Both axes set to none: calls carry no identity. Saving asks for confirmation. Configure a service authorization when the remote endpoint requires authentication.
A service authorization means any team-scope session or IM group chat in the account can call the remote system as that service identity. If the system exposes members’ personal data or allows high-risk writes, enable member authorization as well.

The two forms of member authorization

Each member provides their own key on first use; the key is encrypted and stored at the account level. In the Key Schema, configure the Header name and a help link to guide members on first call. The header name is required and sets the HTTP header that carries the credential. The help link is optional and points to documentation on how to obtain the key. Members fill in and manage their own key from the “Member authorization” column of the A2A agent list.
Each member authorizes through the OAuth 2.1 flow; an authorization window pops up automatically on the first call to this A2A agent, and credentials are stored per member after completion. Before authorizing, choose an execution environment in the Credential dialog: a Cloud Sandbox or an online BYOC Runner; Auto is unavailable. OAuth requests run from the selected environment, so choose a BYOC Runner that can reach the service when its OAuth endpoint is private.
OAuth 2.1 appears only on the member authorization axis. The service authorization is a single static credential shared account-wide, and offers only Bearer Token and API Key.
Saved sensitive fields (such as tokens, API keys, and client secrets) are shown as a fixed **** mask that reveals neither the first nor the last characters. Saving the mask unchanged keeps the current value; saving the field empty clears it.

Changing the Card URL discards stored credentials

Pointing an agent at a different Card URL means a new destination, and the credentials stored for the old one don’t come along:
  • Re-enter every sensitive field of the agent’s authentication settings as plaintext in the same edit. Saving fails and lists the field names to re-enter when a value is left empty, sent back as the mask, or the field is omitted entirely (an omitted field counts as reusing the old value). The error reads: The connection destination changed, so stored secrets are not sent to it. Re-enter these values in the same edit: <keys>.
  • Every member’s credential under member authorization (Secret (Header) / OAuth 2.1) is revoked. After the change, each member enters their key again or authorizes again. Revocation happens before the save, so members re-authorize even when the save fails.
  • Replacing only the OAuth metadata without touching the Card URL also revokes members’ credentials, but does not require re-entering the values shared account-wide. Emptying it only triggers rediscovery from the unchanged Card URL.
Members who can view but not edit an agent get the Card URL with its user:password part removed and every query value replaced by ****; a URL that doesn’t parse is hidden entirely.
Use HTTPS for member authorization (OAuth 2.1) discovery whenever possible. Enable “Allow fetching OAuth configuration over HTTP (testing only)” for a non-local HTTP Card URL only in controlled test environments. If an HTTPS endpoint uses a self-signed certificate, enable “Skip TLS certificate verification” only temporarily and only inside a trusted network.

Protocol version and Agent Card requirements

When calling a remote agent as an A2A client, the platform implements A2A Protocol 1.0 (with the JSONRPC or HTTP+JSON protocol binding). Protocol 0.x and other major versions are not supported: the remote agent’s Agent Card must be in the 1.0 format, or delegated calls will fail. A 1.0-format Agent Card declares its endpoints through the supportedInterfaces array, where at least one entry must contain url, protocolBinding (JSONRPC or HTTP+JSON), and protocolVersion: "1.0". A minimal valid card looks like this:
The version field on the card is the agent’s own version number, not the protocol version. The protocol version is declared by protocolVersion in each supportedInterfaces entry.
Migrating from 0.x to 1.0: if your Agent Card still uses the 0.x format, adjust it as follows before connecting:

Creating and managing

The full lifecycle of A2A agents is managed on the Customize → Plugins → Agents page.
Click Add A2A Agent, fill in the name, scope, instructions, Card URL, auth settings, and save. You must select a definite scope (shared or team) before submitting — the submit button remains disabled until a scope is chosen.
Use the toggle in the list to switch an A2A agent’s enabled state. Only enabled agents appear in AI SRE’s available-agent list and can receive delegated tasks; disabling one makes it immediately invisible to delegation.
Click any row in the list to open the form, where you can view and edit the name, instructions, scope, Card URL, service authorization, member authorization, and streaming. The form is read-only when you do not have edit permission.
Remove an A2A agent from the current scope. Active sessions that delegated to it will fail. Deletion requires confirmation.
Filter the list by scope (All / Shared / a specific team) or search by keywords in the name, instructions, or Card URL. Each row shows its scope (shared / team name).

Scope

A2A agents share the same two-level scope (shared / team) as other resources. For the rules on creating, editing, and runtime visibility, see Scope and permissions.

Inbound: Letting external agents call AI SRE

Expand the “Let External Agents Call Flashduty’s AI SRE” panel at the top of the A2A Agents page to get the Agent Card URL for this account’s AI SRE:
Add that URL to any A2A client to call Flashduty’s AI SRE agent through the A2A protocol. Authentication: add Fd-App-Key: <your app_key> in the request header (or use the ?app_key= query parameter). The capabilities declared on the Agent Card include:
The Agent Card also declares Flashduty’s “run options” A2A extension. In message.metadata, callers can override three settings: incognito, visibility (private / account), and the environment (cloud / byoc and a specific environment_id). incognito hides the session from the session list and is on by default. This extension is optional — plain A2A clients can ignore it and call normally.

Incident and war-room integration

A session can enter through an incident route, for example when an incident or war room triggers AI SRE. In that case, the platform binds the incident to the session and adds it as context, so troubleshooting starts on the correct incident. AI SRE can then use built-in skills to act on the incident: read incident details, query the timeline, create or view war rooms, link changes, and more. For automatic war-room diagnosis on the IM side, see IM Integration.

Subagent

A Subagent is a platform built-in task executor. During an investigation, AI SRE dispatches self-contained subtasks to a Subagent that completes them independently. The platform ships several bootstrap Subagents that work out of the box: In the conversation: each dispatch also appears as one line with the same statuses as an A2A delegation: a robot icon, “Dispatched” plus the subagent name (written as subagent when the name is a type synonym such as agent or general), and the task intent. The right side shows the execution environment of the dispatch (the cloud environment or the BYOC Runner’s name) plus usage and status. Click the line to view the full trace in the right-hand panel; the Agent badge (A2A for A2A delegations) sits in that panel’s title. Runtime limits:
  • Concurrency cap: a session runs at most 20 Subagents at the same time. Total dispatches are unlimited — each completion frees a slot; at the cap, AI SRE waits for running ones to finish before dispatching the rest.
  • Nesting depth: a dispatch chain nests at most 3 levels deep, preventing a Subagent from spawning itself indefinitely.
Execution environment: by default a subtask runs in the same environment as the current session and shares its filesystem, so it can read your workspace’s files directly. AI SRE can also send a subtask to a fresh cloud environment (an ephemeral container with its own filesystem; it can reach the public internet but not your private network) or to a BYOC Runner (account-scope Runners, plus the Runners of the team the session is bound to). The candidate list includes every Runner that has ever connected, including ones currently offline; Runners that have never connected are not listed. Reachability is checked at dispatch time. If the chosen Runner is unusable, the dispatch fails with the reason and is not re-routed. A2A delegations cannot choose an environment; a remote agent executes in its own. See Environments (BYOC) for how the environments differ and how to pick one. A cross-environment dispatch cannot read the parent’s files: a subtask sent to another environment gets its own sandbox or Runner directory and cannot see the parent session’s files. AI SRE therefore puts everything the subtask needs into its task description, and results come back as text or through an external system such as git or a ticket.

Console Chat

Observe A2A delegations and their sub-session panels within a session.

MCP (External Tools)

Connect external tools to agents to expand their capability boundary during tasks.

Manage Knowledge

Use DUTY.md and knowledge to provide agents with team context and troubleshooting experience.

IM Platform

@ AI SRE in an IM group and learn about automatic war-room incident diagnosis.

Overview

Understand AI SRE’s overall capabilities and positioning.