Studio Scout

From script to set: AI-scouted locations, backed by real-world evidence.

Comment

Inspiration

Location scouting is one of the most time-consuming, least-automated parts of pre-production. A line producer or scout has to read an entire screenplay, mentally tag every scene with its setting and mood, and then manually search for real-world locations that match — often relying on personal knowledge, old contact lists, or generic stock-photo location databases with no evidence trail. We wanted to see if an agentic pipeline could do the first pass: read a screenplay like a scout would, reason about what each scene actually needs, go find real candidate locations on the web, and come back with scored, justified recommendations instead of a black-box guess.

What it does

Studio Scout takes a PDF screenplay (plus an optional scouting prompt, e.g. "gritty industrial, Pacific Northwest") and turns it into a scene-by-scene shoot plan:

  • Parses the script and breaks it into scenes with their settings, mood, and requirements
  • Runs live web research per scene to find real candidate shooting locations
  • Scores and ranks candidates against each scene's needs, with evidence backing every recommendation (not just a vibe match)
  • Surfaces the whole process through a live agent-trace view, so you can see the reasoning as it happens rather than just a final report

How we built it

The backend is a Python 3.13 project built with uv, using google-adk and google-genai (Vertex AI, Gemini 2.5 Flash) to power a multi-agent orchestrator. Scene research is grounded with Parallel Web Search rather than the model's own knowledge, so recommendations are tied to real, current information instead of hallucinated locations. All scoring, weighting, and conflict-resolution logic is deliberately kept in plain Python rather than left to the LLM — the model produces raw signal per scene, and Python does the deterministic, auditable decision-making on top of it. Schemas are defined in Pydantic first, and the React 18 + TypeScript + Tailwind frontend mirrors those Pydantic models field-for-field so the two sides never drift out of sync. The API layer is FastAPI, serving both the agent pipeline and the static built frontend.

Challenges we ran into

  • Grounding wiring: Parallel's search tool needed a different tool type (ToolParallelAiSearch with a BYOK key) than the generic retrieval pattern we expected — took real trial and error to get right.
  • Runaway multi-hop search: Automatic Function Calling would fire multiple searches per scene unless explicitly capped, which we had to rein in to keep costs and latency sane.
  • Rate limits at scale: running research across every scene in a full screenplay meant we had to add retry logic and deliberate pacing between calls.
  • Tracing through nested agents: the ADK's AgentTool doesn't forward nested tool-call events to the outer runner by default, so getting a clean live trace for the demo required extra callback hooks.
  • Single-instance state: our pipeline currently uses file-based shared state, which constrains deployment to a single Cloud Run instance — a deliberate tradeoff we made to hit the deadline rather than build out a database layer.

Accomplishments that we're proud of

  • Getting a full screenplay-to-shoot-plan pipeline working end to end under hackathon time pressure, from PDF upload to scored, evidence-backed recommendations
  • Building a live agent-trace view that actually shows the multi-agent reasoning as it happens, instead of just a final static report
  • Keeping the system auditable by design: every location recommendation is backed by real web evidence rather than an LLM's unverifiable claim
  • Making the deliberate architectural call to split "LLM judgment" from "deterministic decision logic" — and having it pay off in a pipeline that's actually debuggable
  • Shipping a working deployed demo on Cloud Run within the submission deadline, including all the infrastructure plumbing (Secret Manager, Artifact Registry, containerization) that goes with it

What we learned

That building a genuinely evidence-backed agent pipeline is mostly about restraint: capping how much the model is allowed to search, keeping the LLM scoped to judgment calls it's actually good at (raw relevance scoring) while pushing anything that needs to be consistent and explainable (weighting, ranking, conflict resolution) into deterministic code. The most reliable answers came not from trusting the model's internal knowledge but from grounding it in live search and verifying API behavior against the actually-installed package versions rather than assuming from documentation.

What's next for Studio Scout

Wiring our two current pipelines — the live multi-agent orchestrator and the deterministic scoring pipeline — into a single end-to-end flow, exposing scouting region as a user-facing input instead of a hardcoded default, and moving off single-instance file state so the app can scale beyond a single Cloud Run instance.

Built With

Share this project:

Updates

Submission history