Argo CD Deployment Failed: AI SRE Agent AURA Fixes It
A deployment fails validation and the sync stops. Argo CD hands the report to AURA, which finds the wrong version, fixes it, and re-runs the sync.
- Learn more about AURA → https://www.mezmo.com/aura
- Get started today → https://github.com/mezmo/aura
- Get deployment help→ https://www.mezmo.com/contact
Normally a failed sync means a person opens the application, reads the hook logs, and works out which value is wrong. Here the sync fail hook sends AURA a short failure report and an incident ID over the agent-to-agent protocol, then exits. It does not say how to investigate or what to change.
AURA works from that symptom. It checks the Argo CD operations and the hook logs, compares the evidence against live Kubernetes state in the demo namespace, and confirms the version mismatch. It updates the one config map it is allowed to change, from version 1 to version 2, and asks Argo CD for another sync. The pre-sync check passes and the application returns to synced and healthy. A final check confirms AURA still holds no wider write access.
The same run is recorded as a trace in Phoenix, so you can inspect what AURA did instead of relying on its final answer. Each model turn and each MCP tool call is a span carrying its request and its result, and the only two changes in the entire run are one config map update and one sync request.
AURA is built for platform engineers and SREs running Argo CD who want a failed deployment investigated and repaired inside limits they set, with a record of every step.
Chapters
0:00 An Argo CD deployment guardian, end to end
0:22 The healthy application and its sync hooks
0:39 Two MCP servers and one changeable config map
1:09 Starting the demo with the wrong version
1:26 The failure report arrives over agent-to-agent
1:48 Hook logs compared against live cluster state
2:11 The re-sync passes and the write limits hold
2:27 Every model turn and tool call in Phoenix
#ArgoCD #AISREAgent #GitOps
Transcript
An Argo CD deployment guardian, end to end
0:00 Hi everyone, I'm Henry. Today I'll be showing AURA as an Argo CD deployment guardian. This demo starts with a failed Argo CD deployment. Argo will send a short failure report to AURA through the agent-to-agent protocol. AURA will inspect Argo in Kubernetes, fix the cause within the limits we set, and check that the deployment recovers. I will then open Phoenix to show each model turn and tool call via AURA traces.
The healthy application and its sync hooks
0:22 On your screen you'll see that the Argo CD application is healthy and synced. Before each deployment, a PreSync hook checks a version value. If that check fails, a SyncFail hook tells AURA that the deployment failed.
0:35 Let's hop over to the AURA config.
Two MCP servers and one changeable config map
0:39 AURA can use two MCP servers. The Argo MCP lets AURA inspect this application and start a sync. The Kubernetes MCP lets AURA inspect the demo namespace. But AURA can only change one named ConfigMap.
0:57 The AURA prompt defines how to investigate and recover. The hook sends only the symptom. Now let's kick off the demo.
Starting the demo with the wrong version
1:09 The script resets the application to a known good state. It then sets the deployment contract to version 1 and starts an Argo sync.
1:18 Argo ran the validation job. The job expected version 2, found version 1, and failed. That failure started the SyncFail hook.
The failure report arrives over agent-to-agent
1:26 The failure hook sent AURA this short message. Argo CD reports that application AURA sync fail demo failed during deployment validation. The deployment did not complete successfully.
1:36 The hook also added a unique incident ID, and does not tell AURA how to investigate or what to change. AURA accepted the task over the agent-to-agent protocol so the hook could exit while AURA continued.
Hook logs compared against live cluster state
1:48 Now, this all happened very quickly, but AURA checked the Argo operations and the hook logs. It compared the evidence with the live Kubernetes state. The evidence confirmed the version mismatch, and AURA was able to update the named ConfigMap. It then requested one more Argo sync.
The re-sync passes and the write limits hold
2:11 AURA found the old version in the deployment contract and changed it from 1 to 2. Then asked Argo to sync again. The PreSync check passed and the application returned to a synced and healthy state. The final checks also confirmed that AURA has no wider write access.
2:27 Let's hop over to Phoenix.
Every model turn and tool call in Phoenix
2:30 This trace records the same AURA run. It shows the investigation, each model turn, and each MCP tool call. These tool spans record only changes AURA made: one ConfigMap update, and one Argo sync request. Each span includes the request and the result. We can inspect what AURA did, instead of relying on its final answer.
2:51 In closing, Argo sent AURA a short failure report through the agent-to-agent protocol. AURA found the cause, fixed it within the limits we set, retried the deployment, and checked the result. Phoenix gives us a record of every model turn and tool call. Thanks for watching.
More videos
