You can now register your own agent in the Flashduty console. AI SRE can then hand it a whole task, keep working, and get the result back as a message. It works in reverse too: AI SRE exposes a standard A2A endpoint, so your agents can hand work to it.
We built this for FlashAI first. When an alert from Flashcat's Event Wall, Firemap, or Polaris reaches AI SRE, FlashAI is usually the better analyst. It has its own model, prompts, and data access, and it may run on another network. Breaking its analysis into tool calls loses the goal and pushes FlashAI's judgment onto AI SRE. Handing over the whole task works better.
A2A (Agent-to-Agent) is an open protocol started at Google. The console has a "Connect FlashAI" template. For your own agent, you register an address, an auth method, and invocation instructions.
Tool or agent?
The question is who decides the next step.
| MCP tool | A2A agent | |
|---|---|---|
| Who decides the next step | AI SRE orders the calls | The remote agent drives its own task |
| Interaction | One request, one response | A task that may run for minutes, or pause for input or authorization |
| State and failure | Stateless in practice; failure is an error | Keeps conversation state; "I can't do that" is a normal reply |
If AI SRE should plan every step, use MCP. If the other side needs its own context to finish the work, use A2A. We wrote about tool interfaces in From MCP to a CLI. In the product, third-party systems in the connector catalog use MCP, and external agents use A2A.
What a delegated task looks like
AI SRE delegates through one asynchronous tool. The call returns a task id right away, and AI SRE goes back to the conversation.
Progress streams into a task card with an A2A badge. The card shows the agent name, the task, its status, tool calls, tokens, and elapsed time. Click it to open the full run in a side panel.
The remote agent may need more input or an authorization. The task then pauses and the card says what it's waiting for. That's not a failure. When the task finishes, the result arrives as a new message.
Limits: 20 tasks at once per session, three levels of nested delegation, and 30 minutes per call. A connection that won't open fails fast. An agent that is slow to load its model or context won't trip the startup timeout.
Telling AI SRE when to call it
Invocation instructions tell AI SRE when to pick your agent. They have two parts. The summary is always loaded. The body loads only the first time AI SRE actually delegates to that agent.
---
summary: One line on what this agent is good at and when it should be preferred
---
Body: how to call it, required phrasing, preconditions, output format, when not to use it...
When AI SRE picks an agent, it sees only names and summaries. So name products, actions, and situations in the summary. Put calling rules, preconditions, output format, and counterexamples in the body. The whole document can be 50 KB. The summary can be 1,024 characters.
Where the request comes from
The call does not leave from Flashduty's servers. It leaves from the execution environment the session runs in. That's either our cloud environment or a runner you deployed. If your agent is on an internal network, a runner on that network has to make the call.

The execution-environment field looks like routing, but it isn't. Calls always run in the session's own environment. The field only says where the agent is available. If one runner can reach it, select only that runner.
When the current environment can't reach the agent, AI SRE is told so. If the agent silently dropped off the list, the model might invent one. With a stated reason, it picks another path.
For the address, you can give the service origin. We then fetch /.well-known/agent-card.json, per the A2A convention. Or give the full Agent Card URL and we use it as is. We don't scan for agents. You register them.
Credentials
You pick one of three modes when you register.
- Account-shared. You register one bearer token or API key, and every session in the account uses it. Use this when the team shares one remote account.
- A secret per user. Each user enters their own key on first use. We store it encrypted, per user. Use this when the remote system authorizes or bills per person.
- One OAuth flow per user (OAuth 2.1). The first call starts the authorization. The platform isolates credentials per user.
OAuth requests also go out from the selected execution environment. That can be the cloud sandbox or a BYOC runner that can reach your internal auth server. Stored secrets always come back masked. Leave a secret field blank when editing to keep the current value.
Account-shared is the default. If the remote agent can do risky writes, switch to per-user secrets or per-user OAuth. Otherwise every session in the account holds the same key.
Calling AI SRE from your agent
AI SRE publishes its own Agent Card. Any A2A client can call it:
curl -H "Fd-App-Key: $APP_KEY" \
https://api.flashcat.cloud/safari/a2a/ai-sre/agent-card
The card lists three skills. AI SRE can find an incident's root cause end to end. It can query and summarize a service's logs over a time window. It can do the same for metrics. External clients use the same interface our product uses. There is no private back door.
The card also declares an optional extension. With it, a caller can pick the execution environment and choose whether the run shows in the session list. Clients that ignore it still work.
Limits
After it delegates, AI SRE sees only what the remote agent reports. What the agent ran internally, and which tools it used, stays hidden unless it streams that back.
There are no automatic retries. If a call breaks mid-stream, the reason goes into the task result. AI SRE then decides whether to try again, at most once. We chose this so a remote action never repeats without anyone knowing.
Getting started
Open AI SRE → A2A Agents in the console. For Flashcat alerts and incidents, start with the "Connect FlashAI" template. For your own agent, fill in the address, auth method, and invocation instructions.
The field reference and the Agent Card interface are in the docs.


