
AWS DevOps Agent Tools : Turning Operational Knowledge into Reusable Agent Skills
A practical look at how AWS DevOps Agent Tools turns operational knowledge into reusable, governed Agent Capabilities. Beyond the tooling, this article explores a broader idea: Operational Intelligence as Code. Bringing expert judgment and decision logic into the software engineering lifecycle.
Amazon Web Services recently released AWS DevOps Agent Tools, an open-source project maintained by the AWS service team. It brings together Skills, Custom Agents, MCP Servers, and the supporting infrastructure templates in one place.
The project has evolved from the DevOps Agent preview and Community Skills Gallery to a more consolidated home under the
aws GitHub organization. What interests me is not simply that these tools are now available in one repository. It's what this shift suggests about the problem we will increasingly face as agents enter production environments.How do we turn the experience of SREs, platform engineers, and operations experts into knowledge that agents can use, while making it reviewable, testable, and safe to reuse? That's what I want to explore in this post.
From runbooks to skills: bringing operational knowledge into the agent
Anyone who has operated production systems knows the value of a runbook. An Amazon EKS node becomes
NotReady . Where do you start? Database connections suddenly spiked. Do you check CPU, lock contention, or the latest deployment? P99 latency rises after a release. What do you investigate first? We have traditionally captured this knowledge in wikis, runbooks, shell scripts, or the heads of experienced engineers. But a runbook mainly solves the problem of documenting experience. It does not eliminate the need for someone to interpret and apply it. During an incident, an engineer still has to understand the context, decide what to investigate, choose the right tools, interpret the results, and determine the next step.Agents create an opportunity to change that. When domain knowledge, decision logic, and operational procedures are made available to an agent in a structured form, together with the tools it needs, parts of that investigative process can move into the agent’s decision and execution loop.
A skill is one way to make this possible. In AWS DevOps Agent Tools, a Skill is a structured set of instructions that organizes domain knowledge, decision logic, and step-by-step runbooks to guide an Agent through a specific operational task. A Custom Agent combines a system prompt, tools, and skills to address a particular operational need.
The shift from a runbook to a skill is therefore more than a change in format. Runbooks make operational experience easier to document and reuse. Skills take that experience a step further, making it available to Agents as part of how they reason and act.
Agent Capability needs its own software supply chain
Once operational knowledge starts influencing how an agent investigates a problem, selects tools, and decides what to do next, it is no longer just documentation. It becomes an Agent Capability that needs versioning, testing, review, and governance. From a software engineering perspective, it starts to behave like a software artifact.
We already know how to govern traditional software artifacts. Code goes through review. Dependencies are scanned. Container images need provenance. IAM policies need scrutiny. Agents introduce another kind of artifact: Operational Knowledge + Decision Logic + Tools + Permissions + Evaluation.
If a Skill can influence how an Agent investigates a production incident, and an MCP server can give it access to Kubernetes, VPCs, or databases, those components are effectively defining both the workflow and the boundaries of what the Agent can do. They need the same engineering discipline we apply to code: version control, review, testing, clearly defined permissions, and lifecycle management.
Agent capabilities need a software supply chain.

