Automating reports with AWS DevOps Agent
A team already running AWS DevOps Agent can automate recurring SRE/Dev team reports on the same managed service instead of building and operating their own custom solution. This post shows what that takes: a few MCP tools for data, metrics, and email, plus a skill, a custom agent, and a trigger configured in the DevOps Agent's web app.
A customer asked for help automating a report. Their SRE team produced a weekly executive leadership team (ELT) report by hand: export tickets from their IT service management (ITSM) system, export work items from their engineering work tracker, paste both into a chat assistant, and edit the result until the numbers lined up. The first design on the table was an agent built on the Strands Agents SDK, deployed on Amazon Bedrock AgentCore Runtime, with its own tools, schedule, and delivery.
The team was already using AWS DevOps Agent for incident response. That changed the design. Instead of building and operating a new agent, we added a custom agent to the managed service they already had and gave it 4 tools. This post describes the pattern and what you need to build to apply it.
What you build
- An AWS DevOps Agent custom agent that runs every Monday at 09:00, reads 2 systems of record, writes a narrative, and emails a rendered HTML report.
- One Amazon Bedrock AgentCore Gateway that exposes Model Context Protocol (MCP) tools: data query tools, a deterministic metrics calculation, and 1 report tool that renders and sends.
- A skill, a custom agent prompt, and a schedule trigger, this is all configuration in DevOps Agent, no code.
Why DevOps Agent 's custom agent
Strands on AgentCore Runtime gives you a model loop, tools, memory, and observability. It is also an agent you own end to end: prompt versions, model access, IAM, scheduling, tracing, and on-call.
AWS DevOps Agent runs that layer as a managed service. You connect capabilities to an agentspace: native integrations such as Azure DevOps, GitHub, ServiceNow, and Datadog, and MCP servers you register. Each capability exposes tools. On the DevOps Agent web app you can create custom agents and skills, select which tools an agent can use, set its schedule, and read the trajectory of each run. The report agent can run in its own agentspace alongside the team's incident spaces, in the same web app.
The development work reduces to what is specific to the report. Here is the comparison:
| Strands on AgentCore Runtime | DevOps Agent custom agent |
|---|---|---|
Agent loop, model, tracing | You build and operate | Managed |
Data connections | Your code, your transport | Capabilities (integrations and MCP servers), configured once per agent space |
Schedule | You add EventBridge Scheduler | Built-in trigger (cron or rate expression) |
Run history | You build it | Trajectory per run in the console |
What you write | Everything | MCP tools (if you need) eg: for email sending/metrics/or custom data source |
Solution overview

Every Monday run:
- The trigger creates a task for the custom agent.
- The agent calls the ITSM and work tracker query tools for the data and metrics. Each returns records and computed metrics.
- The agent calls
preview_weekly_reporttool and returns the figures.
- The agent writes the narrative against those figures.
- The agent calls
send_weekly_reportwith the week and the narrative. The tool recomputes, renders HTML, and sends through Amazon SES to a fixed recipient list.
Tools used in our example
To emulate the data sources needed for report generation, we registered one MCP server, an AgentCore Gateway, with 3 Lambda targets behind it.
Target | Role |
|---|---|
ivanti | Query tool for the ITSM system. Returns the week's problem and change records with a 12-week trend and computes the metrics on them: MTTR, closure lag, provider dependency |
azure-devops | Query tool for the work tracker. Returns the week's releases, ad hoc requests, and retrospective actions with a 12-week trend and computes completion rates and SLA misses |
report | Renders the HTML report and sends it through Amazon Simple Email Service (Amazon SES). |
The 2 query tools include a deterministic metrics calculation. The metric definitions live in one shared Python module used by all 3 functions, so a figure means the same thing wherever it appears.
If you already have third-party MCP connectors for your data sources, keep them for querying and add one MCP tool that calculates the metrics deterministically and sends the report. The agent reads records through the connectors and takes its figures from the metrics tool.
Setting it up

Four steps. The first is code in your account; the other 3 are configuration in the DevOps Agent web app.
Step 1: Build the tools on the gateway
One AgentCore Gateway with
AWS_IAM authorization fronts the 3 Lambda targets. Tool names the agent sees are <target>___<tool> .Step 2: Register the MCP server
In the DevOps Agent console, register the gateway URL as an MCP server with SigV4 authorization, add it to the agent space, and allowlist the tools. Registering a custom MCP server requires third-party access to be enabled for the account.
Step 3: Create the skill and the custom agent
The skill holds the report definitions: eg how MTTR is measured, when a retrospective action counts as past SLA, section order, and the rule that every figure in the narrative must come from a tool result. The custom agent prompt holds the 5-step workflow above and references the skill and tools needed.
Step 4: Set the trigger
Triggers take EventBridge cron or rate expressions in UTC:
cron(0 13 ? * MON *)Result
The report is generated and emailed automatically every Monday at 09:00. The team no longer exports CSVs or writes it by hand. The metrics are computed in the tools from the source records, and each run's trajectory shows which tool call produced each figure.
A manual workflow became a scheduled custom agent on a service the team already operates.
Takeaways
- Teams already running AWS DevOps Agent can add reporting as a custom agent in the same web app, without a separate agent runtime or scheduler.
- Put metrics calculation in a tool If your query connectors are third party, add one MCP tool that computes the metrics deterministically.
- Any system a Lambda function can reach can be exposed as a tool through an MCP registration.
Further reading
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article