AWS Builder Center
Why Your DevOps Agent Skill Never Fires (And the Fix)

Why Your DevOps Agent Skill Never Fires (And the Fix)

Your DevOps Agent skill exists but never fires. The fix: Agent Instructions make post-investigation actions mandatory. Five-minute setup.

The Problem

A team running AWS DevOps Agent across multiple regions wanted automatic Jira ticket creation after every root cause investigation. They wrote a well-structured skill: project key, issue type, description template, priority mapping, duplicate check — the full workflow. The agent never fired it.
Every investigation completed with a summary. Then nothing. The team had to type "create a Jira ticket" every time. The skill existed. The agent ignored it.
This is not a bug. It is how DevOps Agent's architecture works — and the distinction matters for any post-investigation automation.



Root Cause: Skills Load On Demand. Instructions Do Not.

DevOps Agent has two mechanisms for guiding behaviour:
Skills define how to do something. They load on demand — the agent evaluates each skill's description against the current task and decides whether to load it. If the agent does not judge the skill as relevant, it does not load it. The "When to Use" section inside the skill never gets read.
Agent Instructions define when to do something. They are unconditional — injected into the agent's context at the start of every session before anything else happens. The agent does not decide whether to load them. They are always present.
You configure agent instructions via the Operator Web App: Agent Space → Knowledge → Instructions tab. The content is stored as an  AGENTS.md  file. You can set global instructions (apply to all agents) or agent-specific instructions (apply to a single managed agent like Incident RCA). Both paths produce the same result — an always-on markdown block the agent reads before anything else.
From the  AWS documentation :
“Unlike DevOps Agent Skills, which load on demand when the agent matches a skill description to the current task, agent instructions are always present from the start of every session, regardless of what the agent is working on.”
Aspect
Skill
Agent Instructions
Context injection
On demand (agent decides)
Always (unconditional)
Loaded when
Agent matches description to task
Every session, no exceptions
Use for
Procedures, templates, API specs
Standing policies, mandatory actions
The customer’s skill was waiting to be loaded. Nothing told the agent to load it. The fix lives in instructions, not in the skill.



The Fix

Add a standing instruction via Agent Space → Knowledge → Instructions tab → select the relevant agent (e.g., Incident RCA). This takes under five minutes:
## Post-Summary Action: Jira Bug Triage

After writing the investigation summary findings — every time, without exception —
you MUST load the `create-jira-bug-from-findings` skill and follow all of its steps
in order:

1. Categorise the incident using the five defined categories. Only proceed further
if the category is "Code bug (needs code change)".
2. Run the duplicate check against the Jira project before creating anything.
3. Create the Jira Bug ticket (if no duplicate exists and the category qualifies),
attaching the investigation link in both the description and the ticket's web links.

Do not wait for the user to ask. This is a mandatory post-summary step on every
investigation.

The skill stays unchanged. It still contains the full procedure. The instruction guarantees it gets loaded.



Three Design Choices That Matter

1. Concrete anchor point.
The instruction says "after writing the investigation summary findings." Not "when the investigation is complete."
This matters. "Complete" is ambiguous — after root cause identification? After the summary is written? After the user acknowledges? The agent cannot reliably determine when something vague has occurred.
"After writing the investigation summary" is a concrete, observable event. The agent knows exactly when it has finished writing the summary. Specificity drives reliability.
2. Categorisation gate.
Not every investigation should produce a ticket. An infra blip that auto-resolves in 30 seconds does not need a bug filed. A monitoring gap needs a Slack notification, not a Jira story.
The instruction categorises first, acts second. Only "code bug (needs code change)" proceeds to ticket creation. Everything else stops. This prevents noise tickets that erode team trust in the system.
3. Duplicate check.
Cascading failures trigger multiple investigations of the same underlying issue. Without a duplicate check, one incident produces three identical bugs. The instruction mandates a check against the project before creating anything.



The Stacking Pattern: Multiple Post-Actions

The single-action pattern extends when a customer wants different actions for different incident types. The principle: one gate per action, one skill per action, stacked in instructions.
Do not build one mega-skill with branching logic. Build multiple single-purpose skills and let the instructions orchestrate which one fires.
## Post-Summary Actions

After writing the investigation summary — every time, without exception —
categorise the incident and execute the appropriate action:

### Code bugs
If category is "Code bug (needs code change)":
Load `create-jira-bug-from-findings` and follow all steps.

### Infrastructure issues
If category is "Infrastructure (needs scaling, config, or capacity change)":
Load `escalate-to-pagerduty` and follow all steps.

### Monitoring gaps
If category is "Monitoring gap (detection delay or missing coverage)":
Load `post-monitoring-gap-to-slack` and follow all steps.

### Self-resolving
If category is "Self-resolving (no action needed)":
Log the investigation reference. Take no further action.

Each skill remains independently testable and maintainable. The instructions handle orchestration. The skills handle execution.



Outcome

After implementing this pattern:
  • Every investigation that identifies a code bug automatically creates a Jira ticket with full RCA detail, timeline, severity mapping, and follow-up actions.
  • No duplicate tickets. No noise from self-resolving incidents.
  • Zero manual intervention required. The team reviews tickets in their backlog, not in DevOps Agent.
  • Time from "investigation complete" to "tracked work item" went from minutes of manual effort to seconds of automated execution.
The team reported that adoption accelerated once the last-mile friction was removed — the Jira integration made the output useful by default, which made engineers want to use the agent more.



Key Takeaways

Principle
Guidance
Skills = how. Instructions = when.
The skill defines the procedure. The instruction tells the agent to load it. Without the instruction, the skill sits unused.
Mandatory actions belong in instructions.
If something must happen every time, it cannot depend on the agent’s skill-loading judgment. Put it in AGENTS.md.
Anchor to observable events.
“After writing the investigation summary” > “when the investigation is complete.” Ambiguity causes inconsistent behaviour.
Gate before you act.
Categorisation prevents noise. Duplicate checks prevent pollution. Both go in the instruction, before the “create” step.
Stack, do not branch.
Multiple post-actions → multiple instruction blocks, each loading a different single-purpose skill. One skill per action.



Getting Started

Prerequisite: Your Jira integration must be configured as a connection in your Agent Space before the skill can call the API. See  Configuring connections  in the DevOps Agent User Guide.
  1. Write your post-action skill. Define the full procedure (API call, field mapping, error handling) as a DevOps Agent Skill in your Agent Space.
  1. Add a standing instruction. Agent Space → Knowledge → Instructions tab → select the relevant agent (e.g., Incident RCA). Add a mandatory post-summary block that loads your skill.
  1. Include gates. Categorisation and/or duplicate checks before the action step.
  1. Test. Run an investigation. Confirm the action fires without prompting.



References

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article