In the AWS DevOps Agent Tools repository, Skills, Custom Agents, and CloudFormation templates are organized separately. The project also makes an important point: these tools are provided as sample code. Before using them in production, you should test them in a non-production environment and review their IAM permissions and security configuration.
I see the repository as an emerging Agent Capability Catalog, with governance becoming part of how capabilities are distributed and reused.
A closer look at a skill: EKS Operation Review
The EKS Operation Review Skill makes this more concrete. It organizes an EKS operational review into a defined workflow. The review covers cluster configuration, Kubernetes resources, node groups, add-ons, networking, security, and workloads. It also analyzes CloudWatch metrics, control plane logs, and CloudTrail events from the previous seven days, then generates a Markdown report based on EKS best practices.
The skill’s structure is straightforward:
eks-operation-review/├── SKILL.md├── README.md├── references/│ ├── best-practices-checklist.md│ └── metrics-thresholds.md└── evals/What interests me is how the skill packages the knowledge and procedures needed to complete the task.
SKILL.md defines the task, the steps to follow, and the rules to observe; references/ supplies the best-practices checklist and metric thresholds; evals/ is used for the Skill's evaluation and validation.My simplified view of this structure is: Skill = Knowledge + Procedure + Reference + Evaluation
Greater capability requires clearer boundaries
Once an agent can act, the center of gravity for governance shifts from "can it do this" to "how far is it allowed to go." There are three engineering principles I want to emphasize: define permissions upfront, enforce boundaries outside the prompt, and expand access only when the task requires it.
Define permissions upfront
Many demos take the approach of getting the Agent working first and dealing with permissions later. In production, I would reverse that order: define what the Agent is allowed to do first, then design how it completes the task.
AWS DevOps Agent Tools reflects this approach. Each skill documents its required IAM permissions in its README; skills that need extra permissions can be configured through a CloudFormation template the repo provides.
For example, the repo offers this deployment pattern:
aws cloudformation deploy \ --template-file cloudformation/devops-agent-skill-policies.yaml \ --stack-name devops-agent-skill-policies \ --parameter-overrides ExistingRoleName=<YOUR-DEVOPS-AGENT-ROLE-NAME> \ --capabilities CAPABILITY_NAMED_IAMThe template supports permissions for different skills and can restrict access to specified AWS Regions. This may look like a deployment detail, but it reflects a fundamental design choice. Permissions should be part of an Agent Capability’s definition, not a security configuration added after deployment. Least privilege is not about making an IAM policy look elegant. It is about giving an agent only the access it needs to complete a specific task.
Enforce boundaries outside the prompt
Instructions are not enforcement.
We can put "Never modify production data." In a system prompt. But that's still an instruction. A real security boundary shouldn't depend on the Agent remembering what not to do; it should be guaranteed by permissions and system mechanisms that sit outside the Agent.
RDS Operation Review (
database-rds-devops ) is a useful example. This skill collects the configuration, networking, security, and events of RDS instances and Aurora clusters, along with CloudWatch, RDS Logs, and Performance Insights, to analyze the health of the database. What matters is how it accesses them: the information is pulled through AWS APIs, the entire review stays read-only, it reads only what the diagnosis requires, and it makes no changes to the database.When exposing a tool to an agent, I would not start by asking how much access the Agent needs to be useful. I would ask: What is the minimum capability required to complete this task?
Expand access only when necessary
The RDS Operation Review above shows a fairly clean boundary: if a read-only AWS API can complete the diagnosis, there's no need to touch the database directly. But what if that information isn't enough to pinpoint the problem? Then you need to go further, into the data plane, which also means the agent's access must be explicitly expanded.
The repo's
rds-aidba provides exactly this. It's a read-only MCP server for MySQL/PostgreSQL that runs a set of predefined database-diagnostic operations and restricts what can run through a query allowlist , rather than letting the model generate and execute arbitrary SQL.Its tools include:
execute_health_querylist_health_queriesrun_category_checkrun_full_health_checklist_clustersget_cluster_healthget_cluster_metricsget_performance_insightsProgressive access to Agent Capabilities.

What this reflects is a progressive-access mindset: start from the minimum capability and escalate step by step only when the task requires it.
Whatever can be diagnosed through the control plane, don't rush to open the data plane; and even when you do need the data plane, restrict the executable operations as much as possible. If an allowlist can bound the query scope, don't give the Agent the ability to run arbitrary SQL.
The deeper an agent reaches into real systems, the more its capability boundary needs to be explicitly defined and constrained.
Governance is about more than the model
When we discuss agent governance, the conversation often starts with the model: prompt injection, hallucinations, and output safety. These concerns matter. But for an agent operating in production, the model is only part of the risk. The agent’s ability to affect a real system also depends on the capabilities behind it. Which tools can it call? What identity does it use? What permissions does it have? Which production resources can it access?

