A shooting script is the most authoritative document a production owns, and for most of its life it stays trapped as prose. Every department reads the same pages and rebuilds the same lists by hand: the AD counts scenes, the line producer tallies cast days, the VFX supervisor hunts for effects beats, wardrobe scrapes props and costumes. That manual pass happens over and over, and it drifts the moment a revision lands. Codex exists to end that. It turns the production document into data before principal photography, so the whole building works from one parsed source instead of a dozen private spreadsheets.
Codex parses a shooting script into a 12-category breakdown. Nine of those categories are auto-tagged directly from the page, and it produces cast rollups so you can see who works when across the whole script. Scenes, shots, speaking parts, background, props, wardrobe, effects and the rest come out as structured records rather than highlighted PDF pages. This is what people mean when they ask for screenplay to data: not a smarter highlighter, but the script recompiled into rows you can query, sort and hand to the next system.
The point of doing it early is leverage. When the breakdown exists before the first day of principal photography, scheduling, budgeting and department planning all start from the same numbers. Nobody is transcribing the script into their own tool and quietly introducing a different scene count than the desk next to them.
The single most important design choice in Codex is what is not in it. There is no LLM in the parse. The breakdown is produced deterministically, which has two consequences that matter more than they sound.
First, the output is diffable. Run the same script twice and you get the same breakdown, byte for byte. So when a revision arrives, you can diff the new breakdown against the old one and see exactly what changed: the two scenes that split, the character who picked up three lines, the prop that got added on page 44. No model temperature, no quiet rewordings, no phantom differences to chase. Revisions become a changelog instead of a re-read.
Second, it is auditable. A deterministic parse behaves the same way every time, so when someone questions a number, you can point at the rule that produced it rather than shrug at a black box. For a document that drives money and schedule, that predictability is the feature.
Note: The parsed breakdown does not sit in a silo. It feeds Fabric, the knowledge graph that joins ShotGrid, FileMaker and Airtable natively plus 300+ more sources via the connector catalog. Once the script is data, characters and scenes become entities the rest of the production can query alongside shots, media and rights.
The flow is short and one-directional. A screenplay PDF goes in, Codex parses it, and a 12-category breakdown comes out as structured records: scenes, shots and cast among them. From there it feeds the graph.
Codex takes the screenplay PDF as its input. It reads the page, not a hand-marked version of it, so nobody has to pre-tag anything to get started.
The parse produces a 12-category breakdown with 9 categories auto-tagged from the text. The result is structured records, not highlights on a PDF.
Cast rollups show who appears where across the whole script, so cast-day counts and scheduling questions come off the data instead of a manual tally.
Because there is no LLM in the parse, two runs of two script versions are directly comparable. You diff the breakdowns and read the changes as a list.
The breakdown flows into Fabric, where scenes and characters become entities the production can query next to shots, media and rights.
It is worth being explicit about why the no-LLM choice is the right one for this job, because plenty of tools now offer to read a script with a language model. The difference shows up the third time a script changes.
Output can shift between runs even on the same input. A revision produces a fresh interpretation, not a clean diff, so you re-read the breakdown to trust it. Numbers are hard to attribute back to a rule when someone challenges them.
Same script in, same breakdown out, every time. A revision becomes a diff you can read in seconds. Cast rollups and the 12-category breakdown are reproducible, and any number traces to how the parse works, not to a model's mood.
Getting the script to structured data before principal photography changes the shape of the whole production's information. Scheduling and budgeting share one scene list. VFX planning starts from the same effects beats the AD is scheduling around. And because the breakdown feeds Fabric, that structure keeps paying off long after the shoot, when someone needs to find every scene a character appears in or reconcile the script against what actually got shot and delivered.
If your production technology group is trying to make the script the spine of the pipeline rather than a document people retype, that is exactly the seam Codex sits in. See how it fits alongside the rest of the platform on the production technology tour, read how the parsed graph pays off downstream in the archive, and when you are ready to try it on a real script, the four-week pilot runs on data you choose, in your numbers.
The script was always structured. Codex just stops making twelve people rebuild that structure by hand.