Give Your On-Call Its Own AI Teammate

Swaapnika Motapothula, Meta, Chinmay Gandhi, Meta, Vlad Tsvang, Meta15:41 · Nov 2026 · 328 views
Thumbnail for Give Your On-Call Its Own AI Teammate Watch on YouTube
TL;DR
  1. 1

    Meta's team proposes one AI teammate per on-call rotation, with shared context, team memory, its own identity, and a human approval boundary.

  2. 2

    The agent moves from investigation to drafting fixes to selected autonomous work when mistakes are cheap to catch and it has proved reliable on that action.

  3. 3

    The system is intended to reduce the number of decisions reaching an engineer, but the speakers have not yet measured time saved rigorously.

Summary

Meta's on-call team argues that separate alert, ticket, deployment, and incident automations leave the engineer connecting clues and choosing every next step. Their alternative is one AI teammate for each rotation. It can connect alerts, metrics, tickets, incident history, code changes, runbooks, and team memory, then bring an engineer a hypothesis, evidence, and a proposed action. The teammate follows an autonomy ladder. It first investigates, then drafts fixes for approval, and eventually handles selected lower-criticality work when errors are cheap to detect and the agent has a track record on that action. Critical production decisions remain with people, and code changes still pass review and continuous integration. The system also triages incoming work, repairs stuck automation, posts shift handoffs, and carries corrections between rotations. The speakers describe promising early signs of reduced on-call load, but explicitly reserve any time-saved claim for a rigorous study.

Key ideas
00:01

AI has sped up coding while production operations still depend on paged engineers

Chinmay Gandhi says AI now writes about three quarters of new code, and more AI-generated changes reach production. Those changes can still cause failures, while on-call work has not sped up. A high-quality change can pass review and break in production, sending someone a page at 2:00 a.m. The team therefore asks whether AI that helps write code can also help operate it. Their answer is yes, but the operational design matters because an assistant that only answers questions leaves the engineer responsible for coordinating the incident.

01:21

A reactive assistant leaves the engineer as the glue between isolated automations

In the illustrative 2:00 a.m. incident, twelve alerts fire. An engineer sorts them, chooses checkout, asks an assistant why P99 latency is high, reads the deployment and runbook findings, and receives a rollback suggestion. The assistant is useful, but it waits for each request and goes dormant after answering. Separate alert, triage, deployment, and incident agents have the same problem. One sees latency, another sees tickets, another knows about a 1:49 config change, and incident history contains similar cases. The clues exist, but the engineer has to connect them.

03:18

One teammate per rotation connects signals and keeps working before the engineer wakes up

Meta's proposal is one AI teammate per on-call rotation. It runs one loop across alerts, tickets, deployments, incidents, and other signals, with team memory, its own identity, and a human gate. In the example, it ranks the twelve alerts, merges payments into the checkout cause, reads dashboards, compares the config change, and finds two similar incidents. It gives the engineer a hypothesis, a short verification step, and a fix waiting for review. The engineer verifies the cause and approves the action without coordinating every investigation step.

05:08

Autonomy grows only when mistakes are cheap to catch and the agent has earned trust

The autonomy ladder follows the way a new engineer joins on-call. At level one, the agent investigates and changes nothing. At level two, it drafts a fix, explains the root cause, prepares a test plan, answers review comments, and fixes CI issues, but a human must approve anything that reaches production. At level three, it handles lower-criticality work and interrupts people only for decisions that matter. An action moves upward when a mistake is inexpensive, tests, CI, or review can catch it, and the agent has a record on that exact action. High-criticality mitigations remain human-owned.

07:15

The system aims to reduce the decision queue rather than merely speed up each task

A board example shows 23 incoming items, with only three requiring the engineer's decision. The agent handles noisy alerts, duplicates, and routine fixes that pass normal review and CI. Each remaining item states what it needs and offers a direct action. The same experience appears in chat and incident surfaces. A morning digest reports what needs attention, what was handled, and what remains in progress. In the checkout example, the agent provides the evidence, answers whether the issue affects only Europe, drafts the rollback, and lets the engineer approve it in the thread without opening a dashboard.

09:31

Triage, recovery, and handoffs run as continuing automation loops

The teammate starts an investigation for every new signal. It classifies the signal, checks criticality, and sends an alert, task, test failure, or lookup to the appropriate agent, team skill, coding agent, or memory search. A second loop checks for stuck or failed runs, repairs broken schedules, and pages a human only when it cannot recover. A handoff loop summarizes each shift and each morning at 9:00, including work that needs attention with a draft fix and work completed independently. Urgent issues are sent to chat with findings and proposed fixes, while the next on-call person is tagged.

11:44

Team-owned identity and memory carry operational knowledge across shifts

The agent belongs to the rotation rather than to one person. It has the team's playbook, alert profiles, past decisions, access permissions, agents, and skills. In the example, Sam teaches it to roll back a conflict first when checkout times out after a conflict push. Three days later, Jordan asks for a fix and receives the source of that instruction with a rollback draft. Handoffs, decisions, and corrections enter shared memory. The system retrieves entries semantically, scores whether they helped, and promotes or retires them. When someone marks an entry wrong, the correction reopens the item and becomes new memory.

13:24

Feedback and customization are part of the operating model

The speakers describe three design choices for team adoption. Feedback and course corrections reopen work and enter the memory loop instead of being reviewed only occasionally. Teams customize the same teammate with their own playbooks and skill workflows rather than forking the system. Identity, configuration, and memory belong to the team, so moving the setup to another rotation does not create a new project. Their next work includes measuring accepted mitigations, turning runbooks into skills from chat, and studying time saved with a rigorous method rather than usage counts.

"An on-call agent can belong to just a single person because the on-call itself doesn't."Vlad Tsvang11:49
Who should watch
  • You maintain separate alert, ticket, deployment, and incident automations, and engineers still have to connect their findings during pages.
  • Your team wants to give an operational agent more autonomy while keeping production mitigations and code review under human control.
  • You need a design for carrying runbooks, corrections, and incident decisions from one on-call shift to the next.