Jellyfish Review 2026: AI Short-Drama Production Workspace

Jellyfish is an open-source production workspace for AI-generated short dramas. The repository at github.com/Forget-C/Jellyfish shows 6,504 stars, and the project site at forget-c.github.io/Jellyfish describes it as an end-to-end pipeline that takes a script through to a finished episode. The pricing page lists a starting tier at $0/mo, which means the entry point is free rather than gated behind a sales call.

This review is written from the documentation, the repository, the project site and the published pricing. Nobody here ran the tool, generated an episode with it, or benchmarked its output. What follows is an analysis of what the project claims to do, how it is structured, what it costs, and where it fits against the alternatives a short-drama creator would actually consider in 2026.

What is Jellyfish?

Jellyfish is not an AI coding assistant and it is not an engineering analytics platform. It is a production workspace for short-form AI drama — the vertical, serialized, often 60-to-180-second episodes that have become a genuine content category on TikTok, Reels, YouTube Shorts and the Chinese equivalents. The repository describes the scope as script to finished episode, which is a wider claim than most AI video tools make. Most of them stop at clip generation and leave assembly, continuity and sound to the user.

The category matters because short drama is not the same problem as general AI video. A single generated clip is a demo. A finished episode needs consistent characters across shots, a script that survives the cut, dialogue that lines up with mouth movement, music that does not fight the voice track, and subtitles that are timed correctly. The project site frames Jellyfish as the workspace that holds all of those stages together rather than a model that does one of them well.

That framing is the honest way to read the project. Jellyfish is a pipeline and an interface. The underlying generation is done by external models — the kind of large multimodal systems listed on public model pricing pages — and Jellyfish orchestrates them into a production flow. The repository shows 6,504 stars, which for a niche creative tool is a meaningful signal that people are watching it, though stars measure attention rather than production reliability.

Who should use Jellyfish in 2026?

The natural user is a solo creator or a very small team producing serialized short drama at a pace that makes manual editing painful. If you are making one episode a month by hand in a general video editor, Jellyfish is probably more machinery than you need. If you are trying to ship several episodes a week with a consistent cast of AI characters, the case gets stronger, because the repetitive parts — shot assembly, subtitle timing, voice alignment — are exactly the parts a workspace can automate.

It also suits people who already have a script pipeline and want to keep it. The project is open source, so a technically comfortable creator can read the code, change the prompts, swap models, and host it themselves. That is a different proposition from a closed SaaS video tool where the model choice is fixed and the workflow is whatever the vendor decided.

It is a poor fit for anyone who wants a finished episode with zero configuration. The repository is a codebase, not a consumer app. Expect to install dependencies, supply API keys for whatever generation models you use, and debug failures yourself. It is also a poor fit for teams that need collaboration features, review workflows, or asset management at studio scale. Nothing in the documentation suggests Jellyfish is built for a ten-person production house with approval chains.

And it is not for people who want live-action editing. Jellyfish is aimed at AI-generated content. If your footage comes from a camera, a conventional NLE is the right tool and Jellyfish adds nothing.

Key features: script to finished episode

The project describes an end-to-end flow, and the interesting question is what each stage actually covers. Based on the documentation and repository structure, the pipeline runs roughly as follows.

Script handling

The entry point is a script. Jellyfish takes written material and turns it into a structured production plan — scenes, shots, characters, dialogue. This is the stage that separates a drama tool from a clip generator, because a script implies continuity across time, and continuity is where AI video usually falls apart. The documentation presents script parsing as the foundation the rest of the pipeline depends on.

Character and visual consistency

Short drama lives or dies on whether the same character looks like the same person in shot one and shot forty. The project site presents character consistency as a core concern, which is the right priority. Any tool in this space that does not solve it produces unusable serialized content. How well Jellyfish solves it depends on the generation models it calls and the reference-image handling in the pipeline, neither of which can be judged from documentation alone.

Voice, dialogue and audio

Dialogue-driven drama needs speech that matches the character and the timing. The pipeline includes voice generation and alignment as a stage rather than leaving it to a separate tool. Music and sound effects sit alongside it. This is the part of the workflow that most creators underestimate — a visually perfect episode with mismatched audio reads as amateur immediately.

Assembly and subtitles

Final assembly, subtitle timing and export are the last stages. Subtitles matter more in short drama than in almost any other format, because a large share of viewing happens muted on a phone. A workspace that handles subtitle timing automatically removes a genuinely tedious manual step.

Model orchestration

Because Jellyfish is a workspace rather than a model, its cost and quality are largely determined by which generation models you plug in. Public model pricing in 2026 spans a wide range. On the low end, openai/gpt-5-pro lists at $15/M input and $120/M output, and anthropic/claude-opus-4.1 at $15/M input and $75/M output. Mid-range options include openai/gpt-5.5-pro at $30/M input and $180/M output and anthropic/claude-opus-4.6-fast at $30/M input and $150/M output. At the top, openai/o1-pro lists at $150/M input and $600/M output, with a batch tier at $75/M input and $300/M output. For script generation and rewriting, the cheaper tiers are usually sufficient; the expensive reasoning models only make sense if you are asking for structural story work rather than prose.

Video generation models are priced separately and are not in the snapshot above, so a full episode cost cannot be calculated from these numbers alone. The honest statement is that Jellyfish itself starts at $0/mo and the real spend is your model usage, which scales with episode count and quality target.

Jellyfish pricing: free entry, model costs on top

