It's 2 in the morning. PagerDuty starts beeping. You get up, try to open your eyes, look for your laptop, connect the VPN and pass the two-factor authentication. 20 minutes have passed and you are still staring at an empty dashboard trying to understand why the core system has gone down.

The Commonwealth Bank of Australia (CBA) has changed this dynamic. They haven't eliminated on-call shifts, but they've thrown an AWS DevOps Agent into the equation to do the dirty work while the engineer boots up.

The technical concept: Alert forking

Instead of the resolution flow being linear—where the machine alerts the human and the human starts the investigation—the CBA infrastructure team does a fork at the moment of the incident.

PagerDuty still calls the engineer, but in that same millisecond it injects the entire alert payload to the AI agent.

While you make a coffee and turn on your laptop, the agent is already executing queries, correlating metrics and looking for anomalies in the database or the network. When you finally manage to enter the system, you're not starting from scratch. You have a summary of the incident, the most likely root cause and a list of suggested mitigation actions.

The initial problem shifts from "where do I start looking?" to "do I agree with the machine's diagnosis?".

Grounding the concept

Imagine a classic network problem: containers in a Kubernetes cluster cannot communicate with an RDS database. An on-call engineer could spend hours crossing logs from different services to see what broke and when.

The DevOps agent acts differently. It receives the alarm webhook and its internal logic, possibly supported by an LLM configured with restricted read permissions, executes a series of automated checks through the cloud provider's API.

# Simplified logic flow of how the agent would operate
def handle_incident_alert(alert_payload):
    resource_id = alert_payload['affected_resource']

    # 1. The agent extracts recent network logs
    vpc_logs = aws_client.get_flow_logs(resource_id, time_window="-15m")

    # 2. Reviews recent infrastructure changes
    cloudtrail_events = aws_client.get_recent_api_calls(event_name="AuthorizeSecurityGroupIngress")

    # 3. Correlates and generates diagnosis
    prompt = f"Analyze these flows {vpc_logs} and recent events {cloudtrail_events} for {resource_id}"
    diagnosis = llm.generate_insights(prompt)

    # 4. Delivers context to the engineer
    pagerduty.append_notes(alert_payload['incident_id'], diagnosis)

Instead of manually throwing SQL queries at the logs or reviewing the deployment history, the agent quickly detects that someone modified an inbound rule in the database Security Group right before the outage. It hands you the ID of the affected resource and the confirmation of the changed rule.

The harsh reality of the system

Jason Sandery, the bank's head of cloud services, made it clear: the agent isn't magic. It doesn't solve the problem completely on its own, it simply removes the initial dead time. They reduced the root cause identification time from a multi-hour investigation to a 30-to-50 minute window.

Let's accept that the tool will have its flaws. Sometimes the agent will spit out hallucinations or drown in noise if the problem is subtle, like a very specific concurrency race condition. In those cases, you'll have to roll up your sleeves anyway. But if it's an outage caused by expired certificates, exceeded API quotas, or a misapplied infrastructure deployment, the machine will isolate the error before you finish stretching.

To go a step further, the bank uses another internal agent called Patchwork. If the root cause of the problem is determined to be code or Infrastructure as Code (IaC), this second agent drafts the patch and proposes it. Always with a human reviewing and approving the final pull request.

I find this to be a colossal paradigm shift. Going from maintaining systems that we only operate reactively, to designing ecosystems that observe their own state, reason about alarms, and hand you chewed-up context at the most critical moment of the night.