-
-
Asset Library
-
Settings
-
Audit Reports
-
tab to add new character, prop or location
-
Home Page
-
The analysis data
Inspiration
The filmmaking industry is entering a fundamental transition.
Generative AI has reduced the barrier to producing cinematic visual content. Characters, environments, props, storyboards, and even video sequences that traditionally required actors, physical locations, production design, cameras, VFX teams, and substantial post-production can increasingly be synthesized computationally.
This creates an important opportunity: filmmaking is becoming more accessible to creators who cannot afford conventional production infrastructure.
However, our research identified a fundamental asymmetry:
$$ \text{Generation Quality} \uparrow \quad \not\Rightarrow \quad \text{Production Consistency} \uparrow $$
A model may generate an excellent individual frame while failing to preserve the identity of the same character, the geometry of the same location, or the appearance of the same prop in subsequent shots.
This is not merely an aesthetic inconvenience.
It is a scalability problem.
The 2025 CVPR survey Generative AI for Film Creation identifies character consistency, stylistic coherence, motion continuity, controllability, and fine-grained editing among the major challenges in applying generative AI to filmmaking. (openaccess.thecvf.com)
Other recent research reaches the same conclusion from a technical perspective. A 2025 study on character-stable AI video found that removing its visual anchoring mechanism caused character-consistency performance to fall from 7.99 to 0.55, demonstrating how strongly persistent visual references influence identity preservation. (arxiv.org)
This led us to a simple question:
If generative AI can create the shot, what allows it to remember the film?
That question became CHITRAAK.
What it does
CHITRAAK is an agentic production intelligence layer for generative filmmaking.
Rather than treating AI generation as a sequence of independent prompts, CHITRAAK maintains a persistent representation of the production and allows specialized agents to reason over that state.
The system is organized around five fundamental production entities:
$$ \boxed{ Characters,\ Locations,\ Props,\ Shots,\ Sequences } $$
A filmmaker can establish characters, locations, and props as persistent visual assets and associate them with the shots in which they appear.
For example:
$$ Character_A \rightarrow {Shot_01,Shot_04,Shot_09,Shot_{15}} $$
This transforms the film from a collection of generated images into a structured production graph.
The central idea is:
$$ \boxed{ Film = Entities + Relationships + Temporal\ State } $$
CHITRAAK's multi-agent architecture can then operate on this state.
Rather than asking a single general-purpose model to perform every task, different agents can reason about different dimensions of production.
Conceptually:
$$ Film\ State \rightarrow \begin{cases} Character\ Agent\ Location\ Agent\ Prop\ Agent\ Shot\ Agent\ Continuity\ Agent \end{cases} \rightarrow Production\ Decision $$
A continuity agent, for example, can inspect the relationship between a shot and the established production state and identify potential deviations.
This creates a fundamentally different workflow:
$$ \text{Generate} \rightarrow \text{Remember} \rightarrow \text{Reason} \rightarrow \text{Verify} \rightarrow \text{Act} $$
rather than:
$$ \text{Prompt} \rightarrow \text{Generate} $$
The filmmaker remains in control, while the agents provide an additional layer of production intelligence.
How we built it
We built CHITRAAK as a full-stack, agent-oriented production workspace.
The frontend is implemented using React + TypeScript, with Vite as the build tool and Tailwind CSS for the interface layer.
However, the most important architectural component is the persistent data layer behind the interface.
Multi-agent architecture
CHITRAAK is designed around specialized agents rather than a single monolithic AI assistant.
The underlying concept is a distributed reasoning system:
$$ A = {A_c,A_l,A_p,A_s,A_v} $$
where, conceptually:
- (A_c) = character reasoning
- (A_l) = location reasoning
- (A_p) = prop reasoning
- (A_s) = shot/sequence reasoning
- (A_v) = visual continuity reasoning
Each agent can operate over the relevant portion of the production state while contributing information back to the shared system.
This allows the system to decompose a complex filmmaking problem into specialized tasks.
For example, when a new shot is introduced:
$$ Shot_{new} \rightarrow Character\ Analysis $$
$$ Shot_{new} \rightarrow Location\ Analysis $$
$$ Shot_{new} \rightarrow Prop\ Analysis $$
The resulting observations can then be aggregated into a continuity assessment.
This is particularly important because visual continuity is inherently multi-dimensional.
Persistent production state
The system stores the production entities and their relationships as structured data.
Instead of allowing information to disappear after an individual generation, CHITRAAK maintains project-level state.
The conceptual model is:
$$ State_t = State_{t-1} + NewShot + NewAssets + AgentObservations $$
This allows agents to reason about the current state of the production, rather than only the current user prompt.
ClickHouse data layer
We implemented a ClickHouse-backed data layer as the persistent analytical foundation of the system.
This is particularly relevant for CHITRAAK because the production naturally produces structured, queryable relationships:
$$ Shot \leftrightarrow Character \leftrightarrow Location \leftrightarrow Prop \leftrightarrow Continuity\ State $$
As the number of shots and entities increases, these relationships become increasingly valuable for analytical queries.
The architecture therefore separates:
$$ \boxed{ Production\ UI \rightarrow Agent\ Layer \rightarrow Data\ Layer } $$
rather than embedding production state directly inside individual UI components or model prompts.
Shot workspace
The ShotGrid provides the primary production view.
Each ShotCard represents a shot within the sequence, while ShotDetail exposes the deeper information associated with that shot.
This gives the filmmaker two complementary perspectives:
$$ \text{Sequence-level overview} $$
and:
$$ \text{Shot-level inspection} $$
Asset workspace
The AssetsView organizes recurring visual entities into Characters, Locations, and Props.
The AddAsset workflow allows new production entities to be introduced explicitly.
This is important because CHITRAAK treats these entities as persistent state rather than disposable generation outputs.
Continuity visualization
The Consistency Chart and semantic status components provide a visual representation of continuity information.
Instead of requiring a filmmaker to inspect every shot manually, the interface creates a production-level view of where attention may be required.
The status model is intentionally semantic:
$$ {\text{Consistent},\text{Needs Review},\text{Flagged}} $$
This allows future agent-generated analysis to plug into the same interface.
Production-oriented design
We deliberately designed CHITRAAK to resemble professional creative-production software rather than a conventional AI application.
The interface uses:
- flat matte surfaces
- restrained typography
- semantic status colors
- no gradients
- no glow effects
- minimal decorative elements
The intention is simple:
The AI should feel like infrastructure, not decoration.
Challenges we ran into
The hardest challenge was recognizing that continuity cannot be reduced to a single similarity score.
A character can look different because of:
- camera angle
- lighting
- pose
- expression
- perspective
while still being the same character.
Therefore:
$$ Pixel\ Difference \neq Continuity\ Error $$
The system instead needs to reason about semantic properties.
We therefore conceptualize continuity as:
$$ C = w_cC_c+ w_lC_l+ w_pC_p+ w_sC_s+ w_tC_t $$
where:
- (C_c) = character consistency
- (C_l) = location consistency
- (C_p) = prop consistency
- (C_s) = stylistic consistency
- (C_t) = temporal consistency
with:
$$ \sum_i w_i=1 $$
This immediately creates a second challenge: different agents need different contexts.
A character agent does not need the entire production database for every decision.
A location agent may require spatial and environmental information.
A shot agent needs sequence context.
A continuity agent may need relationships across all of them.
This made agent specialization and persistent shared state important architectural considerations.
A third challenge was building a system that remains useful while the underlying generative ecosystem changes rapidly.
We therefore avoided making the production interface dependent on a single generation model.
The long-term architecture separates:
$$ Production\ Memory $$
from:
$$ Generation\ Model $$
This allows the same production state to potentially interact with different models and tools.
Accomplishments that we're proud of
We are proud that CHITRAAK evolved beyond the concept of an AI image-generation interface into a structured, agentic production system.
The central accomplishment is the combination of:
$$ \boxed{ Multi-Agent\ Reasoning + Persistent\ Production\ State + ClickHouse + Visual\ Continuity\ Workflow } $$
We built an actual production-oriented interface around this architecture, including shot sequencing, shot inspection, asset management, continuity visualization, semantic status states, and the underlying data model required to connect these components.
We are particularly proud of implementing the data layer rather than treating the production state as temporary frontend mock data.
This distinction matters.
A prompt-based system primarily remembers what the user tells it now.
CHITRAAK is designed to remember what the production knows.
That enables a much more powerful abstraction:
$$ \boxed{ Prompt\ Memory \rightarrow Production\ Memory } $$
We are also proud of the design philosophy.
AI systems frequently communicate intelligence through visual effects, gradients, glowing components, and highly decorative interfaces.
We intentionally did the opposite.
CHITRAAK was designed to look like a serious production tool because our objective is not to make AI look futuristic.
It is to make AI useful inside an existing professional workflow.
What we learned
Our biggest realization was that generative filmmaking is fundamentally a state-management problem.
A simple generation workflow can be approximated as:
$$ O_t=f(P_t) $$
where the output depends primarily on the current prompt.
A production system requires:
$$ O_t = f(P_t,E_t,S_{t-1},C_t) $$
where:
- (P_t) = current creative instruction
- (E_t) = persistent visual entities
- (S_{t-1}) = previous production state
- (C_t) = current cinematic context
This means that an effective filmmaking agent cannot operate purely as a chatbot.
It needs:
$$ \boxed{ Memory + State + Tools + Reasoning } $$
We also learned that multi-agent systems become useful when the problem itself is naturally decomposable.
Film continuity is exactly such a problem.
Characters, locations, props, shots, and temporal relationships represent different dimensions of the same production state.
Instead of one model attempting to reason about everything simultaneously, specialized agents can inspect specific dimensions and contribute to a shared production understanding.
We also learned why small inconsistencies become increasingly significant as productions become longer.
Under a simplified assumption that every shot has an independent probability (p) of introducing an unacceptable continuity deviation:
$$ P(\text{no deviation across }n\text{ shots})=(1-p)^n $$
For (p=0.05):
$$ P_{20}=0.95^{20}\approx35.8\% $$
while:
$$ P_{50}=0.95^{50}\approx7.7\% $$
This is not an empirical measurement of CHITRAAK. It illustrates the underlying scaling problem.
As the number of shots increases, continuity becomes increasingly difficult to manage manually.
This changed our understanding of the problem:
Continuity is not a final quality-control step. It is a persistent property of the production state.
What's next for CHITRAAK
Our current implementation establishes the foundation for a larger agentic filmmaking infrastructure.
1. Autonomous continuity analysis
The next step is to allow the continuity agents to automatically inspect new shots against the production state.
A new shot would trigger:
$$ Shot_{new} \rightarrow Agents \rightarrow Evidence \rightarrow Continuity\ Score $$
The system could then identify exactly which entity requires attention.
For example:
$$ Shot_{24} \rightarrow Character_A \rightarrow \boxed{\text{Needs Review}} $$
while:
$$ Shot_{24} \rightarrow Location_B \rightarrow \boxed{\text{Consistent}} $$
This is more useful than a single binary "good/bad" output because it tells the filmmaker where the problem exists.
2. Agentic actions
We want the agents to progress from analysis to action.
Instead of merely saying:
"Character A appears inconsistent in Shot 24."
the system could eventually:
$$ Detect \rightarrow Explain \rightarrow Recommend \rightarrow Regenerate \rightarrow Verify $$
with explicit filmmaker approval at appropriate stages.
This turns CHITRAAK from a monitoring system into an active production assistant.
3. Deeper ClickHouse analytics
The production database can eventually support queries across the entire film.
For example:
$$ \text{Which characters appear in the most inconsistent shots?} $$
$$ \text{Which locations produce the highest continuity variance?} $$
$$ \text{Where does continuity degradation begin in the sequence?} $$
$$ \text{Which visual assets require repeated regeneration?} $$
This transforms continuity from a subjective production concern into an analyzable dataset.
4. Model-agnostic production memory
CHITRAAK's production state should remain independent of the generation model:
$$ Production\ Memory \rightarrow Gemini $$
$$ Production\ Memory \rightarrow Image\ Model $$
$$ Production\ Memory \rightarrow Video\ Model $$
$$ Production\ Memory \rightarrow External\ Creative\ Tool $$
The filmmaker should not have to rebuild the visual identity of a film simply because the underlying generation model changes.
5. Full cinematic agent network
Our ultimate vision is a network of specialized agents operating over one shared production state:
$$ \boxed{ \begin{aligned} &Script\ Agent\ &Character\ Agent\ &Location\ Agent\ &Prop\ Agent\ &Shot\ Agent\ &Continuity\ Agent\ &Production\ Agent \end{aligned} } $$
These agents would collaborate rather than operate independently.
A change to one production entity could propagate through the relevant shots and trigger downstream analysis.
For example:
$$ Character_A\ Changed $$
$$ \Downarrow $$
$$ Affected\ Shots $$
$$ \Downarrow $$
$$ Continuity\ Agents $$
$$ \Downarrow $$
$$ Review/Regeneration\ Recommendations $$
This is the direction in which we believe agentic AI can become genuinely useful in filmmaking.
Ultimately, we see CHITRAAK as a persistent intelligence layer between creative intent, production data, generative models, and the final film:
$$ \boxed{ Creative\ Intent \rightarrow Production\ Memory \rightarrow Multi\text{-}Agent\ Reasoning \rightarrow Generation \rightarrow Continuity \rightarrow Editing } $$
Generative AI has made it increasingly possible to create a shot.
CHITRAAK is exploring the infrastructure required to create the same world across an entire film.
The model generates the frame. CHITRAAK remembers the film.
Log in or sign up for Devpost to join the conversation.