CineCast

From auditions to the perfect cast—powered by AI.

Comment

Beyond the First Impression

Casting is often built around a first impression. A director watches an audition, looks at an actor's profile, compares a few candidates, and then has to make a difficult creative decision.

I wanted to explore whether AI could make that process more intelligent without taking the creative decision away from the director.

That idea became CineCast AI.

I built CineCast as a casting assistant for filmmakers that can analyze audition performances, understand what a role requires, research relevant information, compare candidates, rank them, and explain why a candidate may or may not fit a role.

The key idea was never to create an AI that says "this is the actor you should cast."

Instead:

AI investigates, analyzes, and recommends. The director decides.

As a solo developer, I also wanted to challenge myself to build the complete system rather than only an AI prototype. This meant designing the frontend, backend, database, video-processing pipeline, AI analysis, agent architecture, research tools, matching logic, ranking system, and director workflow as one product.

From Audition to Recommendation

CineCast transforms the casting process into a structured AI-assisted workflow.

A director first creates a production and defines a role with requirements such as:

  • Age range
  • Gender
  • Skills
  • Location
  • Role description
  • Expected dialogue
  • Emotional requirements
  • Voice style
  • Facial-expression importance
  • Gesture importance
  • Dialogue importance

Actors can then submit audition videos for the role.

CineCast processes the audition and analyzes multiple aspects of the performance, including:

  • Facial expression
  • Emotions
  • Gestures and pose
  • Voice
  • Speech
  • Dialogue delivery
  • Overall performance

The resulting information becomes structured evidence for the CineCast Agent.

The agent then performs the casting workflow:

Role Requirements
       ↓
Audition Analysis
       ↓
Parallel Research
       ↓
Candidate Matching
       ↓
Candidate Ranking
       ↓
AI Reasoning
       ↓
Explainable Recommendation
       ↓
Director's Final Decision

Instead of only showing a numerical score, CineCast can provide a recommendation with strengths, concerns, match details, and reasoning.

The AI recommendation is also kept separate from the director's final decision. An actor can be recommended by the AI and still be rejected by the director, or receive a lower AI match and still be selected because the director sees something the automated system cannot capture.

The Agent Behind the Casting Desk

I built CineCast using Next.js, React, TypeScript, Tailwind CSS, FastAPI, Python, PostgreSQL, SQLAlchemy, Gemini, and multiple computer-vision/audio-processing components.

I deliberately avoided putting the entire system into one giant LLM prompt.

Instead, I separated the AI workflow into specialized components:

                    CineCast Agent
                          │
          ┌───────────────┼───────────────┐
          ▼               ▼               ▼
    Role Analysis   Research Agent   Candidate Data
          │               │               │
          └───────────────┼───────────────┘
                          ▼
                  Matching Agent
                          │
                          ▼
                   Ranking Agent
                          │
                          ▼
                    AI Reasoning
                          │
                          ▼
                 Director Dashboard

Role Analysis

Gemini analyzes the role description and converts it into structured casting requirements.

This allows the matching system to work with structured information rather than relying entirely on free-form LLM reasoning.

Audition Analysis

The uploaded audition video is processed through separate services.

Audition Video
      │
      ├── Video Frames
      │      ├── Face Analysis
      │      ├── Emotion Analysis
      │      └── Pose/Gesture Analysis
      │
      └── Audio
             ├── Voice Analysis
             └── Speech-to-Text

The resulting performance information is stored and used by the casting pipeline.

Parallel Research

One of the most important agent features is the research stage.

The system can create multiple independent research tasks and execute them concurrently using asynchronous processing.

For example:

                 Research
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
   Role Context  Industry     Actor
   Research      Research     Research
        │           │           │
        └───────────┼───────────┘
                    ▼
             Research Results

This means the agent is not simply answering a question from one prompt. It is gathering information, coordinating multiple tasks, combining results, and passing the evidence to the next stage.

I also kept private application data separate from public web research rather than blindly sending private database information into external searches.

Candidate Matching

The matching system compares structured audition performance against the requirements of the role.

It evaluates areas such as:

  • Emotion compatibility
  • Emotion sequence compatibility
  • Facial-expression compatibility
  • Gesture compatibility
  • Voice compatibility
  • Dialogue compatibility

The backend calculates these compatibility scores deterministically.

This was an intentional design decision.

I did not want Gemini to simply invent a final score. Instead, the backend calculates measurable compatibility, and Gemini is used where language-model reasoning is more useful: interpreting evidence and generating understandable explanations.

Candidate Ranking

Candidates are then ranked according to their calculated casting scores.

The system categorizes candidates into:

80–100  → Matched
60–79   → Low Match
0–59    → Rejected

