
VOX-SHOT: AI-Assisted Video Production Architecture
The system is built around three independent but connected components:
- The Project Schema
- Plugins / Skills
- The Application
The most important architectural principle is that these three components remain separate. A project should not depend on a particular application, and AI skills should not be permanently embedded inside one application.
1. The Project Schema
The project is the durable source of truth for the production.
A project is represented as a self-contained folder containing everything needed to create the video, including:
- Project metadata
- Scripts
- Story information
- Media
- Generated images
- Generated video
- Reference material
- Production assets
- Other supporting files and data
At the core of the production schema are four primary asset categories:
- Characters
- Props
- Locations
- Style
These assets, along with the rest of the production data, live inside the project folder.
The goal is that the project folder is portable and self-contained. It should contain enough information that another compatible application or AI system could open the project and understand the production without depending on the application that originally created it.
The Schema Is Not a Workflow
The schema describes what can exist inside a production, not the order in which things must be created.
There is no required process such as:
Story → Characters → Locations → Shots → Video
A production might begin with a location, a character, a visual concept, a script, a prop, or an existing piece of media. Different tools may approach the project in completely different ways.
The schema therefore defines possibilities rather than requirements.
The Schema Can Be Richer Than the Application
Not every application needs to understand or use every part of the schema.
One application might work primarily with story and characters. Another might work with shots and generated video. Another might only manage assets.
The project may contain significantly more information than a particular application chooses to expose.
Applications should therefore treat the schema as an independent project format rather than as their own private database structure.
Ideally, an application should preserve project information it does not understand rather than deleting or rewriting it.
A useful principle is:
An application is a partial view of a project, not the definition of the project.
2. Plugins / Skills
Plugins are independent units of intelligence or capability.
They describe what can be done with the project.
Most of these plugins are AI-driven skills that understand some portion of the project schema and can analyze, create, modify, or expand project information.
Examples might include:
- Story development
- Script analysis
- Story beat generation
- Character development
- Prop development
- Location development
- Shot creation
- Establishing-shot generation
- Image generation
- Video generation
- Prompt generation
- Continuity analysis
- Storyboard development
- Visual-style development
Story Sherpa
Story Sherpa is an example of one of these skills.
Story Sherpa is the story intelligence component of the system.
It can take a client’s initial story idea or story impetus and analyze it using storytelling frameworks such as:
- StoryBrand
- Four Words, Five Lines
- A story rubric that evaluates the story’s strength, value, structure, and content
Story Sherpa identifies the strongest story beats and helps organize them into a more effective story.
Story Sherpa itself is not the underlying language model.
Instead:
Story Sherpa = storytelling methodology + rules + prompts + frameworks + structured intelligence
It then uses an LLM such as Claude, OpenAI, or another local or remote model to perform the reasoning.
This separation is important because the underlying AI model should be replaceable without changing the Story Sherpa methodology.
Conceptually:
Story Sherpa
↓
LLM Adapter
↓
Claude / OpenAI / Local LLM / Other Model
The same pattern can be used for other skills.
Plugins should ideally be independent of any particular user interface.
3. The Application
The application is the layer that connects the project schema with the available skills.
Its job is primarily to provide:
- Interaction
- Visualization
- Editing
- Navigation
- Orchestration
- Skill invocation
Conceptually:
PROJECT / SCHEMA ← APPLICATION → PLUGINS / SKILLS
The application reads and writes project information and gives the user access to skills that can operate on that information.
The application itself is replaceable.
At the simplest level, the application could be nothing more than a command-line interface using Claude, Codex, or another AI agent.
For example, an AI agent could open the project folder, understand the schema, invoke Story Sherpa, create new project data, and generate production assets without requiring a graphical interface.
At the more sophisticated end, the application could be a full Electron production environment containing:
- Asset browsers
- Character libraries
- Prop libraries
- Location libraries
- Style libraries
- Storyboards
- Shot management
- Relationship visualization
- Media browsers
- Timelines
- Review tools
- Approval systems
- Client portals
- World libraries
- Production dashboards
- Generation controls
These features are conveniences provided by that particular application. They are not part of the fundamental project architecture.
Overall Architectural Model
The architecture can be summarized as:
Project Schema
What can exist?
The durable, portable representation of the production.
Plugins / Skills
What can be done?
Independent AI-powered capabilities that understand and operate on parts of the production schema.
Application
How do I interact with it?
An interface and orchestration layer that chooses which parts of the schema and which skills it wants to expose.
Core Architectural Principles
1. The project owns the production.
The project folder is the source of truth, not the application.
2. Skills own the intelligence.
Storytelling, generation, analysis, and other AI capabilities live independently from the user interface.
3. The application owns the interaction.
The application presents project information and connects the user with the available skills.
4. The schema defines possibilities, not requirements.
The schema can support many kinds of production information without requiring every project or application to use all of it.
5. The schema does not define a workflow.
There is no mandatory production sequence. Applications and skills may create or modify project information in whatever order is appropriate.
6. An application is a partial view of the project.
Different applications can expose different subsets of the same project while remaining compatible with the same underlying schema.
7. The project should survive the application.
A project created today should remain usable if the current Electron application disappears or is replaced by another application later.
8. Skills should survive the application.
A skill such as Story Sherpa should be usable from an Electron application, a command-line environment, Claude, Codex, an automated agent, or another future interface.
The Result
This architecture allows the production system to evolve without locking projects into a single application.
The same self-contained project could potentially be opened by:
- A desktop Electron production application
- A lightweight client review application
- Claude
- Codex
- A command-line tool
- An automated production agent
- A rendering or generation worker
- A future application that does not yet exist
Each of these can understand as much or as little of the project schema as necessary and use whatever compatible skills are appropriate.
The fundamental separation is:
The project contains the production.
The plugins contain the intelligence.
The application connects the two.