Build an Agentic Incident Triage Assistant with Amazon Quick

Problem

When a production outage strikes, engineers waste precious minutes—sometimes hours—digging through logs, dashboards, and ticketing systems. The manual loop of identifying the symptom, locating the offending service, gathering evidence, and finally creating a work item fragments focus and delays remediation. For teams that run on‑call rotations, each extra minute of triage translates directly into higher customer impact and on‑call fatigue.

What if a single natural‑language prompt could launch an automated investigation, pull the relevant telemetry, draft a concise root‑cause analysis (RCA), and create a tracked task for the next steps? The Amazon Quick blog post published on June 9, 2026 demonstrates exactly that workflow by combining Quick’s agentic capabilities with New Relic’s Model Context Protocol (MCP) server and Asana’s native integration.

Prerequisites

• Amazon Web Services account with permissions to create Quick agents and attach IAM roles.
• New Relic account that has the Model Context Protocol server enabled and API access keys ready.
• Asana workspace where incident tickets are managed, plus an API token for integration.
• Basic familiarity with JSON/YAML configuration files used by Quick agents.
• Access to a recent incident (or a simulated one) to use for testing.

Step‑by‑Step Build

1. Spin up a Quick agent project

Log into the AWS console and navigate to the Amazon Quick section. Choose “Create new agent” and give it a descriptive name such as IncidentTriageBot. The wizard will provision a Lambda‑backed execution environment and generate a default agent.yaml manifest. Keep the default runtime (Python 3.11) unless your organization has a strict language policy.

2. Attach the required IAM role

The agent needs read access to New Relic data and write access to Asana. In the IAM console, create a role named QuickIncidentTriageRole with the following policies:

• NewRelicReadOnlyAccess – allows the MCP server to be queried.
• AsanaTaskWriteAccess – permits creation of tasks in the designated project.

Attach the role to the Quick agent via the “Execution role” dropdown in the Quick console.

3. Enable the New Relic Model Context Protocol integration

Within New Relic, locate the MCP Server settings (found under “Integrations → Model Context Protocol”). Turn the server on and copy the endpoint URL and the API token. Back in the Quick project, edit agent.yaml to add a native integration block:

integrations:
  newrelic_mcp:
    endpoint: "https://api.newrelic.com/mcp"
    token: "{{NEW_RELIC_TOKEN}}"

Store the token in the Quick secret manager so it isn’t hard‑coded.

4. Hook up Asana via Quick’s native connector

Quick ships a pre‑built Asana connector. In the console, click “Add integration” → “Asana”. Paste the Asana personal access token and select the project that will receive incident tickets (for example, “Incidents – Triage”). Quick will automatically map fields such as name, notes, and due_date.

5. Define the agent’s prompt template

The heart of the assistant is a single‑prompt template that tells the agent what to do. Create a file called prompt.txt with the following structure:

You are an incident‑triage AI. When given an incident description, you will:
1. Query New Relic MCP for recent alerts, logs, and metric anomalies related to the service mentioned.
2. Summarize the findings and provide direct links to the evidence (dashboards, traces, logs).
3. Draft a brief root‑cause analysis (max 300 words).
4. Open a new Asana task in the "Incidents – Triage" project with the RCA as the description and a link to the evidence.
Respond only with JSON containing the fields: "rca", "evidence_links", "asana_task_id".

Reference this file in agent.yaml under the prompt key.

6. Wire the workflow logic

Quick allows you to chain actions using a simple YAML flow. Add the following steps to the manifest:

steps:
  - name: "CollectEvidence"
    action: "newrelic_mcp.query"
    input: "{{input.incident_description}}"
  - name: "GenerateRCA"
    action: "llm.complete"
    prompt: "{{file:prompt.txt}}"
    input: "{{steps.CollectEvidence.output}}"
  - name: "CreateAsanaTask"
    action: "asana.create_task"
    input:
      name: "Incident Triage – {{input.incident_id}}"
      notes: "{{steps.GenerateRCA.output.rca}}\nEvidence: {{steps.GenerateRCA.output.evidence_links}}"

This chain tells Quick to first call New Relic MCP, then feed the returned data to the LLM using the prompt, and finally push the result into Asana.

7. Test with a real‑world incident

Open the Quick console’s “Test” tab. Provide a JSON payload similar to:

{
  "incident_id": "INC12345",
  "incident_description": "High latency observed on checkout‑service after deployment at 02:15 UTC."
}

Run the test. If everything is wired correctly, you should see three logs:

1. Evidence fetched from New Relic (links to the latency chart and recent error traces).
2. The generated RCA brief.
3. The Asana task ID returned by the connector.

Visit the Asana project to confirm the task appears with the correct description and links.

8. Deploy to production

Once the test passes, promote the agent from the “development” stage to “production” in the Quick UI. Enable the trigger that listens to your incident‑management source (for example, a webhook from PagerDuty). From that point on, every new incident alert can be routed to Quick, which will run the workflow automatically.

Pro Tips

• Keep the prompt focused. The LLM performs best when the instruction set is concise and ordered. Avoid adding optional steps that can be handled later in Asana.
• Cache frequent New Relic queries. If the same service is repeatedly investigated, store the MCP response for a short TTL (e.g., 5 minutes) to reduce latency and API cost.
• Tag Asana tasks with incident severity. Extend the CreateAsanaTask step to include a custom field that mirrors the severity coming from the incident source. This makes downstream routing easier.
• Monitor agent health. Use CloudWatch metrics on the Quick Lambda (invocation count, error rate, duration). Set up an alarm that notifies the on‑call engineer if the agent fails more than three times in an hour.
• Iterate on evidence formatting. Early runs may produce long URLs. Trim them with URL shorteners or embed them as markdown links for better readability in Asana.

With these steps, you turn a manual triage bottleneck into a repeatable, AI‑driven process that hands off a ready‑to‑act task to your incident response team.