How Replai is building a system that increases creative experimentation without throwing away the expertise that made the original work good.

Generating a short video with AI is easy to demonstrate. Producing the right video, repeatedly, for a specific product and business is a different problem.

A plausible-looking animatic can still be wrong in dozens of ways. The colours may drift from the brand. The aspect ratio may not fit the intended placement. A character can look convincing while being the wrong kind of hero for the product. Gameplay can be visually polished but inaccurate. The opening can be energetic and still fail the creative brief.

People handled those details long before generative models entered the workflow. Creative teams accumulated rules, examples, instincts and review habits that kept the output faithful. The work could be slow and expensive, with repeated handoffs between ideation, scripting and production, but the fidelity was often good.

That changes the automation problem. We are not starting from a broken creative process and asking a model to rescue it. We are trying to make experimentation faster while preserving the judgement that made the existing process work.

Quality was not the original failure

Traditional creative production can take a week or more to move from an idea to a reviewable artefact. Much of that time is not spent rendering pixels. It is spent transferring context, interpreting feedback, revising scripts, rebuilding scenes and checking the same requirements at several stages.

The cost of this process limits experimentation. If every new idea triggers another long sequence of handoffs, teams have to be selective before they have much evidence. Many plausible directions never get tested because producing a version is too expensive.

Generative models change the cost of making a candidate, but they do not automatically change the cost of making a candidate that experts will accept. Without the surrounding judgement, faster generation can simply produce more work for reviewers.

Our goal at Replai is to reduce that repeated work and make more ideas testable without weakening product or brand fidelity.

Expertise is more than a collection of documents

People often describe specialised AI systems as models connected to a knowledge base. That is useful, but incomplete. Expert performance depends on several kinds of information with different roles.

• Knowledge contains relatively stable facts about a product, client or domain.
• Skills describe reusable procedures: how to turn an idea into a script, decompose a script into scenes, or inspect an animatic for a particular class of errors.
• Working context holds the brief, campaign constraints and intermediate decisions for the current job.
• Memory retains feedback or observations that should influence future work, which can be transformed into Skills or Knowledge.

An agent coordinates those pieces. It chooses which procedure to run, which tools to call, what evidence to retrieve and when an output needs another pass or a person’s attention.

We keep these concepts separate because they change in different ways. A campaign brief should not become a permanent memory by accident. A stable product rule should not be buried in the transcript of one generation. A reviewer correction should not be appended to an ever-growing system prompt without knowing which behaviour it is meant to change. And so on…

The architecture is only useful if these distinctions improve the work. The test is whether the encoded expertise changes a decision and produces a better result on representative cases.

Two ways into the same production pipeline

Our current workflow can begin in two places. An expert can supply the core idea, or the system can generate candidate ideas from the available knowledge and constraints. This preserves an important choice: experts can direct the work when they already know what they want, while the system can expand the search space when the goal is exploration.

Both entry points feed the same production path:

Expert idea ───────┐
                   ├─> script
Generated ideas ──┘      └─> scene decomposition
                              └─> storyboard / frames
                                   └─> animation
                                        └─> animatic or GIF
                                             └─> evaluation
                                                  └─> revise or review

Each transition has its own failure modes. A good idea can become a weak script. A coherent script can produce scenes that do not connect visually. A storyboard can satisfy the narrative while depicting the product incorrectly. Animation can introduce artefacts that were absent from the source frames.

Treating the pipeline as a single prompt hides those boundaries. Treating it as a sequence of explicit skills lets us inspect intermediate artefacts, apply the right constraints at the right point and retry a failed stage without rebuilding everything.

This does introduce orchestration overhead. More stages mean more state, more versioning and more ways for a partial failure to propagate. The system has to earn that complexity by improving accepted output, reducing rework or widening the range of ideas that can be tested. A longer agent trace is not a result by itself.

Evaluation is part of production

