StudioOS — The Autonomous Pre-Production Control Room

Multi-agent orchestration: a Script Analyst Agent breaks down the script, four department agents work in parallel
The StudioOS dashboard — live budget, schedule, and greenlight risk score, with a full audit log of every agent action.

StudioOS — Project Story Inspiration

Every film that gets made survives a brutal filter before a single frame is shot: pre-production. A screenplay has to be broken into scenes, priced out, scheduled around locations and cast availability, checked for legal and safety red flags, and finally judged on whether it's even commercially viable. This process is slow, manual, and scattered across a dozen disconnected tools and spreadsheets — and it's where most promising projects quietly die before they ever reach a camera.

We kept coming back to one question the hackathon put in front of us: what does it look like when "writing code" stops being the main event, and orchestrating a system of autonomous agents becomes the real craft? Pre-production felt like the perfect enterprise-scale problem to test that idea on — it's not one task, it's a whole department's worth of interdependent decisions. That's exactly the kind of chaos agentic AI is supposed to be good at taming.

What it does

StudioOS takes a raw screenplay and runs it through a coordinated team of agents that mirror an actual studio's pre-production department:

Script Analyst Agent — breaks the script into scenes, characters, locations, props, and VFX needs Budget Producer Agent — estimates per-scene cost using historical spend data Scheduler Agent — builds a shooting schedule grouped by location and cast availability Greenlight Risk Agent — scores commercial viability against historical box office comps Compliance/Rights Agent — flags scenes needing music licensing, stunt permits, or intimacy coordination Studio Head (orchestrator) — routes work between agents, enforces IAM-scoped permissions, and logs every action for audit

The output is a single dashboard: a schedule, a budget, a risk score with reasoning, and a compliance checklist — generated in minutes instead of weeks.

How we built it

We grounded the system in Gemini Enterprise as the reasoning layer, with each department agent built on the Enterprise Agent Platform SDK and hosted on Cloud Run. Screenplay PDFs, historical box office data, and past production costs were loaded directly into Agent Builder Data Stores, which gave us zero-config grounding without building a manual embedding pipeline — a huge time save.

The orchestration layer was the real design challenge: we needed agents to hand off structured data to each other (the Script Analyst's scene breakdown feeds both the Budget and Scheduler agents) while staying isolated from data they had no business touching. We used Cloud IAM to scope each agent's permissions individually — the Budget Agent, for instance, has no access to the Compliance Agent's legal documents — and Secret Manager to keep credentials out of agent logic entirely. Every hop between agents gets logged, so the Studio Head orchestrator can produce a full audit trail of who touched what.

We prototyped almost entirely in the Console Emulator inside the Google Cloud UI, which let us iterate on prompts and agent handoffs live in the browser without fighting local environment setup.

Challenges we ran into

Getting agents to hand off structured (not just conversational) data cleanly was harder than expected — early versions had the Scheduler Agent re-interpreting loosely-formatted output from the Script Analyst and drifting from the source script. We solved this by having agents pass strict JSON schemas between steps instead of free text.

Balancing governance with usability was another tension: locking down IAM permissions tightly enough to be meaningful, without making the agent network so siloed that the Studio Head couldn't reason across departments, took several iterations of scoping.

Accomplishments we're proud of

Watching a screenplay go in one end and a coherent budget, schedule, and risk assessment come out the other — fully auto-generated and cross-referenced against real historical data — was the moment it clicked. We're especially proud of the governance layer, since most agentic demos skip access control entirely, and we think that's exactly the gap between a fun prototype and something a real studio could trust.

What we learned

Multi-agent systems live or die on the handoffs, not the individual agents. The hardest problems weren't "can Gemini analyze a script" — it can — but how to structure inter-agent communication so five autonomous processes stay coordinated instead of drifting apart.

What's next for StudioOS A "Table Read" mode with Gemini-voiced scene readings and live agent annotation Deeper integration with real studio budgeting tools via MCP servers Expanding the Greenlight Risk Agent with audience sentiment data from review logs