Cinevora

Cinevora deploys coordinated Gemini agents to produce evidence-grounded recovery plans for disrupted film productions, governed by a deterministic safety gate.

Comment

Inspiration

Film productions run on tight schedules and tighter budgets. A bad weather day, a location that falls through, or equipment that isn't ready can turn into thousands of dollars lost and a mess of phone calls between the director, the location scout, and the production manager. Everyone is working off a different piece of information.

The facts needed to make a good recovery call already exist somewhere in the production: the schedule, the crew list, the budget, the location contract. Nobody has time to pull it all together fast enough during a crisis. We wanted to build something that could do that job the way an experienced production manager does it. Gather the facts, weigh them against safety and cost, and propose a real plan, while still letting a human make the final call.

Cinevora is our answer: an agentic recovery platform built for the moment a production hits a disruption and needs a fast, evidence-backed plan.

What it does

When a disruption hits, Cinevora sends three specialist Gemini agents to work on it: a Scheduling agent, a Resource and Logistics agent, and a Location and Budget agent. Each one analyzes the situation on its own. A Producer agent then combines their findings into one recovery recommendation.

A separate decision engine scores that recommendation across six factors: schedule continuity, location suitability, resource impact, budget impact, operational risk, and weather resilience.

$$ \text{Overall} = \sum_{i} w_i \cdot s_i $$

Every claim behind a recommendation gets tracked as evidence, tagged by where it came from (production data, a live web search through Parallel, or agent reasoning) and how confident the model is. A recommendation backed by verified facts scores higher than one built on guesses.

There's also a hard safety gate written in plain code, not a prompt. If a strategy would put the crew at risk, it gets rejected no matter what the model thinks of it. That rejection shows up in the app too, next to every other option Cinevora looked at, so nothing gets hidden.

Nothing executes on its own. A production manager reads the evidence, sees what got rejected and why, and only then approves the plan.

How we built it

The backend is Python and FastAPI using Google's Agent Development Kit to run four Gemini agents, three specialists working in parallel and one Producer agent for synthesis. The Location and Budget agent calls Parallel's search API directly so its location suggestions come from real, current information instead of whatever the model happened to learn during training.

Under the agent layer sits a decision engine with no model calls at all. It builds candidate strategies, runs them through the safety gate, and scores each one based on how well its evidence holds up.

def calculate_evidence_confidence(strategy, evidence):
    # confidence comes from structured fields on each
    # evidence item, not from scanning the text for
    # specific words
    ...

We kept this part deterministic on purpose. The pieces that need to be trustworthy, safety, scoring, ranking, shouldn't depend on how a language model happens to phrase something that day.

The frontend is Next.js. A shared context keeps five pages, Overview, Schedule, Resources, Locations, and Budget, all showing the same facts once a plan is generated. Backend runs on Render, frontend on Vercel.

Challenges we ran into

The hard part wasn't getting the model to produce a plan. It was getting it to admit when it didn't actually know something. Early versions of Cinevora would invent future dates out of nowhere or say a location was confirmed when it wasn't. I rewrote the prompts several times until the rule was strict: never make up a date, never claim something is available without evidence, and if something is genuinely unknown, say so.

We also found our evidence scoring was too fragile at first. It only gave a bonus if the model used the word "confirmed" somewhere in its output, which meant the same input could score differently just because of how the model phrased things that run. We rebuilt it to check the actual confidence and source fields on each evidence item instead of hunting for a specific word. That made the scores far more consistent.

Keeping five pages in sync after a plan is generated took more work than expected. We ended up building a shared state layer instead of letting each page manage its own copy of the data, which is what caused the inconsistency in the first place.

Accomplishments that we're proud of

The safety gate is real code. A strategy that puts crew at risk gets rejected outright no matter how the model scores it, and that rejection is visible in the app instead of getting quietly dropped.

We watched the evidence confidence score respond correctly across a lot of test runs. Strong, well sourced claims pushed the score up. Weak or unverified ones kept it more conservative. That's the system actually doing work, not just displaying a number.

Everything held together under real testing, including a full deployment, not just a local demo we only ran once.

What we learned

Building something agentic doesn't mean letting the model decide everything. The parts that matter most for trust, safety checks, scoring, ranking, work better as regular code that a human can read and verify. The model is better used for synthesis and reasoning, grounded in evidence it actually retrieved.

We also learned that the same input can produce a different score from one run to the next, just from natural variation in how the model writes its output. The answer isn't to force a fixed number. It's to build scoring that's honest about that variation and can still explain itself.

What's next for Cinevora

We want to add more disruption types beyond weather and locations, things like crew conflicts, permit delays, and equipment failures, each handled by its own specialist agent. We're also interested in a what-if mode, where a production manager could change one assumption, like a lower budget or an earlier deadline, and watch the recommendation and its score update in response.

Built With

  • agentic-ai
  • decision-support-systems
  • fastapi
  • gemini
  • gemini-2.5-flash
  • google-adk
  • media-and-entertainment
  • multi-agent-system
  • next.js
  • parallel
  • parallel-web
  • production-management
  • pydantic
  • python
  • react
  • render
  • tailwindcss
  • typescript
  • uv
  • vercel
Share this project:

Updates

Submission history