Production-change-agent

Every schedule change has a price. We tell you what it is before you commit.

Comment

🎬 Inspiration

Film production schedules are incredibly complex. A single change — moving a scene, swapping a cast member, changing a location — triggers cascading effects:

  • Cost overruns from overtime, hold days, and company moves
  • Union violations — turnaround time, meal penalties (SAG-AFTRA, IATSE)
  • Logistical failures — permit lead times, actor and location availability

Production managers make these calls dozens of times a week, usually on intuition and a whiteboard. They commit to changes without knowing the financial impact. A single bad call can cost six figures.

We wanted a tool that surfaces the unseen cost of a decision, generates alternatives instantly, and catches violations before they happen.

"Every schedule change has a price. We tell you what it is before you commit."

💡 What it does

Production Change Agent shows production managers the true cost of a schedule change before they commit to it.

You type the change in plain English. The agent parses it, searches real production data, generates alternative schedules, validates them against union rules, prices them, and hands back three ranked plans — each with reasoning, a confidence score, and citations.

You:   "move scene 5 to day 3"

Agent: Plan #1 — Move + cascade      $340,000   (−$28,650)   87% confident
       Plan #2 — Direct move         $352,400   (−$16,250)   74% confident
       Plan #3 — Swap with scene 9   $361,100   ( −$7,550)   61% confident

       2 rejected: Riverside Alley unavailable · Day 5 exceeds 14h cap

The pipeline

  1. Natural language input — move scene 5 to day 3, no forms or dropdowns
  2. Intent parsing — action, scene IDs, target day
  3. Parallel Search — union rules, cost patterns, permit lead times (runs concurrently)
  4. Generation — alternative schedules via direct_move, swap, and cascade strategies
  5. Validation — hard violations rejected, soft violations priced into a risk score
  6. Costing — crew, locations, company moves, overtime, meal penalties, hold days
  7. Ranking — risk-adjusted cost across all candidates
  8. Visualization — the stripboard updates live

Key features

  • 🧠 Agent chain of thought — step-by-step reasoning in a green terminal view
  • ❓ Plan reasoning — every plan explains why it was chosen
  • 📈 Confidence scores — 0–100% certainty per plan
  • 🔀 Compare view — side-by-side plan comparison
  • 📄 PDF export — professional plan reports for the production office
  • 🔍 Parallel Search citations — every recommendation traces back to a source

🏗️ How we built it

Architecture

Frontend (React + Tailwind)  →  Backend (FastAPI)  →  Parallel Search API
                                       ↓
              Parser → Validator → Cost Model → Generator → Ranker

Tech stack

  • Frontend — React 18, Vite, Tailwind CSS
  • Backend — FastAPI, Python 3.11+, Pydantic
  • Search — Parallel Search API
  • LLM — Google Gemini (fallback intent parser)
  • Deployment — Vercel (frontend and backend)
  • PDF export — jsPDF

Key components

Parser — A hybrid system: regex rules handle the common cases fast and reliably, with a Gemini API fallback for phrasings the rules miss.

Cost model — Deterministic pricing built on union rules (SAG-AFTRA, IATSE). The same request always returns the same cost, so every line is verifiable.

Validator — Separates hard rules (location availability, dark days) from soft rules (overtime, meal penalties, mixed day/night scenes). Hard violations reject a plan; soft ones get priced.

Generator — Builds candidate schedules using direct_move, swap, and cascade strategies.

Ranker — Scores by risk-adjusted cost:

risk_adjusted_cost = cost_delta + (risk_delta * 450)
# $450 = internal price of one risk point

Development approach

We leaned on "vibe coding" for the frontend — building UI components with LLMs (Claude, Kiro) using clear, specific prompts and fast iteration. That freed us to spend our time on the backend logic and the agentic features, which is where the actual product value lives.

🧗 Challenges we ran into

1. Natural language understanding Turning move scene 5 to day 3 into structured intent isn't trivial once phrasing varies. Pure LLM parsing was slow and non-deterministic; pure regex was brittle. The hybrid parser gave us speed on the common path and coverage on the long tail.

2. Cost model accuracy We needed a model that follows union rules, accounts for overtime, meal penalties and hold days, and returns identical output for identical input. Every cost line has to be defensible to a judge — "the AI said so" isn't an answer.

3. Real-time search integration Parallel Search had to run concurrently with schedule generation so it never blocks the response, and the app had to degrade gracefully on API timeouts rather than fail.

4. Agentic UI design Showing the agent's thought process was the hard design problem. We landed on three surfaces: the live agent trace, per-plan reasoning, and visual confidence bars.

5. Deployment complexity Getting frontend and backend deployed with correct CORS and environment configuration took real care. Serverless function timeouts pushed us to /change/stream (SSE) for longer-running requests.

6. Vercel environment variables VITE_API_URL had to be set as a Config variable, not a Secret, for the frontend build to pick it up. The CLI turned out to be more reliable than the dashboard for this.

🏆 Accomplishments that we're proud of

A complete agentic pipeline — intent parsing → search → generation → validation → costing → ranking → reasoning. Not a wrapper around a prompt: a real multi-step agent with tools and a verifiable output.

A deterministic cost model — grounded in real union rules, consistent across runs, and explainable line by line.

A UI that looks like production software — stripboard, agent trace, plan cards with reasoning, confidence bars, compare view, PDF export.

Graceful degradation — search results enrich the plans as citations, but the app still works end to end if Parallel is unreachable.

A live deployment — both frontend and backend are up. You can type move scene 5 to day 3 right now and get three ranked plans with full cost breakdowns.

Built in 3 days — a two-person team covering frontend, backend, data modelling, and the demo.

📚 What we learned

Agentic design is about visibility. An agent isn't just the final answer — it's the journey to it. People trust AI when they can audit its reasoning. The chain-of-thought trace was consistently the most appreciated feature.

Deterministic beats "smart." For scheduling, consistency matters more than cleverness. A number you can reproduce and defend is worth more than a number that's occasionally better and never explainable.

Grounded search changes the output. Searching real production data means the agent isn't just generating plans, it's justifying them. Citations turn a suggestion into an argument.

Vibe coding works — with discipline. LLM-built frontend accelerated us enormously, but only because we wrote specific prompts and iterated in tight loops. Vague prompts produced code we had to throw away.

Clear hierarchy earns trust. Stripboard → input → plans → reasoning. Less clutter, more credibility.

Deployment deserves budgeted time. Timeouts, CORS, and environment variable types are not footnotes — they're where a working demo goes to die at 3am.

🚀 What's next for Production Change Agent

Phase 1 — User preferences Learn from user choices (cost savings vs. fewer violations), adapt candidate generation to those goals, and personalize recommendations.

Phase 2 — Drag-and-drop stripboard Visual schedule editing with real-time cost updates as you drag scenes between days.

Phase 3 — Multi-agent collaboration Separate agents for cost, risk, and logistics, with ensemble voting on the best plan.

Phase 4 — Screenplay PDF ingestion Auto-generate scenes directly from script PDFs, extracting cast, locations, and descriptions.

Phase 5 — Real-time collaboration Multiple users, shared session state, and approval workflows.

Phase 6 — Production-ready Authentication, schedule history and versioning, integrations with existing production management tools, and a mobile-responsive build.

Built With

Share this project:

Updates

Submission history