Generation without evaluation moves the bottleneck downstream. Someone still has to find the wrong colours, invalid format, unsuitable character, visual artefact or inaccurate gameplay. If the system cannot detect those problems, it has automated asset creation rather than the creative workflow.

Replai’s current evaluation layer combines three forms of checking.

Deterministic rules handle requirements that can be expressed precisely. A video can be checked for its dimensions, format and other hard constraints without asking a language model for an opinion.

Model-based evaluators handle criteria that require interpretation. We use multiple LLMs as judges rather than relying on a single model and a single score. They assess outputs against the relevant business taxonomy and creative rules, including checks related to brand and visual consistency, the type of hero depicted, product or gameplay fidelity, and technical generation quality.

Human review provides the reference signal for alignment. Reviewers inspect outputs and automated assessments, correct mistakes and expose criteria that the system has represented poorly or missed entirely.

The combination matters because each method fails differently. Deterministic rules are dependable within their scope but cannot judge every semantic property of a video. Model judges cover less explicit criteria but can disagree, inherit shared blind spots or produce a confident explanation for a wrong verdict. Human review remains necessary where the cost of an error is high or the evaluators are not yet reliable enough.

Multiple judges do not create ground truth through voting. Their value has to be established against qualified human review on representative examples. We treat disagreement as evidence to inspect, not noise to average away.

From feedback to learning

A reviewer correction is useful for the current “animatic”. It becomes more valuable when the system can determine why the error happened and prevent the same class of failure later.

Different corrections belong in different places. A hard requirement may become a deterministic check. A recurring production procedure may change a skill. A client-specific fact may update the relevant knowledge. An evaluator that repeatedly misses the wrong type of hero may need a better rubric, examples or model configuration.

Simply storing every comment is not learning. The correction has to change a future decision, and that change has to improve held-out work without causing regressions elsewhere.

This is part of the broader system we are building. The operating workflow already covers ideation, scripting, scene decomposition, storyboards or frames, animatic generation, and evaluation against business rules and taxonomies. The complete learning loop, including durable memory updates and feedback from observed campaign performance, is not yet a finished end-to-end system, but we’re getting closer.

That boundary is deliberate. Creative feedback can be inconsistent. Campaign outcomes are delayed and confounded by targeting, placement, spend and audience. Automating an update before we know what the signal means would make the system faster at learning the wrong lesson.

What changes after the workflow becomes executable

The immediate benefit is a shorter path from an idea to something an expert can inspect. Experts can supply a direction or ask the system to propose alternatives. The pipeline can produce scripts and animatics, test them against known requirements and focus human attention on ambiguous or high-risk decisions.

The more important benefit is experimental capacity. Lowering the cost of a reviewable candidate allows teams to explore more of the idea space before committing to full production. The relevant metric is not the number of videos generated. It is the number of viable ideas tested for a given amount of time, money and expert attention, with fidelity held constant or improved.

We still need disciplined measurements to establish that value. A credible comparison should include elapsed time, human effort, review burden, retries, failure rate and cost per accepted artefact. It should also check whether gains survive across different briefs rather than appearing only on the examples used to build the system.

The engineering work ahead

Encoding expert judgement is not a one-time knowledge-transfer exercise. Taxonomies change. Clients disagree. Models and providers change underneath the workflow. A rule that is appropriate for one campaign may be harmful when applied globally. Evaluators drift, and a model update can improve visual quality while quietly weakening fidelity.

These are the problems we are working on at Replai: representing specialised expertise, designing reusable agent skills and workflows, coordinating multimodal generation, validating automated evaluators, learning from human correction and operating the whole system reliably under cost and latency constraints.

The standard we care about is not whether an agent can produce an impressive animatic once. It is whether the workflow can preserve the judgement experts already contribute, make that judgement testable, and let teams run more worthwhile experiments without multiplying human rework.

That is a harder engineering problem than video generation. It is also the one with durable value.

And we’ll share our journey with you.