Agentic Studio OS

An autonomous agent operating system that turns screenplays into production-ready shot breakdowns, vector storyboards, and Grafana telemetry using Google ADK, Gemini 2.5 Flash, and Cloud Run.

Comment

An agentic operating system that turns a film production goal into coordinated AI action.

Inspiration

Traditional virtual film production is fundamentally fragmented across disconnected tools and siloed departments:

  • Screenplays locked in Final Draft
  • Scene breakdowns managed in static spreadsheets
  • Storyboard frames created in Photoshop
  • Camera blocking isolated in specialized 3D software
  • Infrastructure reliability buried in separate cloud consoles

The deeper problem isn't simply that these tools don't talk to each other. Film production is an interconnected dependency graph.

When an executive or director changes a scene, lighting plan, cast decision, or production constraint, the consequences can ripple across schedules, budgets, continuity, assets, and downstream decisions.

We asked a foundational question:

What if a Hollywood studio had its own agentic operating system?

Instead of using AI as another isolated creative tool, we built Agentic Cinema OS (Agentic Studio OS): a coordinated production system that combines specialized agents, deterministic production orchestration, persistent production state, generative AI, observability, and human governance.

An executive provides a high-level production directive. The system coordinates specialized domain agents — Producer, Director, Screenplay, Character, Storyboard, and Supervisor — around a shared Production Digital Twin.

The agents and production services decompose goals, analyze production inputs, generate cinematic specifications, create visual keyframes, monitor infrastructure telemetry, update production state, and escalate consequential decisions for human approval.

The result is a studio where AI doesn't simply generate content.

It coordinates production.

What It Does

Agentic Studio OS is an autonomous multi-agent operating system for virtual film production and creative pre-production.

1. Goal-Driven Production Orchestration (/judging)

Through the Autonomous Control Center, an executive can enter a natural-language production directive such as:

"Coordinate the production workflow for the Mars Colony Outpost screenplay, generate a visual storyboard keyframe, evaluate Grafana telemetry, and request a human greenlight."

The system converts the directive into an executable production workflow.

A deterministic Producer orchestration layer decomposes the goal into a directed acyclic graph (DAG), while specialized domain services and agents execute the required production steps.

The workflow provides an observable path from:

Goal → Planning → Cinematic Analysis → Storyboard → Observability → Human Approval

2. Screenplay Ingestion → Production Intelligence (/screenplay-room)

The system accepts genuine screenplay files in:

  • .fountain
  • .txt
  • .fdx (Final Draft XML)
  • .pdf

The screenplay pipeline dynamically extracts:

  • Scene sluglines
  • Characters
  • Dialogue
  • Acts
  • Scene structure
  • Page estimates

The extracted production information can then become part of the Production Digital Twin.

Most importantly, the system is designed to fail honestly. Empty, malformed, or unsupported screenplay files produce explicit errors instead of silently replacing the input with hardcoded demo scenes.

3. Cinematic Reasoning & Live SVG Storyboarding

The Director Agent applies cinematic domain rules to screenplay context and produces structured specifications for camera, lighting, composition, and visual treatment.

For example, a scene can be translated into specifications such as:

  • 35mm anamorphic framing
  • 8:1 chiaroscuro contrast
  • cinematic color palette
  • blocking and composition guidance

The Storyboard Agent then compiles these specifications into a visual generation request.

Google Gemini 2.5 Flash generates the resulting high-density vector SVG storyboard keyframe, producing layered visual composition, lighting gradients, depth, and cinematic framing.

This gives the production workflow a fast visual representation without requiring a heavyweight raster-rendering pipeline.

4. Autonomous Observability with Grafana MCP

The Supervisor Agent connects production intelligence with operational observability.

Agentic Cinema OS integrates with Grafana Cloud using the Model Context Protocol (MCP) over JSON-RPC 2.0.

The Supervisor can:

  1. Discover available Grafana tools
  2. Query live Prometheus/Mimir telemetry
  3. Provide the telemetry to Gemini for diagnostic reasoning
  4. Produce an operational diagnosis
  5. Publish the resulting production annotation back to Grafana Cloud

This creates a closed loop:

Live telemetry → MCP tool call → Gemini reasoning → production diagnosis → Grafana annotation

Observability therefore becomes part of the production decision loop rather than a separate monitoring dashboard.

5. Human-in-the-Loop Governance

Autonomy does not mean removing human authority.

Consequential production decisions are routed through an explicit Human-in-the-Loop (HITL) approval gate.

When an executive approves or rejects a production action, the backend records the decision in SQLite and generates a deterministic SHA-256 audit signature.

The authoritative signature is returned by the backend and persisted with the decision, providing a verifiable record of the approval state.

This creates a clear boundary:

AI can coordinate and recommend. Humans retain final authority over consequential decisions.

How We Built It

Agentic Cinema OS combines Google AI, Google Cloud infrastructure, deterministic production orchestration, persistent state, and enterprise observability.

Google Agent Development Kit (ADK)