The director can see the ranked candidates and inspect the evidence behind the recommendation.

Explainable AI

CineCast doesn't stop at:

"Casting Score: 84."

It can explain:

  • Why the actor matches the role
  • What their strongest areas are
  • What concerns exist
  • Which performance dimensions influenced the match
  • Why the candidate was recommended or not recommended

This makes the AI output more useful to a director than an unexplained score.

Building the System Solo

CineCast was built entirely by me as a solo developer.

That meant I had to work across the entire stack instead of focusing on only one part of the application.

I designed and implemented:

  • The Next.js frontend
  • Director and actor workflows
  • Authentication
  • Production management
  • Role management
  • Audition submission
  • Video upload and replacement
  • FastAPI backend
  • PostgreSQL database
  • SQLAlchemy models
  • Video processing
  • Audio extraction
  • Face analysis
  • Emotion analysis
  • Pose analysis
  • Voice analysis
  • Speech-to-text
  • Gemini role analysis
  • Parallel web research
  • Candidate matching
  • Candidate ranking
  • AI reasoning
  • Explainable recommendations
  • Director review and final decisions

I also structured the backend into separate services and agents so that the system could grow without turning into one large, difficult-to-maintain file.

The project became as much an exercise in AI system architecture as it was in building a casting application.

Where the Hard Parts Were

The biggest challenge was connecting many different technologies into one reliable workflow.

A video upload sounds simple from the outside, but internally it becomes:

Video
 ↓
Frame Extraction
 ↓
Face / Emotion / Pose
 ↓
Audio Extraction
 ↓
Voice Analysis
 ↓
Speech Recognition
 ↓
Performance Scores
 ↓
Role Matching
 ↓
AI Casting Agent

Every stage can fail independently.

I had to deal with issues involving video paths, audio extraction, model processing, database state, asynchronous background tasks, API failures, and keeping the frontend synchronized with long-running AI analysis.

Another challenge was deciding where AI should be used and where it should not be used.

I learned that using an LLM for everything does not automatically create a better AI application.

For CineCast, I separated the responsibilities:

Structured computation → Backend
Data persistence       → PostgreSQL
Video analysis         → Specialized AI services
Web research           → Research Agent
Role interpretation    → Gemini
Candidate matching     → Deterministic logic
Ranking                → Ranking Agent
Explanation            → Gemini
Final decision         → Director

I also had to handle external Gemini failures by adding retry and fallback behavior rather than assuming every model request would succeed.

Turning Many Pieces Into One Product

One accomplishment I am particularly proud of is that CineCast became a complete end-to-end system rather than a collection of disconnected AI experiments.

The complete flow works across:

Actor → Audition → Video Analysis → Role Understanding → Research → Matching → Ranking → AI Explanation → Director Review

I am also proud of the separation between AI recommendation and human decision-making.

The system can recommend a candidate, but it does not have authority over the final casting decision.

From an engineering perspective, I am proud of building the agent architecture around specialized components instead of relying on a single LLM call.

From a product perspective, I am proud that the AI output is actually actionable: the director can watch the audition, understand the performance, compare candidates, see why the system recommends them, and then make the final decision.

Lessons Behind the Model

The biggest thing I learned is that building an AI application is much more than connecting an LLM API.

The difficult part is designing the system around the model.

I learned how important it is to separate:

evidence from interpretation,

automation from decision-making,

and AI reasoning from deterministic computation.

I also learned about asynchronous processing and why independent AI tasks should not always run sequentially.

Building the parallel research layer taught me how agentic systems can coordinate multiple tasks instead of simply responding to a single prompt.

Working with video also taught me that multimodal AI applications introduce a completely different class of engineering problems compared with text-only applications.

Most importantly, I learned that a useful AI system should not just produce an answer—it should provide evidence, reasoning, and an understandable path to a decision.

Beyond the Casting Room

CineCast is currently focused on helping directors analyze and compare audition candidates, but I see the system evolving into a broader AI production assistant.

Future improvements include:

  • More advanced facial-expression analysis
  • More detailed emotion-transition analysis
  • Better body-language and gesture understanding
  • Stronger voice and delivery analysis
  • More sophisticated actor-role compatibility
  • Persistent actor talent profiles
  • Better public-information research
  • Production planning assistance
  • Casting history and analytics
  • Cloud-based video storage
  • Scalable background AI processing
  • More robust multimodal agent reasoning

I also want to improve the explainability of the system so that every recommendation can be traced back to the evidence that influenced it.

The long-term vision is not to replace casting directors.

It is to give them an intelligent assistant that can handle the repetitive research and analysis while leaving the creative judgment where it belongs:

with the filmmaker.

Built With

Share this project:

Updates

Submission history