Pipeline-Sentry

Pipeline Sentry is an autonomous multi-agent healer using Google ADK & MCP to intercept Fivetran failure webhooks, safely auto-deploy live credential/schema repairs, and instantly alert Slack.

Comment

The Pipeline Sentry Story 🛡️

A journey of late-night awakenings, agentic breakthroughs, and the quest for uninterrupted sleep.

💡 Inspiration

My roommate, Dinesh, is a Data Engineer managing hundreds of Fivetran pipelines for a local agency. Whenever a connector broke—due to expired tokens or schema drift—an automated alert would wake him up at 3:00 AM. He’d flip on our room lights to manually patch the connection, completely ruining my sleep before morning classes.

One night, I finally snapped. As someone working in Agentic AI, the manual grunt work made no sense to me: Why is a human waking up to do a machine's job?

Right there, we designed Pipeline Sentry. We combined the Google ADK with the Model Context Protocol (MCP) to build an autonomous multi-agent system that intercepts failure webhooks, reasons through the root cause, and deploys live configuration fixes instantly.

We built it to heal broken data infrastructure autonomously—but mostly, we built it so we could finally get some sleep!

🤖 What It Does

Zero-Touch Infrastructure Healing

Pipeline Sentry acts as an on-call AI DevOps engineer that fixes data infrastructure breakdowns before your team even wakes up. It shifts the burden of infrastructure maintenance from late-night laptop debugging to simple, one-tap mobile approvals.

🔄 The Autonomous Healing Flow

  • Detect & Wake Up: The moment a Fivetran pipeline fails, our FastAPI backend catches the webhook and wakes up the Coordinator Agent, seeding a fresh state session in Google Cloud Firestore.
  • Plan & Delegate: The Coordinator diagnoses the error payload, builds a remediation plan, and passes execution control to the fivetran_expert sub-agent.
  • Draft the Fix: Equipped with the Model Context Protocol (MCP), the sub-agent queries Fivetran’s APIs, stages the exact configuration or credential fix, and generates a clean, one-line triage report.
  • One-Tap Mobile Approval: Instead of forcing engineers to open laptops or parse dense logs, Pipeline Sentry drops an interactive alert directly into Slack.

📱 The Mobile-First Developer Experience

  1. Review the Alert: The pipeline manager receives a clean, high-signal triage report on their phone detailing exactly what broke and how to fix it.
  2. Approve or Deny: Without leaving the Slack mobile app, the manager simply replies to the thread with an approval or drops in a fresh token: text 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
  3. Auto-Repair & Resync: The agent automatically captures the input, executes the live configuration repair using its MCP tools, and triggers an immediate Fivetran resync.
  4. Back to Sleep: Once the sync passes successfully, the agent sends a final confirmation notification. The data manager can freely go right back to sleep, knowing the data warehouse is fully recovered.

🛠️ How We Built It: The Core Architecture

To bring Pipeline Sentry to life in under 24 hours, we combined cutting-edge agentic frameworks, specialized communication protocols, and a high-performance web core.

Here is how the components work together as a cohesive system:

  • The Brain (Google ADK): Google’s Agent Development Kit serves as the central reasoning engine. It ingests the raw infrastructure failure logs, creates a step-by-step remediation plan, manages state variables inside Google Cloud Firestore, and coordinates tasks between sub-agents.
  • The Muscle (Model Context Protocol): We integrated a dedicated Fivetran MCP Server. This gives our agents the "superpowers" needed to securely interact with the outside world—allowing the sub-agents to read pipeline configurations, update access tokens, and trigger remote data resyncs safely.
  • The Supervisor (Slack Interface): To ensure the AI never performs unintended actions, we built an interactive Slack layer. This keeps a Human-in-the-Loop via mobile notifications, allowing an engineer to approve a fix or provide a fresh API key with a single tap.
  • The Central Hub (FastAPI): A lightweight, asynchronous Python web server that orchestrates the entire operation. It instantly captures incoming Fivetran failure webhooks and routes traffic dynamically between Slack, Firestore, and the ADK runtime.

🌐 Architectural Data Flow

