How Flova Works

Flova is not a single model. It is a collaborative system made up of multiple specialized agents. Understanding that system helps you predict Flova's behavior and work with it more effectively.

Planner: The Brain of the System

The Planner is the central orchestrator of Flova's agent system. It does two things:

1. Understands your intent: it reads your message, the current storyboard state, the project documents, and the active Skill to decide what you actually want

2. Breaks work down and dispatches it: it turns your goal into executable subtasks and hands them to the right sub-agents

The Planner does not directly perform creative work itself. It does not generate images or modify the storyboard. Its job is to think and coordinate.

Planner decision logic

Every time it receives your message, the Planner enters a think-act loop. It first evaluates whether it needs clarification or confirmation from you. If not, it chooses which sub-agent should act next. Once it receives the result, it evaluates the next step: dispatch another task or report completion back to you.

That loop allows the Planner to handle complex multi-step workflows. A request like "generate a complete short video from scratch" may require a sequence of calls to the storyboard designer, media generator, and video assembler, all coordinated by the Planner.

Stop conditions

The Planner stops and returns control to you under the following conditions:

• the task is complete

• more information is required

• a key decision must be made by you

• the system hits a constraint such as quota or platform limitation

The Sub-Agent System

Flova currently includes the following specialized sub-agents:

Storyboard Designer

This agent focuses on creating and maintaining storyboard structure. If you say, "Help me plan a three-minute short film about urban night running," the Planner routes that request to the storyboard designer.

Its core principle is "structure first." It resolves narrative logic and shot ordering before moving into the details of each shot. It outputs structured modifications such as add, update, delete, and reorder actions rather than rewriting the storyboard directly, which keeps every change traceable and reversible.

Media Generator

This agent is responsible for creating and managing all media asset groups: image generation, video generation, voice-over synthesis, and music generation.

It handles three main scenarios:

1. Initial generation: creating a new visual or audio asset group from a shot description

2. Revision and regeneration: generating a new version based on user feedback and reference media while preserving older versions

3. Structural management: registering asset groups, maintaining bindings, and tracking resources without generating new content

The media generator follows an important principle: lazy updates. It only regenerates the source asset group you explicitly target. For downstream resources that depend on it, it produces an impact list for the Planner rather than regenerating everything automatically.

Analyze & Prepare

When you upload images, video, or documents, this agent analyzes the material and extracts structured information such as scene descriptions, character traits, and style tags to support later creative work.

Video Assembler

This agent assembles the storyboard blueprint and shot media into a previewable timeline. It manages three tracks: main video, voice-over, and music. Each operation changes only what is necessary instead of rebuilding the entire timeline every time.

Text Editor

This agent maintains project-memory documents such as Final Video Spec and Skill files. It edits them through controlled text operations so the modification history remains traceable.

Skill Loader

This agent injects Skill content into sub-agent working contexts at the right moment. Only the relevant Skill sections are sent to each sub-agent, rather than dumping the entire Skill document into every context window.

The ReAct Loop: Thinking and Acting

Flova's working mode follows the ReAct pattern from the AI field: reason first, act second, then use the result of the action to drive the next round of reasoning.

For users, that means:

Every Flova decision has a reason. The Planner does not call sub-agents randomly. It reasons from the current state before deciding.

Complex tasks are decomposed naturally. If you ask Flova to complete a whole project end to end, it does not try to do everything in one opaque step. It moves in stages, reports progress, and pauses when your judgment is required.

Intermediate states are visible. You do not need to wait until everything is done to see progress. Storyboards and media libraries update as each sub-agent finishes its work.

Context Injection: Flova's Working Memory

When a sub-agent runs, Flova automatically injects the context that is relevant to that agent's responsibility. The governing logic is simple: keep each agent focused on the information it actually needs and hide what would only distract it.

The storyboard designer needs narrative structure, not detailed generation settings. The media generator needs shot descriptions and references, not the full editing logic of the timeline. By carefully scoping what each agent can see, Flova helps specialized agents make better decisions in their own domain rather than drowning them in the full volume of project information.