The system uses a six-agent architecture consisting of:

  • Producer
  • Director
  • Screenplay
  • Character
  • Storyboard
  • Supervisor

The agents share structured execution contracts and production state. Some domain components intentionally use deterministic orchestration and cinematic rules rather than invoking an LLM for every operation. This makes portions of the workflow reproducible, fast, and easier to govern.

Google Gemini 2.5 Flash

Gemini powers the parts of the workflow where generative reasoning provides direct value, including:

  • Visual storyboard synthesis
  • Infrastructure diagnostic reasoning
  • Text generation through the provider abstraction

The system deliberately combines generative AI with deterministic production logic rather than treating every production operation as an LLM call.

Production Backend

A FastAPI backend provides:

  • Asynchronous production workflows
  • WebSocket event broadcasting
  • SQLite WAL persistence
  • Thread-safe state management
  • Deterministic specification hashing
  • Idempotent job handling
  • Persistent production events and approvals

The backend maintains the shared production state that allows different parts of the system to operate against the same production model.

Production Digital Twin

The Digital Twin represents relationships between production entities such as:

  • Scenes
  • Shots
  • Assets
  • Budgets
  • Production events
  • Approvals

This shared state is what allows Agentic Cinema OS to treat film production as a connected system rather than a collection of isolated AI prompts.

Grafana Cloud + MCP

The Supervisor integrates with Grafana Cloud through MCP tools including:

  • query_prometheus
  • list_datasources
  • create_annotation

Live telemetry can therefore enter the agent workflow and result in an observable production decision.

Google Cloud Run

The backend is deployed on Google Cloud Run, providing the production runtime for the API and agent orchestration services.

Firebase Hosting

The React + TypeScript + Vite interface is deployed through Firebase Hosting.

Google Secret Manager

Production credentials for cloud services are isolated from the frontend and stored through Google Cloud secret management rather than exposed in the client application.

Challenges We Ran Into

Multi-Agent State Integrity

Coordinating multiple production operations around shared state introduced risks around duplicate executions, race conditions, and inconsistent state.

We addressed this with durable event logging, deterministic specification hashes, idempotency controls, and transactional SQLite persistence.

Fast, High-Fidelity Storyboarding

We wanted visual storyboarding to become part of the production workflow without introducing a heavyweight rendering pipeline.

We therefore built a visual compilation path that uses Gemini 2.5 Flash to generate layered SVG storyboard graphics with cinematic composition, lighting, and depth.

Making Failure Honest

One of the most important engineering lessons came from auditing our own prototype.

We found places where demo-oriented fallback behavior could make a failed operation appear successful.

We removed those paths.

Today, malformed screenplay input produces an explicit error. Missing authentication produces 401 AUTH_REQUIRED. Upstream visual-generation failures produce an explicit 502 error. Human approvals are authoritative backend records rather than client-side simulations.

We chose a simple principle:

If the system cannot perform an operation, it should say so rather than pretending that it did.

Accomplishments We're Proud Of

  • 128 / 128 backend tests passing
  • 10 / 10 dedicated P0 integrity tests passing
  • Dynamic screenplay parsing across Fountain, TXT, FDX, and PDF
  • Real Gemini 2.5 Flash visual generation producing SVG storyboard keyframes
  • Real Grafana Cloud MCP integration querying live Prometheus/Mimir telemetry
  • Live Grafana annotations generated from the observability workflow
  • Backend-authoritative HITL decisions with persistent SHA-256 signatures
  • Persistent Production Digital Twin state
  • Six-agent production architecture combining generative AI with deterministic domain orchestration
  • Zero credential leakage in client bundles, logs, or database records

What We Learned

1. Agents need shared state, not just shared prompts

Multi-agent collaboration becomes substantially more useful when agents operate against a shared production model rather than isolated conversations.

The Digital Twin gives the system a common representation of the production.

2. Observability can become part of agent cognition

MCP changes the role of operational systems such as Grafana.

Instead of remaining passive dashboards that humans inspect separately, live telemetry can become an input to an agent's reasoning loop.

3. Deterministic systems and generative AI complement each other

Not every production operation benefits from an LLM.

Planning structures, validation, parsing, persistence, and governance often benefit from deterministic execution, while visual generation and diagnostic reasoning benefit from Gemini.

The strongest architecture is therefore not "LLM everywhere."

It is the right intelligence mechanism for each production responsibility.

4. Autonomy requires bounded governance

A production operating system should not attempt to remove human responsibility.

The system can automate coordination, analysis, and recommendations while maintaining explicit human approval gates for consequential decisions.

What's Next for Agentic Studio OS

Agentic Cinema OS is currently focused on the core production operating-system workflow.

Future directions include:

  • Google Veo and Imagen integration for high-fidelity video and raster visual previsualization
  • 3D spatial camera blocking using Three.js / WebGPU virtual stages
  • Multi-user collaborative virtual production with real-time department coordination

These are future extensions rather than requirements for the current production workflow.

Built With

Share this project:

Updates

Submission history