Magiviz: A Self-Hosted AI Video Pipeline That Runs Five Steps in Order

The Problem Magiviz Targets: One Story, Many Disconnected AI Tools

Producing an AI video today usually means stitching together separate services. You write a script in one chat window, generate character art in a second tool, build storyboards in a third, then hand each shot to a video model and reassemble the clips. Nothing shares state. If a character's face drifts between shots, you find out at the end.

Magiviz is built for the person who wants that chain in one place. The README describes it as an AI-driven intelligent video creation platform that covers Hollywood-style film, anime, story drama, advertising and explainer content, and claims a user can go from an idea to a finished video in minutes without prior experience. The repository is a TypeScript Next.js app with app/, components/, trigger/ and drizzle/ directories, so the intended audience is developers and creators willing to run their own instance rather than use a hosted editor. The homepage at magiviz.com is listed as an online demo, which means the hosted version exists alongside the source.

The Five-Step Workflow and How Data Moves Through It

The core interaction lives in components/operate.tsx, which the README says is roughly 10,289 lines and implements an AIFunction component. The pipeline is serial across five stages but parallel within stages two, three and four.

Step one calls /api/ai/generate-story-details with the user prompt, duration, aspect ratio, video style, video model and any reference image. It returns structured JSON containing a title, a scene list and a character list, where each character carries a description plus storyboard and video prompts. The README notes that parsing uses tryParsePossiblyMalformedJson to tolerate LLM output that is not strict JSON, which tells you the project expects imperfect model responses rather than trusting a schema.

Step two calls /api/ai/generate-character-image for each character in parallel. If the user uploaded a reference image, it is passed as referenceImage for image-to-image generation. Step three calls /api/ai/generate-storyboard-image per scene, and filters characters so only those referenced by that scene's characterIds are sent. Step four calls /api/ai/generate-story-video per scene, passing aspectRatio, duration, videoStyle and videoModel, and accepting uploaded video or audio as videoUrls and audioUrls when the selected model is a Seedance variant. Step five calls /api/ai/fal/compose-story-video, which uses FAL AI to concatenate the scene clips into one file with total duration, thumbnail, aspect ratio and file size.

The state machine is explicit: type WorkflowStep = 'idle' | 'script' | 'character' | 'storyboard' | 'scenes' | 'video'. Each step renders as current, completed or pending. Pausing waits for in-flight asynchronous tasks for up to 60 seconds before calling abortController.abort(), and resumeWorkflow dispatches on the stored workflowStep so a paused project continues from where it stopped. A versionGroupId is minted on every regeneration so prior versions stay queryable instead of being overwritten.

Installing Magiviz and Running Your First Project

The README does not provide a step-by-step install guide. What it does expose is the script surface in package.json, which is enough to reconstruct the intended local flow. You need Node.js and a package manager; the repository ships both package-lock.json and pnpm-lock.yaml, and .npmrc is present at the top level.

Clone the repository and install dependencies with the lockfile you choose:

git clone https://github.com/ItusiAI/Open-Magiviz.git
cd Open-Magiviz
npm install

Database work runs through Drizzle against the config in drizzle.config.ts, and the dependency list includes @neondatabase/serverless, so a Postgres-compatible connection string is expected. Push the schema before starting:

npm run db:push

The app itself is a standard Next.js project:

npm run dev

Long-running generation jobs are handled by Trigger.dev, since trigger.config.ts and the trigger/ directory are both present and the scripts include trigger:dev and trigger:deploy. In a second terminal, start the worker:

npm run trigger:dev

What you should see is the Next.js dev server coming up, the Drizzle push reporting the schema is in sync, and the Trigger.dev worker connecting. The README does not document which environment variables are required for the model providers, Stripe or S3, so expect to read the source under app/ and lib/ to find the key names. The README also does not document a Docker path or a rollback procedure.

Model Selection, Media Locking and the Parameter Panel

The generation panel exposes four controls. Video model accepts auto, veo31Lite, veo31Fast, veo31Quality, geminiOmni, seedance25, seedance2Fast, seedance2Mini, seedance2, kling3, happyHorse, wan30, wan30Prime and minimaxH3. Generation mode is auto or first-last-frame. Aspect ratio is 16:9 or 9:16. Duration is auto, 15s, 30s or 60s, and video style is auto, anime, hollywood or ads.

The per-model duration rules are hardcoded rather than inferred. The README states Veo is fixed at 8 seconds, Seedance 2.5 supports 4 to 30 seconds, the Seedance 2.0 series supports 4 to 15 seconds, and Wan 3.0 supports 2 to 30 seconds. That matters because a 60-second target on a Veo run has to be split into eight-second segments, and the segmentation happens during step one, not at render time.

