webtoon-harness: 27 Claude Code agents that take a webtoon episode from trend research to a scroll viewer

What the harness produces, and for whom

webtoon-harness is a Claude Code harness that makes one episode of a webtoon end to end, from trend research to a finished vertical scroll viewer. The pitch is not "generate a comic image". It is that a team of 27 specialised agents and six skills runs the whole chain: research what is popular, write a dialogue-driven script with high tension and a twist in every episode, render character reference sheets first so the cast looks the same in every panel, render 50 or more panels per episode in parallel with speech bubbles and Korean dialogue baked into the image, re-render the panels that fail a validation pass, and assemble the result into a scroll viewer. The intended user is somebody producing a serialised webtoon who has access to Claude Code and wants the pipeline rather than the individual steps.

Four teams and 27 agents

The 27 agents are grouped into four teams that are reconstituted at each phase. The research team is five agents: trend-scout, platform-ranker, audience-analyst, hook-analyst and trend-synthesizer, with four researchers working in parallel and a synthesizer collapsing their output into one planning brief. The scenario team is nine: concept-architect, worldbuilder, character-designer, series-plotter, twist-master, tension-engineer, episode-outliner, dialogue-writer and script-editor. The visual team is eleven: art-director, ref-sheet-artist, panel-director, letterer, prompt-smith, three panel artists and panel-validator. The assembly and QA team is four: episode-compositor, quality-reviewer, continuity-manager and showrunner. Alongside them sit six methodology skills, with webtoon-orchestrator as the entry point that the README says auto-triggers and coordinates the teams.

Reference sheets first, bubbles baked into the image

Two design decisions do most of the work. The first is that character reference sheets are rendered before any panel exists. Multi-angle and multi-expression reference sheets are produced up front and act as the single source of truth for how a character looks, so consistency across episodes is anchored to an artifact rather than to the model remembering. The second is in-image speech bubble baking: bubbles and the Korean dialogue are drawn as part of image generation, so the final assembly needs no text overlay layer at all. Consistency is then enforced by injecting consistency tokens derived from the reference sheets and location tokens into every prompt, and the validator loop is described as catching md5 duplicates, abrupt background changes and broken Korean text.

Installing it into a Claude Code project

It is a harness, not an application, so installation is a copy. You clone the repository and drop its .claude directory into the root of the project you want to work in.

git clone https://github.com/revfactory/webtoon-harness.git
cp -r webtoon-harness/.claude /path/to/your-project/

Then start Claude Code in that project and ask in natural language. The README lists four requests it expects: one that runs the whole pipeline for episode one, one that produces the next episode while reusing the world, style and continuity already built, one that reruns only the scenario team to strengthen a twist, and one that re-renders and re-validates a single panel by number. The repository has no runtime of its own, so the two things you must already have are Claude Code for the agents and skills, and the codex CLI, because panel rendering goes through codex-image, the image_generation tool of codex exec. That needs ChatGPT OAuth authentication, and the README says to keep global concurrent codex sessions to five at most.

The generate-validate loop and the six-axis gate

The generate-validate loop is the part that separates this from a prompt-and-pray image batch. Panels are rendered by codex-image five at a time in parallel batches, then panel-validator runs a six-axis check, and only the panels that miss the threshold are regenerated. Passing is a gate, not a suggestion: the workflow diagram ends the render stage with validation.md, which records that every panel passed, and only baked-bubble panels move on to index.html. The pipeline itself is explicit about its order. A trend brief becomes concept, world, characters and a series arc, which split into a twist plan and a tension curve, which converge into a beat sheet, a script and script_final. From there a style bible and character sheets produce references, then a shot list and lettering spec, then prompts per scene, then panels, then the viewer.

What it costs you, and what is undocumented

The costs are worth naming. You are running 27 agent definitions through Claude Code and rendering panels through a separate CLI with its own login, so this consumes two sets of quota and the render step is capped at five concurrent codex sessions, which sets the ceiling on how fast an episode can be produced. The documentation is in Korean, including the suggested requests, so an English-only user is translating as they go. Continuity across episodes is tracked cumulatively for appearance, setting and foreshadowing, which is a real feature and also a real dependency: the value compounds only if you keep using the same workspace. The README does not document token or dollar cost per episode, so budget that empirically on a single episode before you plan a season.

Driving the panels by hand is the alternative

The alternative is to skip the harness and drive the panels yourself. Generating images one at a time in a tool like ComfyUI, then stacking them in an HTML page, gives you direct control of every prompt, lets you use any model including a local one, and costs nothing in agent orchestration. What you lose is exactly what the harness sells: a reference sheet acting as a single source of truth, consistency and location tokens injected automatically, a validator that rejects and regenerates weak panels, and a continuity ledger that survives into the next episode. If you are making a one-off short comic, hand-driven generation is simpler. If you are serialising and need episode 12 to match episode 1, the ledger is the reason to put up with the machinery.

Licence, layout and upkeep

webtoon-harness is MIT licensed, and the repository is small: a .claude directory holding the agent and skill definitions, a docs directory with the diagram images, a README and a licence. There are no releases, and the last push was on 2026-06-28, so there is no versioned artifact to pin and no changelog to read; what you clone is what you get. Every intermediate artifact is written to _workspace/, which the README frames as an audit trail, and finished episodes are packaged under RELEASE/ep{NN}/. Because the whole thing is Markdown agent definitions, forking and editing a team is a text edit, which is the practical upside of this format over a packaged tool.

Editorial conclusion

Take webtoon-harness if you are serialising a webtoon and the thing that keeps breaking is consistency, because the reference sheet as single source of truth and the continuity ledger across episodes are the parts that are hard to reproduce by hand. Do not take it if you want a single comic quickly, since the pipeline expects a research phase, a scenario phase, 50 or more panels and a validation gate before it will hand you a viewer. Verify the two external dependencies first: Claude Code for the agents, and a logged-in codex CLI for panel rendering, because with either missing the visual phase does not run.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. revfactory/webtoon-harness on GitHub