Agent Governance must therefore answer a more practical question than how intelligent the AI is: What actions are we willing to let that intelligence take?
From this perspective, the value of AWS DevOps Agent Tools goes beyond collecting skills in a repository. The more interesting development is that knowledge, tools, permissions, and evaluation can be considered together as part of an Agent Capability’s lifecycle.
Operational experience is becoming an engineerable asset
For the past two decades, software engineering has steadily turned manual operations and rules into assets that can be versioner, reviewed, tested, and executed repeatedly. We moved from manually configuring servers to Infrastructure as Code, from manual deployments to CI/CD, and from security checklists to Policy as Code.
Agents suggest that another kind of knowledge may now enter this process: the judgment and decision-making experience involved in operating production systems.
An experienced SRE might see several abnormal metrics and check the latest deployment first. If DNS requests are timing out while application pods remain healthy, they might investigate the network path. If database CPU is normal but connection counts and lock waits are rising, they may change their investigation strategy. These are not simply steps in a runbook. They combine domain knowledge, context, decision logic, and operational experience. An engineer recognizes a signal, interprets it, decides what to verify next, and changes direction when new evidence appears. Much of this knowledge has traditionally lived in engineers’ heads.
When it is organized into skills and combined with tools, permissions, and evaluation, some of that expertise can enter an agent’s decision and execution loop. It can begin to take the form of an Agent Capability that can be versioner, reviewed, tested, and reused.

I have a name for this shift: Operational Intelligence as Code. We are beginning to engineer more than infrastructure and operational procedures. We are also exploring how to engineer the judgment and decision logic that have traditionally lived in the experience of individual engineers.
Try it yourself: EKS Operation Review
If you're exploring Agent Skills, I would not start by installing a dozen of them. Pick one. EKS Operation Review is a good place to start.
From the
skills/ directory in the public repo, you can package it the way the docs describe:cd skills
zip -r eks-operation-review.zip eks-operation-review/ \ -i '*.md' '*.txt' '*.json' '*.yaml' '*.yml' '*.xml' \ '*.csv' '*.tsv' '*.html' '*.htm' '*.png' '*.jpg' \ '*.jpeg' '*.gif' '*.svg' '*.webp' '*.pdf' \ -x '*/.claude/*' '*/scripts/*' '*/README.md' \ '*/.skilleval.yaml' '*/.skilleval.yml' \ '*/CHANGELOG.md' '*/evals/*'Once uploaded to your Agent Space, you can trigger it in plain natural language:
Review my EKS cluster prod in us-east-1 for best practices.
Audit EKS security and cost optimization.The skill guides the agent to collect data and generate a report artifact, like:
eks-review-<cluster-name>-<YYYY-MM-DD>.mdThe most interesting part is not how polished the final report looks. Pay attention to the decisions the agent makes. What data does it use? What permissions does it need? Which decisions come from the skill, and which capabilities come from its tools? If it reaches the wrong conclusion, can you trace where things went wrong?
Once you start asking these questions, you are no longer just trying an AI feature. You are designing an agent system.
Final thoughts
Skills, MCP servers, and agents do not automatically turn operational experience into reliable production capabilities. The hard part is still expressing that experience, defining its boundaries, validating its behavior, and deciding what an agent can do autonomously—and when it must stop and ask a human. But we now have an opportunity to bring something new into the software engineering lifecycle: the judgment and decision logic that have traditionally lived in engineers’ experience.
I call this Operational Intelligence as Code.
And that may be the most interesting change I see emerging from AWS DevOps Agent Tools.
References
- AWS DevOps Agent Tools — GitHub
- AWS DevOps Agent — What's new
- EKS Operation Review — AWS DevOps Agent Tools
- RDS Operation Review — AWS DevOps Agent Tools
- CloudFormation Skill policies — GitHub
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article