SentinelMesh

• 

  Main Dashboard

• 

  Multi-Agents

• 

  Runs and Access

• 

  Observability

Inspiration

Modern film and media production is increasingly becoming an agentic workflow: different AI agents can handle scheduling, production coordination, asset access, compliance checks, reporting, and other operational tasks.

But giving multiple autonomous agents access to production systems creates a new problem: who controls what an agent is allowed to do?

A scheduling agent shouldn't automatically be able to access unreleased footage. A reporting agent shouldn't be able to modify production assets. And when an agent produces a malformed or unsafe response, it shouldn't be trusted simply because an LLM generated it.

SentinelMesh is built around the idea that autonomous agents need a governance layer before they can safely operate in real media-production workflows.

It acts as a control plane between AI agents and the systems they interact with—enforcing deterministic policies, controlling access, recovering from failures, and creating an auditable record of critical decisions.

How the demo maps to media production

The deployed demonstration uses a research-lab scenario as a concrete test environment for SentinelMesh's governance runtime. The scenario is intentionally focused on exercising the underlying agent-governance mechanisms—scoped access, policy enforcement, injection detection, failure recovery, and auditable decisions—rather than simulating a specific studio software stack.

For Agentic Cinema, the same governance runtime is applied to autonomous agents operating in film and media production workflows. The production equivalent is a network of agents handling tasks such as scheduling, production coordination, compliance, reporting, and access to sensitive production resources.

For example, a Scheduling Agent may request access to production data while an Asset Agent may request access to restricted production assets. SentinelMesh evaluates each request against deterministic policies and can allow, deny, or require escalation to a human operator. Every critical decision is recorded for accountability.

This distinction is important: the demo is showing the reusable governance infrastructure and its working security mechanisms, while the target application for this challenge is the governance of autonomous AI agents used by filmmakers and studio production teams.

What it does

SentinelMesh is a multi-agent governance runtime for film and media production workflows. It routes tasks to specialized agents while enforcing deterministic authorization and safe execution boundaries.

Compliance Monitor — reads compliance and deadline information from Firestore, classifies risk, and produces structured summaries for production operators.

Data Access Agent — enforces scope-based access rules and quarantines suspicious requests, combining deterministic pattern matching with a semantic Gemini-based injection classifier. Suspicious requests fail closed by default.

Reporting Agent — synthesizes cross-agent activity into structured operational reports, giving production teams visibility into what happened across the agent network.

Policy Twin — provides a read-only counterfactual explanation for denied requests: why the action was blocked and what policy conditions would need to change. It can explain a decision but can never grant access itself.

Orchestrator — routes tasks by intent and manages a bounded retry-and-fallback loop:

timeout → retry → schema validation → safe fallback

This prevents malformed, incomplete, or hallucinated agent responses from silently propagating through a production workflow.

How we built it

SentinelMesh uses Gemini and Google Cloud as the intelligence and execution foundation:

• Gemini 3.5 Flash via Vertex AI — model-based reasoning and semantic security classification, with authentication handled through the Cloud Run service account's Application Default Credentials.
• Google ADK — each specialized agent is implemented as a real Agent + Runner rather than simply wrapping a direct model API call.
• Cloud Run — is configured to host the production backend and frontend as a unified deployed service.
• Firestore — stores the agent registry, compliance items, access rules, session memory, and event history.
• Cloud Logging — provides structured telemetry for agent actions and governance decisions.
• Replit — used during development with Replit Agent, with the finished application deployed directly to Replit for the Replit track.

The key architectural principle is that the model does not control authorization.

Gemini can classify, reason, and flag suspicious behavior, but the final authorization decision remains in deterministic application code.

Challenges we ran into

One of our biggest challenges was ensuring that an agentic system remains trustworthy when individual components fail.

Our frontend and backend were initially developed somewhat in parallel, and we discovered a real mismatch late in development: the UI called four endpoints — /dashboard, /activity, /compliance-items, and /reports/weekly — that weren't yet available in the deployed backend.

We closed that gap and added route-level test coverage against the actual FastAPI handlers rather than relying only on isolated policy tests.

Security was another challenge.

Pure keyword-based injection detection was too brittle, so we added a semantic Gemini-based classification layer. However, we deliberately did not allow the model to make authorization decisions.

The architecture became:

Gemini detects suspicious behavior → deterministic policy engine decides → system allows, denies, or escalates.

We also encountered a subtle Vertex AI deployment issue: a Cloud Run service can deploy successfully while still being unable to make Gemini calls if its runtime service account lacks the required permissions. We added deployment checks to catch this before runtime.

Accomplishments we're proud of

The most important accomplishment is that the governance mechanisms are actually executable rather than just architectural claims.

The failure-recovery path is real and tested:

malformed/timeout → bounded retry → corrective prompt → schema validation → safe fallback

A failed agent does not simply crash the workflow, and an invalid response is never silently treated as trustworthy.

We're also particularly proud of Policy Twin.

When an agent's action is denied, a human operator can inspect the counterfactual explanation without giving the system a backdoor around its own security policies.

Route-level and policy tests cover the FastAPI handlers, recovery logic, and governance policies, providing coverage beyond a visual prototype.

What we learned

The most important lesson was that the biggest risk in an agentic system isn't necessarily a slow model call.

It's trusting an output that should never have been trusted in the first place.

An LLM can produce a response that looks structured, plausible, and convincing while still being malformed or unsafe.

That's why SentinelMesh treats schema validation, deterministic authorization, and bounded failure handling as first-class components of the agent runtime.

The model provides intelligence.

The governance layer provides boundaries.

What's next for SentinelMesh

The next step is to make SentinelMesh more deeply integrated into real media-production environments.

We're planning to expand the Agent Registry into a discovery interface for production teams, strengthen per-agent identity and IAM-backed permissions, and extend Policy Twin from single-request counterfactuals to multi-step remediation simulations across complex production workflows.

Ultimately, SentinelMesh is intended to provide the governance layer that lets film and media teams scale from a few AI assistants to networks of autonomous production agents without losing control, accountability, or trust.

Built With

• agentic-ai
• ai-agents
• artificial-intelligence
• docker
• film
• generative-ai
• google-agent-development-kit-(adk)
• google-cloud
• google-cloud-firestore
• google-cloud-logging
• google-cloud-run
• google-gemini
• google-vertex-ai
• html5
• media
• multi-agent-system
• opentelemetry
• pydantic
• python
• react
• replit
• rest
• tailwind-css
• typescript
• vite