CineMesh ADK: Autonomous Studio Backlot

An event-driven multi-agent mesh using Google Cloud ADK & Gemini to instantly turn live film script edits into compliant budgets, VFX prompts, and production schedules via RAG & MCP.

Comment

💡 Inspiration

As recent industry research highlights, generative AI and agentic workflows are poised to fundamentally reinvent film and television production, potentially unlocking hundreds of billions in value. Yet today, uncoordinated live-set revisions still cause massive budget drift—sometimes upwards of 22%—when script changes take hours or days to filter down to crew departments.

We realized that media production doesn't need another creative writing chatbot; it needs a deterministic AI control plane. We were inspired to build CineMesh ADK to bridge human chaos (unstructured live-set script revisions) into strict enterprise systems (structured code, budgets, and compliance).

⚙️ What it does

CineMesh is an autonomous, event-driven multi-agent orchestration backlot. When a director or screenwriter publishes a live screenplay change (e.g., changing a daytime dialogue scene into a 3 AM high-speed motorcycle stunt in the rain), CineMesh treats the edit as an event stream.

The Orchestrator extracts a complex state schema and dispatches tasks asynchronously to five specialized agents:

  1. Governance Agent (RAG): Audits SAG-AFTRA union compliance (child labor limits, pyrotechnics, vehicle stunts).
  2. Continuity Agent (MCP): Detects weather, prop, and wardrobe drift from previous scenes.
  3. Budget Controller (LLM): Calculates dynamic INR burn rates based on crew overtime, hazard infrastructure, and A-list talent tiers.
  4. Scheduler Agent (LLM): Rebuilds daily call sheets based on mandatory 12-hour turnaround safety rules.
  5. VFX & Art Agent (LLM): Generates extremely detailed Imagen 3 concept prompts and itemized CG post-production manifests.

🛠️ How we built it

We utilized Google Cloud Agent Development Kit (ADK) and Gemini 2.5 Flash as the core engine, utilizing IBM Bob to scaffold, refactor, and optimize our microservice workflows.

  • The Backend: Built with Python and FastAPI. We implemented true RAG (Retrieval-Augmented Generation) using embedding-001 vector search against a union rulebook text file. We also implemented the Model Context Protocol (MCP) pattern, allowing our Continuity Agent to securely query a local SQLite database (production_state.db) for historical scene context rather than relying on LLM memory.
  • Scalability: We wrapped the synchronous google-genai SDK calls inside Python's asyncio thread pool. This allows all 5 agents to execute concurrently, reducing latency from ~40 seconds down to ~19 seconds.
  • The Frontend: An executive observability dashboard built with React, TypeScript, Framer Motion, and Tailwind CSS v3, featuring real-time system telemetry and latency trace logs.

🚧 Challenges we ran into

  • Schema Drift: Initially, our Budget LLM would creatively invent its own nested JSON keys instead of outputting what our React frontend expected. We solved this by enforcing strict types.Schema constraints on the response_schema parameter in the Gemini API.
  • Synchronous Bottlenecks: Waiting for five LLM agents to execute sequentially created an unacceptable UX. We had to heavily refactor our FastAPI backend to implement asynchronous concurrent threading to fire all agents in parallel.
  • CSS Framework Conflicts: Migrating the frontend to Tailwind v4 broke our custom cinematic theme, requiring a rapid downgrade to v3 and a PostCSS configuration rewrite to restore the UI.

🏆 Accomplishments that we're proud of

  • Zero Mocking: We built real RAG and real MCP database queries. The system actually reads rulebooks and queries SQLite.
  • Enterprise Observability: We successfully implemented a System Telemetry panel on the frontend that tracks the exact execution latency and HTTP status of every individual sub-agent.
  • Advanced LLM Reasoning: Our Governance agent successfully understands the semantic difference between "working hours" and "turnaround rest time," actively protecting the studio from union violations based on contextual clues.

📚 What we learned

  • Multi-agent workflows drastically outperform massive single-prompt generation. Breaking the studio down into specialized "departments" (Budget, Legal, VFX) yielded incredibly accurate and predictable JSON outputs.
  • Strict JSON schema enforcement is non-negotiable for enterprise AI; without it, the frontend UI shatters.
  • Integrating AI coding assistants like IBM Bob exponentially speeds up the refactoring process, especially when debugging complex CORS issues or asynchronous Python threads.

🚀 What's next for CineMesh ADK

  • Event-Driven Messaging: Transitioning from REST APIs to Apache Kafka/Confluent so that when a scene updates, different crew departments get real-time push notifications on their iPads.
  • Active Generative Sub-Agents: Wiring the VFX Agent directly to the Imagen 3 API so the dashboard renders actual visual concept art alongside the text prompt.
  • Dynamic RAG: Expanding the vector database to include multi-region film union rules (Hollywood, Tollywood, Bollywood) so the agents can dynamically adjust budgets and labor laws based on GPS shoot locations.

Built With

Share this project:

Updates

Submission history