SentinelMesh

Multi-agent governance runtime for research labs — policy-enforced access control, automatic failure recovery, and auditable decisions on Gemini 3.5, ADK, and Cloud Run.

Comment

Inspiration

Research labs juggle enterprise-scale compliance complexity — grant renewals, IRB deadlines, cross-PI data-sharing rules — with none of the enterprise tooling a corporation would have. That gap is usually tracked in spreadsheets and email. SentinelMesh is built for that "unlikely hero": a small institution that needs real AI governance without an enterprise budget.

What it does

SentinelMesh is a multi-agent governance runtime that routes real compliance and data-access tasks to specialized agents, enforces access policy deterministically, and recovers automatically when something fails:

  • Compliance Monitor — reads grant/IRB deadlines from Firestore, classifies risk, drafts summaries
  • Data Access Agent — enforces scope-based access rules and quarantines suspicious requests, combining deterministic pattern matching with a semantic Gemini-based injection classifier that fails closed by default
  • Reporting Agent — synthesizes cross-agent activity into a weekly digest
  • Policy Twin — a read-only counterfactual endpoint that explains why an access request was denied and what would change the outcome, without ever granting access itself
  • Orchestrator — routes every task by intent, with a bounded retry-and-fallback loop (timeout → retry → schema validation → safe fallback) so a malformed or hallucinated agent response never silently propagates

How we built it

  • Gemini 3.5 Flash via Vertex AI (no embedded API key — auth flows through the Cloud Run service account's Application Default Credentials)
  • Google ADK — every agent is a real Agent + Runner object, not a direct API call wrapped in ADK's name
  • Cloud Run + Firestore + Cloud Logging — single Cloud Run service serves both the FastAPI backend and the built React frontend from one Docker image; Firestore holds the agent registry, compliance items, access rules, session memory, and event log; every decision is logged as structured, auditable telemetry

Challenges we ran into

  • Our frontend and backend were built somewhat in parallel, and we caught a real mismatch late: the UI called four endpoints (/dashboard, /activity, /compliance-items, /reports/weekly) that didn't exist yet in the deployed backend. We closed that gap and added real test coverage for the actual FastAPI routes, not just the isolated policy logic.
  • Getting the injection defense right took iteration: pure keyword matching alone was too brittle, so we added a second, semantic classification layer — but made sure the underlying authorization decision always stays in deterministic Python code. The model can flag a request as suspicious; it can never grant access.
  • Vertex AI permissions are an easy silent failure — a Cloud Run service can deploy successfully and still fail every Gemini call if the runtime service account lacks roles/aiplatform.user. Our deploy script now checks for this before deploying, not after.

Accomplishments we're proud of

  • The failure-recovery path is real and tested, not just described — a malformed or timed-out agent response gets a bounded retry with a corrective prompt, and only falls back to a safe, clearly-labeled response after that, never a crash and never silently bad data.
  • The Policy Twin gives a human operator an actionable explanation for a denial without ever weakening enforcement — it's explicitly non-executable.
  • Full test suite (route-level and policy-level) passes against the real FastAPI handlers, not just isolated functions.

What we learned

The highest-risk failure mode for an agentic system isn't a slow model call — it's accepting a malformed structured response as if it were valid. Schema validation before trusting any agent output turned out to matter more than almost anything else we built.

What's next for SentinelMesh

Expanding the Agent Registry into a real discovery interface other institutions could query, hardening the same-origin gateway check into full per-agent IAM-backed identity, and extending the Policy Twin to simulate multi-step remediation paths rather than single-request counterfactuals.

Built With

Share this project:

Updates

Submission history