---
id: agent-comic-and-manga-studios
title: Agent comic studios exist; the reader loop doesn't
version: 2
published: '2026-10-27'
updated: '2026-10-27'
author: Hiina
produced-by: Claude deep-research run with citation checking
model: claude-opus-5-5
sources-through: '2026-10-25'
status: current
takeaway: Agent comic studios already exist; the missing piece is a calibrated, cross-family
  cold-reading VLM that critiques lettered pages, and a six-page pilot costing tens
  of dollars can test it.
topics:
- comics
- generative-media
- agents
- llm-evaluation
source-sha256: c191a01f6ee51ef2f29cd036b4f9d1282153051745b9e727cdafbd7b06240ba9
---

Index of everything on this site: https://ai.hiina.space/index.md

# Agent comic studios exist; the reader loop doesn't

- Author: Hiina (hiina@hiina.space)
- Produced by: Claude deep-research run with citation checking
- Version: 2 · published 2026-10-27 · updated 2026-10-27 · status: current
- Canonical: https://ai.hiina.space/reports/agent-comic-and-manga-studios.md (this version as one file: https://ai.hiina.space/reports/agent-comic-and-manga-studios/v2.md)
- Takeaway: Agent comic studios already exist; the missing piece is a calibrated, cross-family cold-reading VLM that critiques lettered pages, and a six-page pilot costing tens of dollars can test it.
- Topics: comics, [generative-media](https://ai.hiina.space/topics/generative-media.md), [agents](https://ai.hiina.space/topics/agents.md), [llm-evaluation](https://ai.hiina.space/topics/llm-evaluation.md)
- Model: claude-opus-5-5
- Sources through: 2026-10-25

The question behind this report: can a team of agents make a readable comic or manga by splitting the work the way a human studio does, with an author, a storyboarder, a panel artist, a letterer and an editor, instead of asking one image model for whole pages? And can a vision-language model (VLM) act as a cold reader that critiques the finished, lettered pages and sends notes back into the loop? The report covers published systems and hobby repos, the off-the-shelf parts for each artist role, how well VLMs actually read comics, a concrete pipeline, a costed pilot, and what carries over to agent-built Manim animations and explainer sites.

## 1. Summary

Yes, people have tested agent-made comics. The "studio" split in question is already how both researchers and hobbyists build them. The closest published system, MangaFlow (May 2026 preprint), uses a planner, a layout agent, a panel agent, a reference-conditioned renderer and a text agent. It beats direct whole-page generation by Gemini and FLUX.2 on panel-count accuracy (100% against 28-44%) and on an LLM-scored readability metric. At least two small Claude Code/Codex skill repos have independently built the same pattern: storyboard, image model told to draw no text, then lettering in code. So the architecture is not new. The open part is the step that matters most for this design. Nobody I found closes the loop with a cold-reading VLM that critiques the assembled, lettered pages and sends notes back to the storyboarder. Nobody has validated a comic-readability judge against human readers. And nobody has tested whether LLM-drawn SVG thumbnails help modern edit-capable image models. The evaluation side is harder than it looks. Published frontier VLMs (mostly 2025-era) score 0% on strict manga OCR, sort panels at 46% against humans' 83%, and the best judge-human correlations for storyboard consistency sit at 0.66-0.71. So a VLM reader is a usable but noisy instrument that has to be calibrated before it can be trusted. A 6-page pilot that runs the key ablations costs roughly $40-130 in API spend by my estimate, or about $25-30 if panels render locally on a single 24 GB consumer GPU. The real cost is human attention at three checkpoints plus a small group of human readers. The lessons carry straight over to agentic Manim and explainer sites, where the evidence says the planner artifact matters far more than the critic.

## 2. Whole-page models draw pages, not comics

The best controlled evidence for the motivating prior (that whole-page generation does not yield coherent comics) comes from MangaFlow's own baselines. It asked Gemini 2.5 Flash Image and FLUX.2 9B to produce story pages directly. They hit the requested panel count only **27.94% and 44.20%** of the time. MangaFlow hits 100%, which is true by construction because it uses explicit layouts. A GPT-4.1 judge scored readability **3.80 and 2.67** for direct generation against **4.87 and 4.71** for the agentic pipeline ([MangaFlow](https://arxiv.org/html/2605.28173v1)). Treat those readability numbers as self-reported. The paper calls the evaluator only "a multimodal LLM" in the text, reports no human validation of that score, and has no VLM reviewing final pages inside the generation loop. Humans judged only whether balloons covered faces. The main text does not say how many annotators did that, and I found no code link. Direct FLUX.2 had the highest style self-consistency, which the authors tie to weaker story alignment: the model kept drawing the same thing.

Single pages have gotten good. In a July 2026 informal test, one blogger gave 18 models the same comic-page prompt. GPT Image 2 was the clear winner on spelling, bubble-to-speaker matching and layout. Midjourney could not produce readable dialogue, and most models drifted on character appearance ([BudgetPixel](https://budgetpixel.com/blog/comicbook-prompt-comparisons-with-18-models)). A vendor write-up from August 2026 reports the same split. GPT Image 2 produced a correct six-panel grid with readable dialogue for about $0.05, but near-identical briefs for consecutive pages came back in full colour once and sepia the next. Fixing a typo means regenerating a flat image. The author's working method was a studio pipeline in all but name: generate per panel, anchor each panel to one approved reference rather than chaining, expect to redo about one panel in three, and letter in a layout tool ([Rangy](https://rangy.ai/blog/ai-comic-book)). The prior holds for multi-page coherence and for editability. On single-page competence it is now out of date. I found no controlled benchmark of 8+ page whole-comic generation, so a whole-page baseline is itself a small contribution.

The research systems split into three families. Story-visualization systems handle consistency but not lettered pages. CANVAS plans character, location and object states globally and picks among candidate frames with plan-derived visual questions ([CANVAS](https://arxiv.org/html/2604.13452)). Audit & Repair has a GPT-4 VLM audit characters and runs localized ControlNet repairs for at most two rounds ([Audit & Repair](https://arxiv.org/html/2506.18900v1)). Trained manga models put the planning inside the network. DiffSensei conditions an SDXL model on per-character boxes and dialogue-box positions, but deliberately renders no text: humans added the teaser's dialogue ([DiffSensei](https://arxiv.org/pdf/2412.07589)). DreamingComics fine-tuned Qwen2.5-VL-7B as a layout generator. It beat GPT-4 on page coverage (79.14 vs 29.25) and panel ordering (99.00 vs 66.67) on its own metrics ([DreamingComics](https://arxiv.org/pdf/2512.01686)). The third family is LLM planner plus programmatic lettering. TaleDiffusion uses GPT-4 for frame descriptions and box layouts, then CLIPSeg to find speaker heads and place bubbles on the opposite side with tails ([TaleDiffusion](https://arxiv.org/pdf/2509.04123)). One caution comes from StoryAgent. Its authors dropped their MLLM "observer" critic because "MLLMs and the aesthetic predictor were unreliable" ([StoryAgent](https://arxiv.org/pdf/2411.04925)). The systems where VLM checking worked asked narrow, plan-derived questions rather than "is this good".

On the open-source side, this exact idea is being reinvented in 2026 as Claude Code skills. agent-comic-kit interviews the user, builds character sheets and a `script.yaml` storyboard, and asks GPT Image for a whole page with a no-text instruction. It then splits the page at white gutters, has the agent check each panel against the storyboard and sheets, redraws bad panels singly, and places bubbles away from detected faces. It supports only stacked full-width rows, and its default backend is Windows-only ([agent-comic-kit](https://github.com/Saeyeon-developer/agent-comic-kit)). book-to-comic letters with deterministic Pillow code, runs "eighteen deterministic quality gates", records story review by an independent subagent, and exports PDF/CBZ/EPUB ([book-to-comic](https://github.com/onebluecloud/book-to-comic)). Both have a handful of stars and no published evaluation. The high-star projects, such as Toonflow at about 19K stars, target animated "comic drama" video rather than lettered pages ([Toonflow](https://github.com/HBAI-Ltd/Toonflow-app)). The best-known older open project, AI Comic Factory, was archived in October 2025 ([AI Comic Factory](https://github.com/jbilcke-hf/ai-comic-factory)).

## 3. Every artist-role building block exists off the shelf

**Character consistency** now has two workable tiers. The low-friction tier is training-free multi-reference edit models. Qwen-Image-Edit-2509 takes several input images, though the card says it performs best "with 1 to 3 input images". It natively supports depth, edge and keypoint conditions, and it is Apache-2.0 ([Qwen-Image-Edit-2509](https://huggingface.co/Qwen/Qwen-Image-Edit-2509/blob/main/README.md)). The 2511 successor claims better character consistency and less drift ([Qwen-Image-Edit-2511](https://huggingface.co/qwen/qwen-image-edit-2511)). FLUX.2 dev does multi-reference editing on an RTX 4090 via 4-bit quantization, under a non-commercial licence ([FLUX.2 dev](https://huggingface.co/black-forest-labs/FLUX.2-dev)). Gemini's Nano Banana family, GPT Image and Seedream cover the API side. The older, persistent tier is a per-character LoRA. One SDXL-class example trained on 23 images in **34 minutes on an RTX 4090** ([Civitai](https://civitai.com/articles/5545)). That is still worth doing for a protagonist who appears in hundreds of panels. The failure modes are well documented. Multiple character references fuse in DiffSensei, especially for similar designs, and in stacked IP-Adapters ([DiffSensei](https://arxiv.org/pdf/2412.07589), [lilting.ch](https://lilting.ch/en/articles/novelai-precise-reference-local-ipadapter)). BFL warns that Kontext edits accumulate artifacts after roughly six sequential turns ([Vercel/BFL](https://vercel.com/ai-gateway/models/flux-kontext-pro)). The working rules follow from that: re-anchor every panel to the canonical sheet instead of chaining from the previous panel, spend the reference budget on two characters plus one sketch, and do two-character panels as one-character passes plus regional inpainting. No source evaluates any of the modern edit models on black-and-white manga identity retention. That is untested, not known to fail.

**Composition control** is mature through ControlNets. InstantX's Qwen-Image ControlNet Union handles canny, soft edge, depth and pose in one Apache-2.0 model, with a recommended scale of 0.8-1.0 ([InstantX](https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union)). The question that matters most here has thin and dated evidence: does an LLM-authored sketch steer a modern model better than a text description? In Control-GPT (2023), GPT-4 drew TikZ sketches to condition a ControlNet. It improved spatial accuracy over SD (44% vs 19%), but position and size control stayed at **14%** ([Control-GPT](https://arxiv.org/pdf/2305.18583)). In Chat2SVG, Claude 3.5 Sonnet drew primitive SVG templates, which SDEdit plus a tile ControlNet then detailed. It won its user study, and the authors list "imprecise LLM layouts" as a limitation ([Chat2SVG](https://arxiv.org/html/2411.16602v1)). LLM-grounded Diffusion reported roughly doubled accuracy on spatial and numeracy prompts from LLM-emitted boxes ([LMD](https://arxiv.org/abs/2305.13655)). None of this tests GPT Image, Nano Banana or Qwen-Image-Edit with a rasterized SVG thumbnail as a reference image. My reading is that a crude SVG works best as a blocking spec: panel frame, figure placeholders, horizon line, reserved balloon space. Rasterize it to lineart, or better, to a pose or depth map, and feed it at a loose conditioning scale. Do not expect an LLM drawing to carry anatomy.

**Panel layout** does not need a learned model. The classic CityU work (Cao, Chan and Lau, SIGGRAPH Asia 2012) optimizes layouts from per-panel importance, regions of interest and panel relations. Those are exactly the fields an LLM storyboarder can emit, but I found no public code ([CityU](https://www.cs.cityu.edu.hk/~rynson/projects/manga/MangaDesigner.html)). Layout is strongly author-specific. A classifier given only panel borders identifies which of 104 Manga109 titles a page came from at 84.3%, while genre from borders averages 20.8% ([arXiv 2412.19141](https://arxiv.org/pdf/2412.19141)). So a "house style" is better carried as few-shot layout examples than as genre rules. The practical move is to have the storyboarder emit a recursive guillotine split tree or explicit polygons, then verify the result with existing extractors. Kumiko recovers panels with OpenCV contours and numbers them, with an RTL option ([Kumiko](https://github.com/njean42/kumiko)). Magi detects panels, text and characters, links dialogue to speakers, and orders everything in reading order. Its models are licensed for academic research only ([Magi](https://github.com/ragavsachdeva/magi)).

**Lettering** should be deterministic code, and every serious system agrees. Practitioner rules are easy to encode. Tails point at the speaker's mouth and never cross each other or a face. Balloons don't cover key art. Reading order runs top-left downward for Western comics and top-right leftward for manga. And text is placed before final art so the space is reserved ([Clip Studio Tips](https://tips.clip-studio.com/en-us/articles/4811)). That last rule matters for the pipeline: balloon placement belongs in the thumbnail stage as a constraint, not as an afterthought. Fonts are the real licensing trap. Blambot's indie-comics licence allows print and flattened web use even for projects that make money ([Blambot](https://blambot.com/pages/licenses)). Anime Ace is free only for independent comic creation and non-profit use ([1001fonts](https://www.1001fonts.com/anime-ace-font.html)).

**Agent-drivable tooling** comes out clearly ranked. SVG generated by code and rendered on the command line is the lowest-friction path. resvg is a dependency-free Rust renderer, but its README flags font loading as a rough edge ([resvg](https://github.com/linebender/resvg)). For text shaping, rendering through Inkscape or headless Chromium is the safer bet; I haven't verified which handles comic fonts best. Inkscape's CLI chains `--actions` and can read from stdin and write to stdout. Many actions still assume a GUI, though, and the wiki is unclear about headless use, so plan on `--batch-process` or xvfb ([Inkscape wiki](https://wiki.inkscape.org/wiki/Using_the_Command_Line)). Krita's Python API is rich: a vector layer accepts `addShapesFromSvg` and returns `toSvg` ([Krita VectorLayer](https://lxr.kde.org/source/graphics/krita/libs/libkis/VectorLayer.h)). But `kritarunner` has a confirmed, unfixed bug where `--script` expects a module name and ignores PYTHONPATH ([KDE 391508](https://bugs.kde.org/show_bug.cgi?id=391508)). Headless Krita is undocumented. Use Krita as a human handoff format at the end, not as a tool inside the loop. ComfyUI exposes a clean queue API (`POST /prompt`, `GET /history/{id}`, `POST /upload/image`, WebSocket progress events), so an agent can drive a saved workflow as a function call ([ComfyUI docs](https://docs.comfy.org/development/comfyui-server/comms_routes)). Manga translation tools such as BallonsTranslator (GPL-3.0, headless mode) and Koharu (MIT/Apache, Rust, PSD export) are most useful as checkers and cleaners: they find stray glyphs the image model drew anyway and inpaint them out ([BallonsTranslator](https://github.com/dmMaze/BallonsTranslator), [Koharu](https://github.com/mayocream/koharu)).

**Screentone** is the weakest link for true B&W manga. Sketch2Manga ([arXiv 2403.08266](https://arxiv.org/abs/2403.08266v1)) exists only as a research model. For a pilot, generate line art with flat grays and apply a deterministic halftone pass at compositing time. That is more consistent across panels than prompting each panel for tone.

## 4. VLM readers are weak on manga, and judges top out near 0.7

The benchmarks exist, but they all test reading of human-made comics. On MangaVQA, Gemini 2.5 Flash scored 7.26/10, GPT-4o 6.00 and Claude Sonnet 4.5 5.84. On the strict MangaOCR detection-plus-recognition metric, all three scored **0.0** Hmean, against 71.5 for a fine-tuned Qwen2.5-VL-7B ([MangaVQA](https://arxiv.org/html/2505.20298v2)). On ComicVQA, the best proprietary model reached **62.6% on missing-panel prediction and 46.4% on panel sorting, against humans above 83%**. The authors found models lean on coarse temporal cues ([ComicVQA](https://aclanthology.org/2026.findings-acl.1268/)). CHROMIC reports that even the strongest models struggle with chronological reasoning and invent fine visual detail ([CHROMIC](https://preview.aclanthology.org/credits/2026.eacl-long.205)). On AI4VA-FG, Gemini-2.5-Pro led six of seven tasks, yet most models sat near chance on depth comparison, panel reordering and character counting ([Zooming into Comics](https://arxiv.org/html/2511.06490)). PixelHumor found models default to left-to-right, top-to-bottom order and miscount panels ([PixelHumor](https://arxiv.org/pdf/2509.12248)). Splitting panels into separate images hurt every model on YesBut ([YesBut](https://web3.arxiv.org/pdf/2503.23137)). Speaker attribution is fragile too: on CoMix, a nearest-character heuristic beat Magi on three of four subsets ([CoMix](https://arxiv.org/html/2407.03550v1)). Every one of these numbers predates the current frontier. I found no published comic-benchmark results for Claude 5-era, GPT-6-era or Gemini 3 models. Treat them as lower bounds, and run a control (below) rather than assuming.

Zoom helps, but the headline numbers are an upper bound. The large gains in "Zooming into Comics" came from manual, ground-truth crops to the relevant panels. GPT-4o's action recognition rose from 31.97 to 55.10, Gemini-2.5-Flash's depth comparison from 56.31 to 78.64, and Qwen2.5-VL-7B's panel understanding from 41.33 to 58.67. The authors' trained zoom model, which predicts its own boxes, gained only **10 points** on panel understanding (to 51.33). It did not transfer to MangaVQA and did not fix counting ([Zooming into Comics](https://arxiv.org/html/2511.06490)). This shapes the design. The reader does not need to find the right zoom, because the pipeline owns the page geometry. The compositor knows every panel polygon and balloon box, so it can hand the reader exact crops. That puts the pipeline near the oracle end of the gap for free. The pipeline also knows every word of lettering, because it rendered it. So check legibility deterministically, with OCR per balloon crop diffed against the script, and keep the VLM's job to narrative and staging, where the OCR weakness matters less.

Judge validity is moderate where it has been measured, and unmeasured where this design needs it. CANVAS validated storyboard consistency judges against human ratings. The independent judges reached Pearson **0.66-0.71** (Gemini-2.5-Flash 0.67-0.71, GPT-5 0.66-0.70). The low end, 0.61-0.65, came from Gemini-3-Pro-Image, which is also CANVAS's generator backbone. That is a same-family judge doing worse, and it matches the observation that motivated this report: a model from a different family critiques a page better than the model family that made it ([CANVAS](https://arxiv.org/html/2604.13452)). ViStoryBench's automatic character-similarity metric reached Pearson 0.80 with human ratings, style 0.60, and aesthetics only 0.54 (Kendall 0.26). The benchmark explicitly does not support multi-panel comic layouts ([ViStoryBench](https://arxiv.org/html/2505.24862v4)). PPTAgent's GPT-4o slide judge hit 0.71 Pearson with kappa 0.59 ([PPTAgent](https://arxiv.org/html/2501.03936)). Crafter's VLM judge for scientific figures agreed with the human majority on 72% of pairs ([Crafter listing](https://hyper.ai/fr/papers/2605.30611)). A manga translation-judging paper found that adding the page image raised error detection from 57.9% to about 81%. Its six human verifiers agreed at only Fleiss' kappa 0.266 ([arXiv 2610.17908](https://arxiv.org/html/2610.17908)). The general literature supports separating the two roles. LLM evaluators recognize and favour their own outputs ([Panickssery et al.](https://arxiv.org/abs/2404.13076)), and models struggle to self-correct without an external signal ([Huang et al.](https://arxiv.org/abs/2310.01798)). Both findings are on text, so cross-family VLM critique of images is a sensible precaution, not a measured result.

Comics theory works as a rubric, as long as its labels are treated as soft. McCloud's six transition types have been used to annotate 2,228 Manga109 panel pairs. Action-to-action made up 33.2%, subject-to-subject 20.4%, non-sequitur 15.1%, moment-to-moment 12.6%, scene-to-scene 10.1% and aspect-to-aspect 8.3%. Three student annotators agreed at Cohen's kappa only **0.524-0.774** ([arXiv 2312.08720](https://arxiv.org/pdf/2312.08720)). That kappa is roughly the ceiling for any VLM-vs-human agreement on transition labels. So use transitions in two ways. The storyboarder declares an intended transition per gutter. The reader infers one, and a mismatch flags the gutter for attention without proving it wrong. The transition distribution also works as a stylistic sanity check against manga norms. Cohn's Visual Language Research Corpus offers open annotations of about 45K panels, including character, space and time changes between panels, which makes a more empirical scheme than McCloud's ([VLRC](https://link.springer.com/article/10.1007/s10579-023-09673-0)). One generator has encoded Cohn's arc (Establisher, Initial, Peak, Release) alongside McCloud transitions, with qualitative results only ([Chen & Jhala](https://arxiv.org/html/2401.02863v1)). I found no paper that puts McCloud or Cohn into an LLM or VLM prompt as a rubric. In practice, give the author and storyboarder a distilled summary of *Understanding Comics* in the project's own words (closure across the gutter, transition choice, panel time, word-picture balance), plus the Manga109 transition statistics. Give the reader only the rubric, never the script.

## 5. A studio pipeline with a blind, cross-family reader

The design below combines what the evidence supports. LLMs own the plan and the critique, image models own pixels only, and deterministic code owns every bit of geometry and text. The central artifact is a page spec that every later stage keys off by stable IDs. That is how a critique like "balloon 3 covers Aki's face in panel 2.4" becomes an edit rather than a vague note.

| Role | Engine | Consumes | Produces |
|---|---|---|---|
| Author | Claude (Opus) | Premise, comics-theory summary | `script.md`: beats, dialogue, character bible, 8-12 comprehension questions with answers |
| Character designer | Image model, Claude selects | Character bible | `refs/{char}/`: turnaround, 4-6 expressions, outfit notes; frozen once a human approves |
| Storyboarder | Claude (Opus) | Script, refs, few-shot layouts | `page_NN.json` (panel tree or polygons, shot scale, camera angle, characters with boxes, intended transition, balloons with speaker, order and reserved region) and `page_NN.svg` thumbnails |
| Panel artist | Edit model (Qwen-Image-Edit locally, or Gemini/GPT image) via ComfyUI or API | Panel text spec, 1-3 ref crops, rasterized SVG sketch or pose/depth map | 3 candidates per panel, no text |
| Panel QA | Cross-family VLM plus DINO/DreamSim similarity | Candidate, its spec | Round-trip caption into the spec schema, field-by-field diff, identity score, pick or redraw ticket |
| Letterer/compositor | Deterministic Python | Spec, chosen panels | `page_NN.final.svg` and PNG: panels clipped to polygons, balloons fitted, tails drawn, halftone pass; optional `.kra` export via `addShapesFromSvg` |
| Layout checker | Deterministic plus Kumiko/Magi | Rendered page, spec | Pass/fail on panel recovery, reading order, balloon-face overlap, text overflow, OCR diff |
| Cold reader | Different model family from the author, blind to spec | Full page plus exact panel and balloon crops | Retelling, quiz answers, inferred transitions, confusions keyed to panel IDs |
| Editor | Claude | Checker and reader reports | Revision tickets routed to the author, storyboarder, artist or letterer |

Two patterns from the adjacent literature are worth borrowing directly. AnimeAgent's reviewer has an MLLM re-describe the generated output in the same schema as the spec, then compares field by field. That turns subjective critique into a structured diff ([AnimeAgent](https://arxiv.org/html/2602.20664v1)). Code2Video's critic uses a 6x6 grid of named anchors plus an occupancy table linking each element to its code. It exists because text-only critique can name a misplaced element but gives no direction or distance for the fix ([Code2Video](https://arxiv.org/html/2510.01174)). For comics, name the balloon anchor slots in each panel and keep a bounding-box table keyed to SVG IDs. Then a critic can say "move balloon b3 to slot TL" and the compositor can execute it. Paper2Video found that LLMs respond poorly to small numeric tweaks. It renders discrete variants and has a VLM choose among them ([Paper2Video](https://arxiv.org/html/2510.05096)). Do the same for balloon layouts and panel crops.

Run the review loop at three levels, and cap each one. At the panel level, run QA and keep the best of three, with at most one redraw round per panel. At the page level, deterministic checks must pass before any VLM sees the page. A VLM is the wrong tool for "do these shapes overlap": 2024 VLMs averaged 58% on trivially simple line-crossing and overlap tasks ([BlindTest](https://arxiv.org/abs/2407.06581)), and a deterministic scene-graph checker beat a VLM critic in 65% of human comparisons for Manim ([SGA](https://www.alphaxiv.org/abs/2607.18116)). At the story level, the cold reader runs at most two revision rounds, and the best version so far is kept because refinement can regress ([VFLM](https://arxiv.org/pdf/2603.22187)). Put human checkpoints at three points: approving the script and character sheets, approving the thumbnails, and approving final pages. Thumbnail approval is the cheapest place to catch a storytelling problem, and the planner is where the evidence says the value sits.

## 6. A six-page pilot costs tens of dollars

Pick a 6-page silent-heavy short with two or three characters and about 30 panels, in B&W line art with flat grays. Keep dialogue sparse, so failures show up in staging and transitions rather than being papered over by captions. The recommended stack has four layers. Claude Code as author, storyboarder and editor runs on existing agent compute, so orchestration has no marginal cost. Panels render locally on a single 24 GB consumer GPU through ComfyUI, using Qwen-Image-Edit-2511 (Apache-2.0) plus the InstantX ControlNet Union for pose and depth. A 20B model will need an FP8 or GGUF quant to fit in 24 GB, which I haven't verified, and this research found no timing for it on that class of card, so measure on day one. For a sense of scale, FLUX.2 dev Q8 takes 15-17 s per 1024px image on an RTX 4090 ([RunAIHome](https://runaihome.com/blog/z-image-turbo-16gb-vram-home-lab-image-gen-2026/)). Add one API image model as a second arm: Gemini 3.1 Flash Image or GPT Image 2. Compositing is Python generating SVG, rendered by Inkscape CLI or Chromium, with resvg for fast previews and a Blambot indie-licensed font. Kumiko and Magi run as layout and reading-order checkers. The cold reader is Gemini or GPT, with exact crops supplied by the compositor.

For the human readers, recruit 6-10 people. Each ranks the 4 variants of the story and answers the author's comprehension questions, at about 20 minutes per reader. Compute Spearman between the judge's ranking and the human ranking. CANVAS's 0.66-0.71 is a reasonable bar.

Calibrate the reader before trusting it, with a shuffled-panel reorder probe. Shuffle each page's panels, ask the reader to restore the order, and score Kendall tau. Run the same probe on a human-made comic of similar length. Public-domain Golden Age comics from the Digital Comic Museum, the source CoMix draws on, are a reasonable choice ([CoMix](https://arxiv.org/html/2407.03550v1)). Without that control, a low score can't separate "the comic is unclear" from "the reader is weak", since panel sorting is exactly where models trail humans by nearly 40 points ([ComicVQA](https://aclanthology.org/2026.findings-acl.1268/)). Report the probe relative to the control, not as an absolute number. Pair it with a TeachQuiz-style functional test, borrowed from Code2Video's metric in which an "unlearned" model answers questions after watching ([Code2Video PMLR](https://proceedings.mlr.press/v306/chen26bx.html)). The reader retells the story and answers the author's questions without seeing the script.

| Ablation | Arms | What it shows |
|---|---|---|
| Whole page vs studio | GPT Image 2 or Nano Banana Pro given script plus sheets, one page per call, vs full pipeline | Whether the studio is worth it at today's model quality; extends MangaFlow's baseline to 2026 models and multiple pages |
| Sketch conditioning | Text-only panel spec vs spec plus rasterized SVG thumbnail vs spec plus pose/depth map from the SVG | The untested core claim about LLM sketches; measure first-try acceptance rate and spec-diff errors |
| Critic family | Claude reads Claude's pages vs Gemini/GPT reads them, same rubric, both validated against the human ranking | Whether the cross-family observation holds for visual critique; no published study covers this |
| Critic on/off | 0 vs 2 reader-driven revision rounds | Whether the loop adds value beyond the planner; Code2Video saw about 6.5-21 points from its critic against about 41 from its planner |

Rough budget, my own arithmetic, at prices as of late October 2026. Re-check the live pricing pages before spending. Character sheets come to about 18 images. Each studio arm is 30 panels x 3 candidates plus about 20% redraws, so about 108 images, and the two sketch arms double that. The whole-page baseline adds about 24 page generations and the critic arms about 36 redraws, so about 300 images in total. At Google's listed $0.067 per 1K image for Gemini 3.1 Flash Image ([Gemini pricing](https://ai.google.dev/gemini-api/docs/pricing)), that is about $20. Segmind's third-party measurement of GPT Image 2 is $0.066 for medium and $0.264 for high quality at 1024px, which gives about $20 or $79 ([Segmind](https://blog.segmind.com/ai-image-gen-pricing-compared-nano-banana-2-vs-seedream-5-0-vs-gpt-image-2-2026/)). Segmind also measured Nano Banana 2 above Google's own figure, so test-call before budgeting. VLM reading is cheap. Claude bills images at about (w/28)x(h/28) tokens, capped at 4,784 for a high-res page ([Claude vision](https://platform.claude.com/docs/en/build-with-claude/vision)). A page read with five crops comes to about 13K input tokens. At roughly $2/$10 per million, Sonnet 5.5's listed rate ([Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing)), and assuming a similar tier for the cross-family reader, that is about 5 cents per read. The 4 arms x 6 pages x 3 rounds x 2 critic families x 3 seeds come to about 430 reads, or about $20, plus a few dollars of panel QA.

| Configuration | Images | VLM reads | Estimated total |
|---|---|---|---|
| Panels local on a 24 GB consumer GPU, API only for the reader and the whole-page baseline | ~$2-6 | ~$20-25 | **~$25-30** |
| Mid-priced API images (Gemini Flash Image 1K, GPT Image 2 medium) | ~$20 | ~$20-25 | **~$40-50** |
| GPT Image 2 high for all panels | ~$80 | ~$20-25 | **~$100-130** |

Orchestration inside Claude Code on existing agent compute adds nothing at the margin. Running the agents through the API instead adds a few dollars: PosterAgent spent about 101K tokens per poster ([PosterAgent](https://arxiv.org/html/2505.21497)). Rent a GPU only for FLUX.2 dev at full precision or for parallel arms. Runpod lists an RTX 4090 at $0.89/h and an H100 SXM at $3.99/h ([Runpod](https://www.runpod.io/pricing)). The scarcest resource is human attention: the three checkpoints plus the reader study.

## 7. Lessons transfer to Manim and explainers almost one-to-one

The comic studio shares one structure with agent-built Manim animations and explainer sites: a programmatic geometry layer (panel frames and balloons; Manim scenes; DOM layout) wrapped around a content layer that is hard to verify. The adjacent evidence points in one direction. Code2Video lost about 41 points when the planner was removed, against **6.5 (aesthetics) to 21 (quiz) points** for the critic ([Code2Video](https://arxiv.org/html/2510.01174)). OmniManim argues that layout defects appear only after rendering. It gets its biggest gains from a vision agent that predicts bounding boxes into shared scene state, with CV diagnostics routing each fix to the right agent: removing that agent dropped the overlap score from 0.763 to 0.491 ([OmniManim](https://arxiv.org/pdf/2605.15585)). PhysicsSolutionAgent's single VLM screenshot critique gained little, and the VLM sometimes misread frames ([PSA](https://arxiv.org/pdf/2601.13453)). PosterAgent's loop got worse with a weaker VLM ([PosterAgent](https://arxiv.org/html/2505.21497)). Four things carry across directly. Put effort into the spec artifact. Key every element to a stable ID with anchors so critique is actionable. Run deterministic overlap and overflow checks before any VLM. Use a comprehension quiz from a blind reader as the headline metric.

Comics are the better first testbed for a specific reason: a still page is fully in distribution for a VLM, while video critique has to infer motion from sampled frames, a limitation PSA calls out. Whatever is learned about judge calibration, cross-family critique and sketch-as-spec on comics is cheap to measure. It then carries to explainer sites almost unchanged, since those are also static renders plus DOM geometry, and to Manim, with the motion caveat.

## 8. Which gaps are real

Several things look like gaps but are not. The role split itself is done: MangaFlow and the hobby repos already have it. Programmatic lettering placed off detected faces is done in TaleDiffusion, agent-comic-kit and book-to-comic. Reference-anchored per-panel generation is standard practice. And single-page text rendering is largely solved by GPT Image 2.

Six gaps are real, meaning I searched for them and they turned up absent. First, there is no human-validated readability or comprehension benchmark for generated comics. ViStoryBench excludes multi-panel layouts, MangaFlow's readability score is unvalidated, and CANVAS validates judges only on storyboard consistency. Second, no system closes the loop from a cold-reading VLM on assembled, lettered pages back to the storyboarder or author. MangaFlow confirms it has no final-page VLM critic. Third, there is no evidence on whether LLM-drawn SVG thumbnails improve modern edit-capable image models over text, so the best data is Control-GPT and Chat2SVG from the SD era. Fourth, there is no controlled multi-page whole-comic benchmark of 2026 image models, and no same-family vs cross-family VLM critique comparison on rendered visual output. Fifth, there are no published comic-reading numbers for current frontier models, and no LLM or VLM work that uses McCloud or Cohn as a rubric. Sixth, there is no agent driving Krita or Inkscape as a layered editor. That one is a gap mostly because nobody needs it: SVG generated by code does the job better. Search coverage was moderate rather than exhaustive. Webtoon and yonkoma generation and Chinese-venue work were not searched, and the field moves monthly, so these gap claims have a short shelf life.

## 9. Conclusion

The idea is less about building a comic generator than about measurement. The generator is mostly assembled from parts that already exist. What does not exist is a calibrated reader: one that runs against a human-made control, comes from a different model family than the author, gets exact crops, and is checked against a human ranking. Once it exists, it doubles as the evaluation harness for animation and explainer pipelines. The pilot's most informative output is not the comic. It is two numbers: the reader's Spearman correlation with humans, and the first-try acceptance gap between SVG-conditioned and text-only panels. If the judge clears about 0.7 and sketches cut redraws meaningfully, the result is a studio that can iterate unattended between human checkpoints. If not, the pilot has still produced the first validated study of comic readability for generated comics, a result that is publishable on its own.

One caution about where effort should go. Every adjacent result says the plan beats the critic. The highest-leverage hours go into the page-spec schema and the storyboarder's few-shot layouts, not into longer critique loops.

## 10. Sources

- [MangaFlow (arXiv 2605.28173)](https://arxiv.org/html/2605.28173v1)
- [BudgetPixel, comic-page prompt comparison across 18 models](https://budgetpixel.com/blog/comicbook-prompt-comparisons-with-18-models)
- [Rangy, AI comic book write-up](https://rangy.ai/blog/ai-comic-book)
- [CANVAS (arXiv 2604.13452)](https://arxiv.org/html/2604.13452)
- [Audit & Repair (arXiv 2506.18900)](https://arxiv.org/html/2506.18900v1)
- [DiffSensei (arXiv 2412.07589)](https://arxiv.org/pdf/2412.07589)
- [DreamingComics (arXiv 2512.01686)](https://arxiv.org/pdf/2512.01686)
- [TaleDiffusion (arXiv 2509.04123)](https://arxiv.org/pdf/2509.04123)
- [StoryAgent (arXiv 2411.04925)](https://arxiv.org/pdf/2411.04925)
- [agent-comic-kit](https://github.com/Saeyeon-developer/agent-comic-kit)
- [book-to-comic](https://github.com/onebluecloud/book-to-comic)
- [Toonflow](https://github.com/HBAI-Ltd/Toonflow-app)
- [AI Comic Factory](https://github.com/jbilcke-hf/ai-comic-factory)
- [Qwen-Image-Edit-2509 model card](https://huggingface.co/Qwen/Qwen-Image-Edit-2509/blob/main/README.md)
- [Qwen-Image-Edit-2511 model card](https://huggingface.co/qwen/qwen-image-edit-2511)
- [FLUX.2 dev model card](https://huggingface.co/black-forest-labs/FLUX.2-dev)
- [Civitai, character LoRA training article](https://civitai.com/articles/5545)
- [lilting.ch, NovelAI precise reference vs local IP-Adapter](https://lilting.ch/en/articles/novelai-precise-reference-local-ipadapter)
- [Vercel AI Gateway, FLUX Kontext Pro (BFL guidance)](https://vercel.com/ai-gateway/models/flux-kontext-pro)
- [InstantX Qwen-Image ControlNet Union](https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union)
- [Control-GPT (arXiv 2305.18583)](https://arxiv.org/pdf/2305.18583)
- [Chat2SVG (arXiv 2411.16602)](https://arxiv.org/html/2411.16602v1)
- [LLM-grounded Diffusion (arXiv 2305.13655)](https://arxiv.org/abs/2305.13655)
- [CityU, automatic manga layout (Cao, Chan and Lau)](https://www.cs.cityu.edu.hk/~rynson/projects/manga/MangaDesigner.html)
- [Manga109 panel-border author identification (arXiv 2412.19141)](https://arxiv.org/pdf/2412.19141)
- [Kumiko](https://github.com/njean42/kumiko)
- [Magi](https://github.com/ragavsachdeva/magi)
- [Clip Studio Tips, lettering article](https://tips.clip-studio.com/en-us/articles/4811)
- [Blambot font licences](https://blambot.com/pages/licenses)
- [1001fonts, Anime Ace](https://www.1001fonts.com/anime-ace-font.html)
- [resvg](https://github.com/linebender/resvg)
- [Inkscape wiki, Using the Command Line](https://wiki.inkscape.org/wiki/Using_the_Command_Line)
- [Krita VectorLayer API source](https://lxr.kde.org/source/graphics/krita/libs/libkis/VectorLayer.h)
- [KDE bug 391508, kritarunner script loading](https://bugs.kde.org/show_bug.cgi?id=391508)
- [ComfyUI server routes docs](https://docs.comfy.org/development/comfyui-server/comms_routes)
- [BallonsTranslator](https://github.com/dmMaze/BallonsTranslator)
- [Koharu](https://github.com/mayocream/koharu)
- [Sketch2Manga (arXiv 2403.08266)](https://arxiv.org/abs/2403.08266v1)
- [MangaVQA (arXiv 2505.20298)](https://arxiv.org/html/2505.20298v2)
- [ComicVQA, Findings of ACL 2026](https://aclanthology.org/2026.findings-acl.1268/)
- [CHROMIC, EACL 2026](https://preview.aclanthology.org/credits/2026.eacl-long.205)
- [Zooming into Comics (arXiv 2511.06490)](https://arxiv.org/html/2511.06490)
- [PixelHumor (arXiv 2509.12248)](https://arxiv.org/pdf/2509.12248)
- [YesBut (arXiv 2503.23137)](https://web3.arxiv.org/pdf/2503.23137)
- [CoMix (arXiv 2407.03550)](https://arxiv.org/html/2407.03550v1)
- [ViStoryBench (arXiv 2505.24862)](https://arxiv.org/html/2505.24862v4)
- [PPTAgent (arXiv 2501.03936)](https://arxiv.org/html/2501.03936)
- [Crafter, scientific figure judge (listing)](https://hyper.ai/fr/papers/2605.30611)
- [Manga translation judging with page images (arXiv 2610.17908)](https://arxiv.org/html/2610.17908)
- [Panickssery et al., LLM evaluators recognize and favor their own generations](https://arxiv.org/abs/2404.13076)
- [Huang et al., LLMs cannot self-correct reasoning yet](https://arxiv.org/abs/2310.01798)
- [McCloud transitions on Manga109 (arXiv 2312.08720)](https://arxiv.org/pdf/2312.08720)
- [Cohn, Visual Language Research Corpus](https://link.springer.com/article/10.1007/s10579-023-09673-0)
- [Chen & Jhala, comic generation with Cohn's narrative arc](https://arxiv.org/html/2401.02863v1)
- [AnimeAgent (arXiv 2602.20664)](https://arxiv.org/html/2602.20664v1)
- [Code2Video (arXiv 2510.01174)](https://arxiv.org/html/2510.01174)
- [Paper2Video (arXiv 2510.05096)](https://arxiv.org/html/2510.05096)
- [BlindTest, VLMs are blind (arXiv 2407.06581)](https://arxiv.org/abs/2407.06581)
- [SGA, scene-graph checking for Manim](https://www.alphaxiv.org/abs/2607.18116)
- [VFLM (arXiv 2603.22187)](https://arxiv.org/pdf/2603.22187)
- [RunAIHome, home-lab image generation timings](https://runaihome.com/blog/z-image-turbo-16gb-vram-home-lab-image-gen-2026/)
- [Code2Video, PMLR](https://proceedings.mlr.press/v306/chen26bx.html)
- [Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing)
- [Segmind, image generation pricing compared](https://blog.segmind.com/ai-image-gen-pricing-compared-nano-banana-2-vs-seedream-5-0-vs-gpt-image-2-2026/)
- [Claude vision docs](https://platform.claude.com/docs/en/build-with-claude/vision)
- [Claude pricing](https://platform.claude.com/docs/en/about-claude/pricing)
- [PosterAgent (arXiv 2505.21497)](https://arxiv.org/html/2505.21497)
- [Runpod pricing](https://www.runpod.io/pricing)
- [OmniManim (arXiv 2605.15585)](https://arxiv.org/pdf/2605.15585)
- [PhysicsSolutionAgent (arXiv 2601.13453)](https://arxiv.org/pdf/2601.13453)

---

Text licensed CC BY 4.0 (attribution: Hiina, ai.hiina.space). Source: https://github.com/hiinaspace/ai-hiina-space