CallSheet

Inspiration

A call sheet is the one piece of paper that gets a film crew through a shoot day. It says where to park, when to be there, and — critically — where the nearest emergency room is. It is also, on a small production, the document most likely to be thrown together the night before by someone exhausted.

That makes it a bad fit for a normal AI writing tool. If a language model invents a plausible-sounding hospital address, that is not an amusing hallucination. That is a crew member bleeding in a van going the wrong direction. Production paperwork is a category where "plausible" is worthless and "verified" is the entire job.

So CallSheet was built around a simple rule: the agent is not allowed to remember facts about the real world. It has to go and look them up, every time, and show its sources.

This was built on Vancouver Island, where a working production community operates out of Victoria under its own regional film commission. On a studio show, a production coordinator makes the call sheet — it is their job, and they are paid to do it. On the independent shoots that make up most of the work here, there is no coordinator. The director makes the call sheet at midnight, after a full shoot day, on a laptop, and every hour spent on paperwork is an hour not spent on the film. CallSheet is aimed squarely at that person: the small crew doing studio-grade work without a studio's overhead.

What it does

Paste in a scene — a formatted screenplay page, or just a messy paragraph describing what you want to shoot.

1. Breakdown. Gemini 2.5 Flash reads the scene and extracts what a 1st AD would pull out: scene numbers, the primary shooting location, cast needed, time of day, and any special equipment.

2. Live research. The extracted location is handed to the Parallel Search API, which runs three queries against the live web: the exact address and parking access, the nearest emergency hospital and its contact details, and the filming permit and municipal jurisdiction for that location.

3. Assembly. Gemini writes a structured call sheet from the breakdown and the retrieved research — production header, location and parking, hospital and emergency info, scene schedule, and department notes.

Every source Parallel returns is displayed on the page next to the call sheet, grouped by what it answered, with clickable links. You can check the agent's work without leaving the app.

How we built it

• Google Gemini 2.5 Flash, called through the google-genai SDK, handles both the script breakdown and the final synthesis.
• Parallel Search API (v1, turbo mode) performs the live grounding on every generation.
• Streamlit for the interface.
• Ships with an original 4-scene short screenplay, "The Last Ferry", as a test fixture — four locations, three characters, a day/night spread — plus a deliberately unstructured synopsis to prove the breakdown step works without screenplay formatting.

Challenges we ran into

The first architecture on paper was a five-agent pipeline. Building it revealed that the interesting part was not the number of agents but whether the grounding was load-bearing, so the design was cut down to a three-step spine that does the job honestly.

Smaller ones cost real time: an initial Gemini model endpoint failed and the project moved to gemini-2.5-flash. Parallel authenticates with an x-api-key header rather than a bearer token, and returns an excerpts list rather than a single snippet — both discovered the hard way.

Accomplishments that we're proud of

The grounding is not decorative. There is no cached data, no mock fallback, no path where the app quietly answers from the model's memory when the search fails — if Parallel returns nothing citable, the app says so rather than handing over a call sheet that looks authoritative and isn't.

It was built solo, and the scope

Built With

• gemini-2.5-flash
• google-cloud
• google-gemini
• google-genai
• parallel-search-api
• python
• streamlit