Ouroboros: The Self-Healing "Black Box" for DevOps

DevOps tools miss visual bugs. Ouroboros catches them. It detects "rage clicks , correlates pixels to code, and autonomously fixes broken UI logic using Gemini , and auto-deploys the patch

Comment

💡 Inspiration

We have entered the "Action Era" of AI, yet developers still rely on manual bug reports. We realized that traditional DevOps tools (like Datadog or Sentry) are great at catching server crashes (500 Errors), but they are completely blind to "Logic Zombies."

A "Logic Zombie" is a bug where the app technically works (returns 200 OK), but is broken for the user—for example, a "Pay Now" button covered by an invisible div. These bugs kill conversion rates because they leave no logs. We wanted to build an agent that doesn't just chat about code, but fixes it based on visual evidence, just like a human developer would.

🤖 What it does

Ouroboros is an autonomous "Self-Healing" agent for web applications. It acts as an immune system that lives inside the browser.

  1. The Black Box: A lightweight recorder sits in the background of the app.
  2. Frustration Detection: It detects "Rage Clicks" (when a user clicks rapidly in frustration).
  3. Visual Reasoning: It sends the video replay to Google Gemini.
  4. Diagnosis: Gemini correlates the pixels of the error with the text of the source code.
  5. Auto-Repair: The agent autonomously identifies the broken file (e.g., ProductCard.jsx), writes a patch, and pushes it to GitHub.
  6. Deployment: The fix is deployed automatically.

⚙️ How we built it

We built Ouroboros using a React frontend and a Python agent backend, powered by the Google Gemini API.

  • The Eyes (Frontend): We used the MediaRecorder API to create a "Black Box" component that buffers the last few seconds of user interaction.
  • The Brain (AI): We leveraged Gemini 1.5 Flash (and the architecture is compatible with Gemini 2.0 Flash) for its massive context window and native video understanding. This allows us to feed the entire relevant codebase + the video proof in a single prompt.
  • The Hands (DevOps): A Python script automates the Git operations, handling the "clone, patch, push" cycle without human intervention.
  • Sniper Mode: To handle rate limits and improve accuracy, we built a logic filter that only sends relevant component files to the AI, rather than the entire repo.

🧠 Challenges we ran into

  • The "Human Barrier": Automating git push was difficult because Git usually prompts for passwords. We had to configure a secure local credential store to allow the agent to act as a true autonomous employee.
  • Rate Limits: Sending video + code is token-heavy. We initially hit 429 Resource Exhausted errors. We solved this by switching to the highly efficient Gemini Flash model and implementing a "Surgical Read" function that only scans critical .jsx files.

🏆 Accomplishments that we're proud of

We successfully closed the "Loop of Autonomy." The most magical moment was seeing the "Rage Click" happen in the browser, and then watching VS Code automatically rewrite the ProductCard.jsx file 10 seconds later without us touching the keyboard. It feels like the future of software development.

🚀 What's next for Ouroboros

  • Live Production Support: Integrating with real backend logging tools.
  • Multi-File Reasoning: Allowing the agent to fix bugs that span across multiple components.
  • Voice Context: Allowing users to yell at the screen to provide audio context for the bug fix!

Built With

Share this project:

Updates