Inspiration
Film sets generate camera footage, production sound, script notes and backup reports across different devices and departments. Before a camera or sound card is erased, the crew must confirm that every expected file has reached safe storage.
The dangerous moment is not when a file is obviously corrupted. It is when everything appears complete, the cards are released, and the missing file is discovered after the set has been struck.
I initially explored broader AI-assisted filmmaking ideas, but many of them felt subjective or difficult to trust. I wanted to solve a smaller, practical problem with a clear outcome:
Can the DIT safely release the source cards, or is a specific recovery action still required?
That became WrapCheck.
What it does
WrapCheck is a human-controlled media-handoff gate for film productions.
It reconciles four sources of evidence:
- Camera reports describing the video files recorded on set.
- Sound reports describing the corresponding production-audio files.
- Script supervisor notes identifying important and circled takes.
- Backup manifests containing file sizes, destinations and SHA-256 checksums.
WrapCheck compares what the production reports say should exist with what actually reached two independent backup destinations.
The demonstration contains three original camera takes with separate production sound. The problem delivery produces exactly two blockers:
- The production WAV for the circled Take 7,
SR12_024B_T07.wav, is missing. - Camera card A017 has not completed its second verified backup.
Instead of displaying a generic warning, WrapCheck produces exact recovery instructions. It tells the operator which sound file must be recovered and which backup operation must be completed.
The source cards remain on hold until a human reviews the evidence and records the recovery. Even after every automated check passes, only a named DIT or data manager can release the cards.
WrapCheck then generates an editorial handoff report containing the takes, evidence, detected problems, human decisions and final reviewer.
How I built it
WrapCheck uses a Next.js frontend and a FastAPI backend deployed on Google Cloud Run.
The hosted architecture includes:
- Google Cloud Run for the frontend, API, ingestion worker and private MCP service.
- Private Google Cloud Storage for camera clips, production audio, uploaded reports and temporary delivery assets.
- Cloud Tasks for authenticated, retryable ingestion jobs.
- Gemini on Google Cloud for constrained normalization of semi-structured PDF and DOCX production reports.
- ClickHouse Cloud as the durable system of record.
- The official ClickHouse MCP server with a separate read-only ClickHouse identity.
- FFprobe for media metadata extraction.
- CRC32C and SHA-256 validation for uploaded files.
- Deterministic reconciliation code for the final two-destination media policy.
Uploads go directly from the browser to private Cloud Storage through short-lived signed URLs, so large media files do not pass through FastAPI memory.
The worker validates file extensions, MIME types, signatures, declared sizes and media metadata. It calculates real hashes, parses structured reports and stores normalized delivery evidence in ClickHouse.
The agent retrieves the delivery through the private, read-only ClickHouse MCP service. Deterministic code then decides whether the delivery has a missing file, a hash mismatch or fewer than two verified destinations.
Gemini can help normalize reports and summarize retrieved evidence, but it cannot claim that a file exists, verify a checksum, resolve a finding or release source media.
Runs, findings, decisions, releases, ingestion jobs and tool telemetry are stored durably in ClickHouse. Human decisions survive backend restarts, and final release records are immutable.
Original demonstration media
I created a miniature rights-safe film delivery specifically for WrapCheck.
It includes:
- Three original 720p H.264 camera clips.
- Slate and timecode information.
- Scratch camera audio.
- Separate 48 kHz production WAV files.
- Camera, sound and script reports.
- Backup manifests with real file sizes and SHA-256 hashes.
- A problem package and a fully recovered package.
The footage is not used as proof that a file was copied. The manifests and matching hashes provide that proof. The playable media exists so the operator can inspect the exact take associated with a finding.
Challenges I faced
Finding a practical problem
The first challenge was choosing the right problem. A general “AI for filmmaking” product was too broad and risked becoming a visual gimmick. Narrowing the project to one expensive, time-sensitive decision made the workflow more credible and testable.
Keeping AI inside a safe boundary
File existence and checksum verification are objective facts. Allowing a language model to decide those facts would make the system less trustworthy.
I separated the responsibilities carefully:
- Gemini handles constrained document normalization.
- ClickHouse stores the production evidence.
- MCP provides read-only retrieval.
- Deterministic code enforces the release rules.
- A human controls the final decision.
Building a real cloud path
It was important that the hosted demo did not pretend fixture activity was a live agent or MCP call. I implemented separate live and local modes, private service-to-service authentication, signed uploads, durable persistence and real tool telemetry.
Producing reliable demonstration media
The problem delivery needed to produce the same two intended findings every time without unrelated false positives. I generated original camera and audio assets, measured their real sizes, calculated their real hashes and tested both the problem and recovered packages repeatedly.
Durable human decisions
Process-local state would disappear when a Cloud Run instance restarted. I moved runs, findings, decisions and releases into append-only ClickHouse records and reconstructed the latest state using durable queries.
What I learned
I learned that agentic systems are most valuable when the model is not treated as the source of truth for everything.
For this workflow, the strongest design combines:
- AI for understanding semi-structured documents.
- MCP for controlled evidence access.
- A durable analytical database for traceability.
- Deterministic rules for safety-critical decisions.
- Human authority for irreversible actions.
I also learned that a focused operational question creates a stronger product than a broad collection of AI features. “Can we safely release these cards?” is understandable, measurable and directly connected to the work happening on set.
Accomplishments I am proud of
- Built and deployed a functional end-to-end application instead of a static prototype.
- Integrated Google Cloud, Gemini, ClickHouse and the official ClickHouse MCP at runtime.
- Created original camera and production-sound demonstration media.
- Implemented real file-size, metadata and checksum validation.
- Kept the MCP service private and read-only.
- Made final release human-controlled and immutable.
- Produced consistent problem and recovered outcomes.
- Added quotas, request limits, least-privilege identities and private storage.
- Preserved a complete audit trail from ingestion through final release.
What is next
The next major improvement is a guided delivery-package builder.
A production user should be able to select a media folder and existing reports, then let WrapCheck generate the initial manifest, calculate hashes and help map camera files to production sound without manually preparing CSV files.
Future integrations could also import reports and checksum manifests directly from established DIT and offload tools. Additional production testing would cover multiple cameras, multiple sound rolls, duplicate filenames, larger shooting days and different report formats.
The long-term goal is not to automate the decision to erase source media. It is to give the responsible human clearer evidence before making that decision.
Log in or sign up for Devpost to join the conversation.