The pricing page lists a starting tier at $0/mo. That is the entry point, and it is worth being precise about what it does and does not mean. A free starting tier on an open-source production workspace typically means you can run the software without paying the project, while you pay separately for the generation models and any hosting you use. The tool block does not list higher paid tiers, seat limits, or usage caps, so this review does not invent any. If Jellyfish adds paid plans, they will appear on the pricing page.

The practical cost model is therefore: $0/mo for the workspace, plus your model bill. That is a different shape from closed SaaS video tools, which bundle generation into a subscription and mark it up. It is also a different shape from enterprise creative suites, which charge per seat and per render minute. For a solo creator, the open-source-plus-your-own-keys model is usually cheaper at low volume and more expensive in time, because you are the one wiring the models together.

Compare that with the alternatives a short-drama creator would weigh. General AI video platforms bundle generation and editing but lock you to their models and their pricing. Traditional NLEs cost a flat subscription and give you full control but no AI generation. Jellyfish sits between them: open pipeline, bring your own models, no vendor markup on inference.

How this review was researched

Sources for this review are the project repository at github.com/Forget-C/Jellyfish, the project site at forget-c.github.io/Jellyfish, the published pricing information showing a $0/mo starting tier, and the live model pricing snapshot used to estimate generation costs. The repository shows 6,504 stars. No hands-on use, installation, or benchmark was performed, and no episode was produced with the tool. Claims about pipeline stages come from the documentation and repository structure; claims about cost come from published pricing. Where the documentation is silent — for example on exact output quality, render times, or model compatibility beyond what is listed — this review says so rather than filling the gap.

Jellyfish pros and cons

The strengths are structural rather than cosmetic.

• End-to-end scope. Script to finished episode in one workspace is a genuinely wider claim than most AI video tools make, and it addresses the real bottleneck in short drama, which is assembly rather than generation.
• Open source. The code is readable and modifiable. You can change prompts, swap models, and self-host. That is rare in this category and it matters for anyone who does not want their production pipeline owned by a vendor.
• Free starting tier. The pricing page lists $0/mo, so evaluation costs nothing beyond your own model usage.
• Community signal. 6,504 stars on the repository indicates sustained interest, which usually correlates with active issue discussion and third-party fixes.
• Bring-your-own-model economics. No vendor markup on inference. You pay model providers directly at published rates.

The weaknesses are equally structural.

• Setup burden. This is a codebase, not a consumer app. Expect dependency installation, API key management, and debugging. The documentation helps, but it does not remove the work.
• Quality depends on models you supply. Jellyfish orchestrates; it does not generate. If your chosen models produce inconsistent characters, the workspace cannot fix that.
• No collaboration layer. Nothing in the documentation suggests review workflows, approval chains, or multi-editor asset management. Small teams will feel this.
• Cost is opaque until you run it. Because generation is billed per token or per clip by external providers, the true cost of an episode is not knowable from the pricing page. You have to estimate from your own usage.

Jellyfish vs. alternatives

The comparison set for a short-drama creator is not the same as for an engineering team. The relevant alternatives are general AI video platforms, traditional NLEs, and other open-source AI video pipelines.

General AI video platforms

Closed platforms bundle generation, editing and export into one subscription. They are faster to start and require no setup. They also lock you to their models, mark up inference, and give you no ability to change the pipeline. If you value time over control, they win. If you want to tune the workflow or keep costs at provider rates, Jellyfish wins.

Traditional NLEs

A conventional editor gives you total control and no AI generation. For live-action work it is the correct tool. For AI-generated serialized drama, it means doing shot assembly, subtitle timing and audio alignment by hand, which is exactly the labor Jellyfish automates. The trade is control versus speed.

Other open-source AI video pipelines

Several open-source projects stitch generation models into a workflow. Most stop at clip generation and leave the episode-level concerns — continuity, subtitles, audio — to the user. Jellyfish's differentiator, per its documentation, is that it treats the whole episode as the unit of production rather than the clip. That is the claim worth evaluating if you are choosing between them.

For teams that also need AI assistance on the writing side, general-purpose models are the usual route. At the cheaper end of the published snapshot, openai/gpt-5-pro at $15/M input and $120/M output and anthropic/claude-opus-4.1 at $15/M input and $75/M output are reasonable for script drafting. If you need heavier structural reasoning on story arcs, openai/o3-pro at $20/M input and $80/M output or openai/gpt-5.5-pro at $30/M input and $180/M output are the step up. Batch processing cuts cost where latency does not matter: openai/o1-pro:batch lists at $75/M input and $300/M output against $150/M and $600/M for the standard tier, and openai/gpt-5.5-pro:batch at $15/M input and $90/M output against $30/M and $180/M. For a production pipeline that generates many script variants overnight, batch pricing is the difference between viable and not.

Verdict: is Jellyfish worth it in 2026?

Jellyfish is worth it if you are producing serialized AI short drama and you want an open, self-hostable pipeline that covers the whole episode rather than just the clip. The $0/mo starting tier makes evaluation cheap, the 6,504-star repository suggests a real community, and the end-to-end scope addresses the actual bottleneck in this format, which is assembly and continuity rather than raw generation.

It is not worth it if you want a polished consumer app, if you need team collaboration features, or if you are not comfortable managing dependencies and API keys. In those cases a bundled AI video platform or a traditional NLE will serve you better. The honest summary is that Jellyfish trades convenience for control, and whether that trade is good depends entirely on how much of your production you want to own.

Rating: 4.0 out of 5. Strong scope and open licensing, held back by setup burden and a cost model that only becomes clear once you are running it.