NolanX: self-hosting the open source long-runtime agent stack for AI filmmaking
Nolanx, Open-sourced AI Netflix.
At a glance
- What is it?
- NolanX is an MIT-licensed monorepo that wires a web app, an API server and a Python agent runtime around text, image and video model providers so short-form generators can be chained into longer runs. The install path is one script, and the cost of that convenience is a hard dependency on three paid API keys.
- Who is it for?
- Adopt NolanX if you already hold OpenRouter, FAL and ReelMind credentials and want the runtime orchestration rather than another generation model. Do not adopt it if you need an offline pipeline or a fully open model stack, because the README states plainly that chat, image and video generation simply do not run without those keys.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 116 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 17, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem NolanX targets: generation limits, not model quality
Most video models are evaluated on a single clip. NolanX starts from the opposite end. Its README describes the project as "Open-source long-runtime multi-modal agent infrastructure for filmmaking" and frames the goal as pushing video models "far beyond their native single-generation limits" while keeping long creative runs coherent across language, image, audio and video. The stated target is 5 minutes, 30 minutes, even 1 hour of output, built on short-form generators such as Seedance 2.0, Kling 03, Google Veo 3.1 Lite, LTX 2.3, PixVerse v6 and Wan 2.7.
The intended user is not someone who wants a better clip. It is someone who already has generation access and now needs the layer above it: story logic, screenplay, script breakdown, character views, scenes, props, sound, auditions, world assets, timeline editing, storyboard structure, dialogue, performance detail and directorial reasoning. That list comes from the README and it is the real scope of the project. NolanX is an orchestration system. If your bottleneck is model quality, this repository does not address it.
Three processes, three ports, one config file
The repository is a pnpm monorepo with a Python component. The package.json describes it as an "Open-source NolanX monorepo: web app, API server, and Python agent runtime", and the quick start confirms three separate services: web on port 3000, api on port 8080, and agent on 127.0.0.1:52178.
The layering is by capability rather than by feature. Text runs through OpenRouter, defaulting to google/gemini-3.5-flash, and handles chat, planning, screenplay generation, routing and general reasoning. Image runs through FAL, defaulting to openai/gpt-image-2, and covers generation, editing, keyframes and visual references. Video runs through ReelMind's endpoint at https://nestapi.reelmind.ai/external-api/video/generate with dreamina-seedance-2-0-260128 as the default model, and handles shot generation. Cloudflare R2 is optional and holds uploaded references, generated assets and persistent storage for continuity flows.
The README states that apps/agent/config.toml is the primary self-host configuration file, that apps/api/data/runtime-config.json stores values edited through the UI, and that the root .env is only for local host and port overrides. That split is worth respecting. Putting provider keys in .env when the runtime expects them in config.toml is a common way to end up with a stack that starts cleanly and then fails on the first generation request.
Installing NolanX and running the first generation
The README gives a single clone-and-start command. It clones the repository, changes into it and runs the dev script, which brings up all three services and opens the browser at the NolanX route.
clone https://github.com/nolanx-ai/nolanx.ai.git && cd nolanx.ai && ./dev.shIf you have already cloned, the README gives the shorter form. After startup you should see web on http://localhost:3000, api on http://localhost:8080 and agent on http://127.0.0.1:52178, with the browser opening http://localhost:3000/nolanx automatically.
cd nolanx.ai
./dev.shBefore any generation will work you need provider keys. The .env.example lists them with empty values, which is the clearest signal that the stack starts without them but cannot generate. Copy the example file and fill in the three runtime keys plus the optional R2 block.
cp .env.example .env
# then edit .env and set:
# OPENROUTER_API_KEY=
# IMAGE_API_KEY=
# VIDEO_API_KEY=The README is explicit about the failure modes. Without OPENROUTER_API_KEY, chat, planning and script generation do not run. Without IMAGE_API_KEY, image generation and editing do not run. Without VIDEO_API_KEY, video generation does not run. Without the R2 variables, NolanX still runs, but enhanced persistence, upload and continuity flows stay disabled.
There is also a Docker path. The docker-compose.yml defines the same three services on node:22 for api and web and python:3.12 for the agent, each mounting the repository and reading .env. The agent service creates a virtual environment, installs requirements.txt and starts main.py bound to 0.0.0.0 on port 52178.
docker compose upFor verification without a full run, the README's development section gives build checks for each app and a compile check for the agent entry point. That last command is the cheapest way to confirm the Python side is importable before you spend money on generation calls.
pnpm --dir apps/web build
pnpm --dir apps/api build
cd apps/agent && .venv/bin/python -m py_compile main.pyRuntime keys can also be edited after startup. The README points to the Runtime Keys control under /nolanx for local overlays, which writes to apps/api/data/runtime-config.json. Local data otherwise lives in apps/api/data as nolanx-db.json and runtime-config.json.
The provider dependency is the real limitation
NolanX does not ship a model. Every generative capability in the stack resolves to an external paid endpoint, and the README says so without hedging: no key, no capability. That is a deliberate design choice, and it is also the constraint that will decide whether the project fits your situation.
The video layer deserves particular attention. The README states that the default video route is ReelMind's own API platform and that "this routed path includes a 5% markup". That is not a hidden cost, but it is a cost, and it sits on the layer that will dominate spend in any real production run. The README's own self-host note for video is to "replace this layer with your preferred video provider or internal endpoint", which is a fair description of the work involved: you are expected to swap it.
The same applies to text and image. The README calls the text provider "the first provider family you swap or extend" and tells self-hosters to replace the image endpoint with their preferred stack. In practice this means the repository is a runtime and an agent design, not a bundle. If you do not already have generation credentials, the true cost of adopting NolanX is the cost of acquiring them.
The optional R2 layer is the one place where degradation is graceful. The README states that NolanX still runs without it, with persistence, upload and continuity flows limited. For a project whose whole premise is long-run coherence, that is a meaningful reduction, but at least it is a reduction rather than a failure.
One more boundary is worth naming. The README says the repository is "trimmed to the NolanX path" and that community, membership, admin and credit logic are out of scope. Anyone expecting the hosted product's account system in this code will not find it. What is here is the runtime.
How this differs from ComfyUI-style graph pipelines
The closest familiar comparison is a node-graph generation tool such as ComfyUI, where you assemble a pipeline visually and the graph itself is the artifact. NolanX inverts that. The artifact is a long-running agent process on port 52178 that reasons about story structure and directs the generation calls, with the web app on port 3000 as the editing surface and the API on port 8080 as the boundary.
That difference is visible in what the README lists as responsibilities. A graph pipeline does not have "directorial reasoning" or "script breakdown" as a layer. NolanX does, and it places those in the text provider's column alongside routing and planning. The design assumption is that continuity across a 30-minute run is a planning problem before it is a generation problem.
The trade-off is control. In a graph tool you can inspect and rewire every edge. In NolanX the interesting decisions are made inside the agent runtime and the provider layers, and the README's answer to customization is to edit config.toml and replace providers rather than to rewire a visible graph. The README also credits the Jaaz project as an inspiration and mentions modifying LangChain where needed, plus ideas drawn from OpenClaw, Harness, Hermes and long-memory systems. That lineage suggests the agent design is the part the authors consider novel, and the provider wiring is the part they expect you to change.
Licence, maintenance and what upgrading costs you
The repository is MIT licensed, which is permissive and places few obligations on how you use or redistribute the code. The practical implication for a self-hoster is that the licence is not the constraint; the provider terms are. Your OpenRouter, FAL and ReelMind accounts each carry their own conditions, and the README's 5% markup note on the video route is a commercial term rather than a licensing one. Nothing here is legal advice, and if you plan to redistribute a modified stack commercially, the provider agreements are the documents to read.
On maintenance, the facts are narrow. The repository is not archived. The last push was on 2026-05-26. There are no retrieved releases, and package.json carries version 0.1.0, which is consistent with a project that has not yet cut a tagged version. The README states that two people maintain nolanx.ai and reelmind.ai, which sets expectations about how quickly issues and provider changes will be absorbed.
Upgrade cost is concentrated in one place: the provider layers. Because text, image and video are each a swappable family with a default model string in config.toml and a matching key in .env, a provider deprecating a model name means editing IMAGE_MODEL, VIDEO_MODEL or OPENROUTER_MODEL rather than rewriting agent logic. That is a good boundary to have drawn. It also means the agent runtime is the part you cannot cheaply replace, so watch changes under apps/agent most closely when you pull new commits.
Editorial conclusion
Adopt NolanX if you already hold OpenRouter, FAL and ReelMind credentials and want the runtime orchestration rather than another generation model. Do not adopt it if you need an offline pipeline or a fully open model stack, because the README states plainly that chat, image and video generation simply do not run without those keys. Before committing, read apps/agent/config.toml and confirm which provider each layer points at, then decide whether the ReelMind video route with its 5% markup is acceptable or whether you will replace that endpoint with your own. The repository was last pushed on 2026-05-26, so check recent commit activity against your own maintenance expectations.
Frequently asked questions
What is NolanX?
NolanX is an MIT-licensed, open source long-runtime multi-modal agent infrastructure for filmmaking, published as a monorepo containing a web app, an API server and a Python agent runtime. Its stated purpose is to extend short-form video generators into longer, coherent production runs.
How do I install and run NolanX locally?
The README gives a single command that clones the repository and runs ./dev.sh, which starts web on http://localhost:3000, api on http://localhost:8080 and agent on http://127.0.0.1:52178, then opens http://localhost:3000/nolanx. A docker-compose.yml is also provided with the same three services.
Does NolanX work without API keys?
It starts, but generation does not. The README states that without OPENROUTER_API_KEY, chat, planning and script generation do not run; without IMAGE_API_KEY, image generation and editing do not run; and without VIDEO_API_KEY, video generation does not run. The R2 variables are optional, and without them persistence, upload and continuity flows stay disabled.
Community notes