# FireRed-OpenStoryline: an AI video editing agent driven by natural language > FireRed-OpenStoryline turns editing decisions into conversational prompts, with LLM planning, MCP tool calls, and reusable Style Skills. It is a Python project for people who would rather direct a video than operate a timeline, and it expects you to bring your own model keys. **FireRedTeam/FireRed-OpenStoryline** — FireRed-OpenStoryline is an AI video editing agent that transforms manual editing into intention-driven directing through natural language interaction, LLM-powered planning, and precise tool orchestration. It facilitates transparent, human-in-the-loop creation with reusable Style Skills for consistent, professional storytelling. - Repository: https://github.com/FireRedTeam/FireRed-OpenStoryline - Stars: 3,456 · Forks: 403 - Language: Python - License: Apache-2.0 - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/fireredteam-firered-openstoryline ## The editing problem FireRed-OpenStoryline targets Most video editing tools assume you want to operate a timeline. FireRed-OpenStoryline assumes you want to describe an outcome. The README frames the project as turning complex video creation into conversation, and the feature list backs that framing: media search and download, script generation, music and voiceover recommendation, conversational refinement, and skill archiving. The intended user is not a professional colorist. It is someone producing short, style-consistent video at volume, plus beginners who would otherwise stall on the first cut. The interesting part is the second half of that list. Editing Skill Archiving lets you save a complete editing workflow as a custom Skill, then swap the media and apply the same Skill to reproduce the style. That is a batch-production primitive, not a one-off assistant. If your problem is "I make the same kind of video every week with different footage," the design speaks to you directly. If your problem is "this one scene needs a specific frame trimmed," it does not. ## How the agent plans, calls tools, and keeps you in the loop The dependency list is the clearest description of the mechanism. langchain, langchain-core, langchain_openai, langchain_mcp_adapters, and mcp are all present, alongside fastapi and uvicorn. That combination points to an LLM planner that reaches editing operations through MCP tool calls, wrapped in an HTTP service. The repository layout agrees: agent_fastapi.py sits at the top level next to cli.py, with prompts/ and src/ beside them. Media handling is not left to the model alone. transnetv2_pytorch and moviepy handle shot detection and compositing, librosa and funasr and torchaudio cover audio analysis and speech, and faiss-cpu with sentence-transformers suggests retrieval over media or style references. The README describes clip segmentation and content understanding as steps applied to your thematic media, which matches the presence of a shot-detection model rather than a purely generative pipeline. The human-in-the-loop claim is structural, not decorative. Edits are issued as natural-language prompts and applied immediately, and the project keeps a .storyline/ directory at the repository root that is copied into the container image. That directory is where project state lives. It also means the agent is not a black box that emits a finished file; you steer it turn by turn. ## Installing FireRed-OpenStoryline and running a first edit The repository does not publish a package on PyPI in the files provided, so installation means cloning and running the local scripts. The Dockerfile gives the most explicit path: it uses python:3.11-slim, installs ffmpeg, wget, unzip, git, git-lfs, and curl via apt, then installs requirements.txt, then executes download.sh. The README badge states Python 3.11 or newer. If you prefer the container, the build and run sequence is short. The image exposes port 7860, which the Dockerfile comments identify as the Hugging Face Space default port, and the start command is run.sh. ```bash docker build -t openstoryline . docker run -p 7860:7860 openstoryline ``` After that, the service should be reachable on localhost at port 7860. The Dockerfile does not document which environment variables the agent needs for model access, so check config.toml before assuming a default model will work. The bare-metal path follows the same order. Create a Python 3.11 environment, install the pinned dependencies, run the download script, then start the FastAPI agent. ```bash python3.11 -m venv .venv source .venv/bin/activate pip install -r requirements.txt ./download.sh python agent_fastapi.py ``` The requirements file pins exact versions, including fastapi==0.128.0, mcp==1.26.0, moviepy==2.2.1, and torchaudio==2.11.0. That is helpful for reproducibility and unhelpful when a pin conflicts with your existing environment. The download.sh step is the one most likely to fail, because it fetches model or asset files and the README gives no fallback instructions if the download is interrupted. For a first real use, the README's own workflow is the guide: describe your theme, let the agent search and download matching media, review the generated script and narration, then refine by prompt. It also mentions a CLI, since cli.py is at the repository root, though the README does not document its flags. Treat the web or FastAPI interface as the documented entry point. ## Where FireRed-OpenStoryline breaks down The AI Transition Generation feature, added on 2026-04-02, comes with an explicit warning in the README. It depends on third-party AIGC video generation services, the cost is described as relatively high, and the README states that results are somewhat unpredictable because of variation in source material, prompts, and model performance. The project's own recommendation is to enable it only when needed. That is an unusually candid note, and it should shape your expectations for the whole pipeline: generated transitions are a paid, non-deterministic step, not a built-in effect. The larger limitation is control. Because edits are performed exclusively via natural-language prompts, there is no described path to specify an exact timecode, an exact keyframe, or a byte-identical re-render. Two runs with the same prompt and the same media can differ, since an LLM plans the sequence. For a documentary editor or anyone delivering to a broadcast spec, that is disqualifying. The tool is also a poor fit for a one-off project, because the value proposition concentrates in Skill reuse; a single video gets you the setup cost without the batch payoff. There are also operational unknowns. The README does not document rollback, does not describe how to undo a Skill application, and does not state what happens when media search returns nothing usable. The .storyline/ directory implies state persistence, but the README does not describe its format or whether it is safe to edit by hand. ## How it differs from a scripted pipeline built on MoviePy A common alternative is writing your own pipeline on top of moviepy or ffmpeg, which are both already dependencies here. The difference is where the decisions live. In a hand-written pipeline, you encode the cutting logic as code: fixed durations, fixed transitions, fixed text positions. It is deterministic and cheap to run, and it never surprises you. It also cannot adapt when the footage changes shape, and every new style means new code. FireRed-OpenStoryline moves those decisions into a plan produced by an LLM and executed through MCP tools. The trade is explicit: you gain adaptation and style transfer from reference text, and you lose determinism and cost predictability. The README's Few-shot style transfer, where you define copy styles through reference text, is something a scripted pipeline cannot do without training or a large rule set. The AI transition feature is the clearest illustration of the cost side, since it bills against an external generation service. A second contrast is packaging. The project ships as an agent with a web-facing FastAPI service and a CLI, not as a library you import. If you wanted to call the editing logic from inside your own application, the README does not describe a supported API surface for that beyond the FastAPI service itself. ## Maintenance, licensing, and what an upgrade costs you The repository is not archived, and the last push was on 2026-07-31, so the codebase is receiving changes. There are no retrieved releases, which means there is no tagged version to pin against. Upgrades therefore mean pulling the default branch, and the pinned requirements.txt is your only stability anchor. If an upstream pin moves, you find out at install time. The project is licensed under Apache-2.0, which permits commercial use and modification and includes an explicit patent grant. That covers the code in the repository. It does not cover the third-party model services the agent calls, and the README's cost warning about AI transitions is a reminder that your real operating cost sits outside the licence. I am not a lawyer and this is not legal advice; if you plan to redistribute a product built on this, review the Apache-2.0 terms and the terms of whichever model providers config.toml points at. The upgrade cost is dominated by the dependency graph. torchaudio, funasr, sentence-transformers, and faiss-cpu are heavy, and a Python version bump can invalidate the pinned wheels. Budget for a rebuild rather than an in-place pip upgrade. ## Conclusion Adopt FireRed-OpenStoryline if your workflow is repetitive, style-driven short video and you are comfortable wiring up external model credentials, because the repository ships a Dockerfile, a download.sh, and a config.toml rather than a hosted product. Do not adopt it if you need frame-accurate manual control or deterministic, reproducible cuts, since the README states that edits are performed exclusively through natural-language prompts. Before committing, verify that download.sh completes without network failures, that your Python is 3.11 or newer, and that you accept the Apache-2.0 terms plus the third-party service costs the README flags for AI transitions. ## FAQ ### What is FireRed-OpenStoryline? It is an AI video editing agent that turns manual editing into intention-driven directing through natural language, LLM planning, and tool orchestration. The README lists media search, script generation, music and voiceover recommendation, conversational refinement, and reusable editing Skills as its main features. ### How do I install FireRed-OpenStoryline? Clone the repository and either build the provided Dockerfile, which installs ffmpeg and the pinned requirements before running download.sh, or create a Python 3.11 environment, run pip install -r requirements.txt, execute ./download.sh, and start the agent with python agent_fastapi.py. The container exposes port 7860. ### Does FireRed-OpenStoryline cost anything to run? The code is Apache-2.0 licensed, but the README warns that AI Transition Generation relies on third-party AIGC video generation services and that the cost is relatively high. The README recommends enabling that feature only when needed. ## Sources - [FireRedTeam/FireRed-OpenStoryline on GitHub](https://github.com/FireRedTeam/FireRed-OpenStoryline) - [Issues](https://github.com/FireRedTeam/FireRed-OpenStoryline/issues) - [License: Apache-2.0](https://github.com/FireRedTeam/FireRed-OpenStoryline/blob/main/LICENSE) - [README](https://github.com/FireRedTeam/FireRed-OpenStoryline/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/fireredteam-firered-openstoryline