Media compatibility locks automatically. If you upload video or audio, the model selector restricts you to the Seedance family, and validateSeedanceMedia calls probeMediaUrl to check counts against SEEDANCE_LIMITS.video.maxCount and audio.maxCount, total duration against maxTotalDuration, and per-file format and size. The README is explicit that multimodal video and audio references are supported only by Seedance models. If your workflow depends on a Veo or Kling look, you cannot also feed it reference footage.

Regeneration Is Granular, and That Is the Real Design Decision

Most script-to-video tools make you rerun everything when one shot is wrong. Magiviz scopes regeneration by element. Regenerating the story reruns all five steps. Regenerating a character finds the affected scenes and regenerates their storyboards, scene videos and the final composite. Regenerating a single storyboard regenerates only its scene video and the composite. Regenerating a scene video regenerates only the composite. Regenerating the full video runs the composition step alone.

In first-last-frame mode there is an additional path: regenerateFrameType rebuilds only the first or only the last frame, using firstFramePrompt or lastFramePrompt, and then flows through to the scene video and composite. That is a narrower blast radius than most pipelines offer, and it is the strongest argument in the README for using Magiviz over assembling the same models by hand.

The cost is complexity. The character regeneration path has to compute which scenes reference the changed character, which means the scene-to-character mapping has to stay correct across edits. The README does not describe what happens if a user edits a character after scenes have already been rendered against an older version, beyond noting that versionGroupId keeps the old version queryable.

Where Magiviz Is the Wrong Tool

Two gaps stand out. The licence is not identified anywhere in the README or the repository listing, and there is no LICENSE file at the top level. For a project that bundles Stripe billing, an S3 client and multiple paid model APIs, shipping without a declared licence means you cannot make an informed decision about redistribution or commercial use. Treat that as a blocker until it is resolved.

The second gap is operational. There is no Dockerfile, no docker-compose, and no install section in the README. You are expected to assemble Postgres, object storage, Trigger.dev and the Next.js app yourself, and to discover the environment variables by reading the source. The README also does not document rollback, migration reversal or how to recover a project whose Trigger.dev run died mid-step. If you want a managed editor, the hosted demo at magiviz.com is the simpler answer, and if you want a library rather than an application, this is the wrong shape entirely: it is a full web platform, not an SDK.

One more constraint worth naming: the README states that video and audio reference inputs are Seedance-only. Anyone whose preferred look comes from Veo or Kling loses multimodal reference when they need it.

How Magiviz Differs from ComfyUI-Style Node Graphs

The closest alternative approach is a node-graph tool such as ComfyUI, which the README itself references in the sponsor section as a supported surface for the MiniMax H3 API. The difference in approach is structural. ComfyUI gives you a graph of primitives and leaves orchestration, state and persistence to you or to community extensions. Magiviz gives you a fixed five-stage pipeline with a defined state machine, a database schema managed by Drizzle, version tracking through versionGroupId, and a web UI with per-element regeneration.

That means Magiviz trades flexibility for a working default. You cannot rearrange the stages, and you cannot swap in a model that is not in the parameter list without editing the code. In exchange you get pause and resume, credit-aware interruption, project history and a UI that a non-developer can operate. If your goal is to experiment with sampling settings and custom nodes, the graph approach wins. If your goal is to hand a repeatable production line to a small team, the pipeline shape is the point.

Maintenance, Upgrade Cost and Licensing

The last push to the default branch was on 2026-09-04, and the repository is not archived. Version 1.0.4 is the package version, and no releases were retrieved, so upgrade guidance has to come from the commit history rather than from release notes.

Upgrade cost is dominated by the dependency surface. package.json pins a large Radix UI set, Next.js, Drizzle, the AWS S3 client, @fal-ai/client, @neondatabase/serverless, Stripe and the auth adapter. Drizzle migrations are generated and applied through db:generate and db:migrate, so schema changes are trackable, but the README does not state whether migrations are additive or whether a downgrade is supported. Budget for reading diffs before you pull.

On licensing: no licence identifier appears in the README or the repository listing, and no LICENSE file is listed among the top-level entries. That is not a detail you can defer, because it determines whether you may fork the code, run it commercially, or redistribute a modified version. Because the project integrates Stripe for payments, any deployment that sells access inherits the billing and tax obligations of the operator, not of the upstream authors. That is a general observation about running a paid service, not legal advice; consult a lawyer about the licence question once it is resolved.

Editorial conclusion

Adopt Magiviz if you want a self-hosted, TypeScript-based pipeline that orchestrates several video models behind one workflow and you are prepared to run Postgres, object storage and a Trigger.dev worker alongside it. Do not adopt it if you need a licence you can read before shipping, or if you expect a documented Docker or one-command install; the README gives neither. Verify the licence file first, then check whether the FAL and model API keys you already hold cover the models the parameter panel exposes.

Frequently asked questions

Official sources

1. Issues
2. ItusiAI/Open-Magiviz on GitHub
3. Project website
4. README