[Fivetran Webhook] ──> [FastAPI Hub] ──> [Google ADK Brain] ──> [Slack Mobile Approval]
                                                │
                                                └──> [MCP Server] ──> [Live Fivetran Fix]

Built with an asynchronous architecture designed to eliminate data warehouse downtime while keeping engineers firmly in control.

🚧 Challenges We Ran Into

Building an autonomous infrastructure healer in 24 hours came with serious architectural and deployment hurdles. Here is what we faced and how we fought through it:

  • Architectural Analysis Paralysis: We struggled to choose the right agent topology. A Single-Agent setup was fast and reliable but struggled with complex tool calls. A Graph Workflow offered maximum control and error handling but risked adding latency. We ultimately chose a Collaborative Multi-Agent Workflow using Google ADK, delegating high-level reasoning to a Coordinator and pure execution to a specialized Fivetran MCP sub-agent.
  • The MCP Deployment Puzzle: Model Context Protocol (MCP) servers typically run locally. Integrating an active MCP server into a hosted, containerized FastAPI backend without turning our codebase into a messy, unmaintainable tangle of subprocesses was incredibly difficult. We had to carefully isolate the tool-calling layer to keep things modular and clean.
  • The Onboarding Bottleneck (The Unsolved Challenge): Making this easily testable for hackathon judges was tough. We wanted a seamless experience, but setting up a Slack app natively requires specific bot tokens, workspace permissions, and dynamic webhooks for every single user. Due to the tight time constraint, we couldn’t build a fully isolated multi-tenant testing simulator, so we chose to provide a clear step-by-step video demo alongside a live test workspace.

📉 Complexity Trade-Off Analysis

When deciding on our agent architecture, we had to balance system control against implementation speed:

$$Complexity \propto Agents \times Connections$$

By selecting a two-agent hierarchy over a complex graph, we minimized state tracking bugs while preserving specialized tool execution.

Built with resilience, quick pivoting, and intense late-night debugging sessions in our Kota dorm room.

🏆 Accomplishments That We're Proud Of

  • Consistent execution: I am incredibly proud of staying committed and working consistently on a highly complex engineering project for an entire month, pushing through multiple failures and refactors.
  • Mastering next-gen tech: We successfully climbed a steep learning curve in a short time, mastering advanced tools like the Google ADK and the Model Context Protocol (MCP).
  • A real step toward automation: While it requires a human-in-the-loop for final approvals, we successfully built a functioning, robust framework that represents our first major step toward true autonomous infrastructure healing.

Built with resilience, grit, and the willingness to fail forward until the system finally worked.

🧠 What We Learned

  • The discipline to stay focused: I learned how to stick to one thing and see it through, ignoring all the flashy new tools and hype technologies out there.
  • What real problems look like: I gained a true understanding of what a real-world production problem looks like and how to build a practical solution for it.
  • Cloud deployment: I learned how to deploy services on Google Cloud Run and manage production infrastructure.
  • The power of agents: I had an amazing experience working with a real agent framework and seeing firsthand how autonomous systems can solve actual problems.

🔮 What's Next for Pipeline Sentry

  • A seamless testing frontend: Our immediate next step is to build a clean, intuitive dashboard so judges, developers, and users can trigger simulated failures and watch the agent resolve them in real time without any setup friction.
  • Expanding the agent army: We plan to add more specialized sub-agents to handle a wider variety of infrastructure platforms beyond Fivetran, such as Airbyte, dbt Cloud, and custom Cron jobs.
  • Achieving true autonomy: We want to minimize human interaction even further by training the agents to safely handle more edge cases—like self-generating tokens via OAuth refreshes—so the pipeline can fix itself completely automatically while the manager sleeps.
  • One-click deployment: We aim to pack Pipeline Sentry into an easy-to-install template so any data team can securely connect it to their own workspace and cloud infrastructure in minutes.

Built With

  • cloud-run
  • fastapi
  • gemini
  • google-adk
  • llm
  • mcp
  • python
  • slack-event-commmands
  • slack-webclient
  • uvicorn
Share this project:

Updates