Sentry Governor

Autonomous agent using Fivetran MCP & Gemini to detect, remediate, and cryptographically ledger Shadow PII in real-time

Comment

Data compliance fines reach billions annually, largely due to "Shadow PII"—sensitive data that silently slips into fast-moving data pipelines. Sentry Governor uses Fivetran’s MCP and Google Gemini to autonomously detect, quarantine, and cryptographically ledger these violations before they become liabilities.

Inspiration

Modern enterprises use Fivetran to build robust, high-volume data pipelines into BigQuery. However, data governance remains a manual bottleneck. When untracked PII enters a source database, it immediately propagates downstream. We need autonomous agents that can act faster than data engineers, but AI agents have a trust problem. How do you trust an AI to modify your enterprise pipelines without it going rogue? We were inspired to build a system that not only fixes the problem but mathematically proves its own integrity.

What it does

Sentry Governor is a zero-trust, autonomous data-governance agent built for the modern data stack.

  • Discovers: Continuously scans tables synced to BigQuery.
  • Classifies: Uses Google Cloud AI (Gemini) to intelligently evaluate column data against strict, predefined "Data Contracts."
  • Remediates: Acts autonomously via the Fivetran MCP Server to instantly mask columns or halt non-compliant pipelines.
  • The "Prove-It" Ledger: Every single action the agent takes is hashed and stored in a cryptographically tamper-evident Merkle tree.

How we built it

We bypassed the "weekend script" approach and built a staff-engineer-level microservices architecture:

  • Frontend: React + Vite (hosted on Vercel) featuring a dark-mode, Series-B enterprise UX.
  • Backend: Python + FastAPI (hosted on Render) with robust CORS policies.
  • Database: PostgreSQL for persistent Data Contracts and Ledger storage.
  • AI & Partner Integrations: We used Google Gemini 1.5 Flash for its structured JSON outputs to accurately categorize ambiguous data. We used the Fivetran MCP Server as our Control Plane to programmatically execute pipeline halts.

Challenges we ran into

Achieving real-time communication between the Vercel frontend, Render backend, and the Fivetran MCP required strict environment and CORS management. More importantly, designing a lightweight Merkle tree for the cryptographic ledger that updates in real-time without blocking the FastAPI asynchronous event loop required careful architectural planning.

Accomplishments that we're proud of

Successfully wiring the Fivetran MCP to an autonomous agent. But most importantly, creating the "Prove-It" moment: a UI that live-verifies the cryptographic integrity of the agent's actions, proving to human operators that the AI is acting securely. We built an agent that enterprises can actually trust.

What we learned

We learned how to design a zero-trust architecture for AI agents. Giving an AI the power to halt an enterprise data pipeline is dangerous; learning how to mathematically ledger those actions using cryptographic hashing was a massive step forward in building safe, enterprise-ready AI.

What's next for Sentry Governor

Expanding the MCP integrations beyond Fivetran, introducing "Human-in-the-loop" (HITL) approval notifications via Slack for high-risk pipeline pauses, and containerizing the deployment for Google Kubernetes Engine (GKE) for true enterprise scalability.

Built With

Share this project:

Updates

posted an update —

Post-Sprint Update: Resilient Client Factories and Bulletproof Evaluation Baselines

We have just pushed a major architectural enhancement to the enterprise-grade-sprints branch to solidify the production resilience and evaluation safety of Sentry Governor.

What is New in this Enhancements Cycle:

  1. Production-Safe Demo Isolation (run_local_demo.py)

    • Instead of introducing dangerous, fail-open environment conditionals inside our core auth.py router (which risks accidental backdoor exposure in cloud deployments), we implemented a blessed, isolated testing pattern using FastAPI's dependency injection mechanisms (app.dependency_overrides).
    • Running python run_local_demo.py safely mocks authentication only within that local process scope, keeping our production infrastructure byte-for-byte unchanged and secure.

  2. Relaxed Input Validation and Schema Intelligence (schemas.py)

    • Refactored the /contracts POST payload schema to inject robust default configurations (fivetran_production domains and catch-all * tables).
    • This guarantees backward-compatibility for minimal webhook simulators while preventing common 422 Unprocessable Entity validation friction during automated data ingestion cycles.

  3. Cooperative Cascade Fallback Architecture

    • Hardened the system's runtime dispatch mechanism. If the primary Model Context Protocol (MCP) server or managed Agent Engine becomes unavailable, the system gracefully degrades to a generic Vertex AI loop, and finally to a rule-based deterministic parser. The ingestion loop never crashes.

  4. Dynamic Risk Calculations Verified

    • Confirmed exact compliance weights mapped against EDPB Article 83 parameters—ensuring high-risk vulnerabilities (like unmasked payment cards) dynamically price out a defensible 4.2-Million-Euro Financial Exposure Blast Radius backed entirely by automated database metadata hooks.

How to Evaluate the New Sprint Commit Locally:

git checkout enterprise-grade-sprints
cd backend
python run_local_demo.py

Log in or sign up for Devpost to join the conversation.