ResearchStudio-Reel: Automate the Last Mile of Research from Paper to Poster, Video, and Blog

Lingao Xiao, Yalun Dai, Yangyu Huang, Qihao Zhao, Wenshan Wu, Hugo He, Ruishuo Chen, Jin Jiang, Qianli Ma, Jiahuan Zhang, Xin Zhang, Ying Xin, Yang Ou, Yan Xia, Scarlett Li, Longbo Huang, Zhipeng Zhang, Yang He, Yap Kim Hui, Yan Lu

ResearchStudio-Reel automates research dissemination by composing five skills into a unified, editable, and cross-referenced artifact bundle.

How can we automate the "last mile" of research dissemination by transforming a single PDF into a synchronized, multi-format suite of poster, video, and blog assets?

Research dissemination is a manual "last mile" where authors must independently produce a poster, a talk video, and a blog post, often leading to inconsistent facts and non-editable, one-way file formats. ResearchStudio-Reel treats this as an architectural composition: a shared extraction layer (Paper2Assets) feeds three generators (Paper2Poster, Paper2Video, Paper2Blog) that produce native, editable files, all bound by a convergence layer (Paper2Reel) that links the artifacts into one interactive viewer. On the Paper2Poster benchmark, these generated posters outperform prior automated systems and single-shot frontier LLMs, winning the overall score on 84–93% of papers while being the only pipeline to ship all three artifacts in their native authoring tools.

Paper Primer

The system hinges on a "measured-fill loop" with hard pass/fail gates: instead of relying on soft aesthetic scores that plateau, each generator iterates through categorical quality verdicts (e.g., "Empty," "Sparse," "Full") and exits only when the artifact meets strict, deterministic render requirements.

The core move is the shared asset bundle: Paper2Assets extracts the paper once into a structured manifest of figures, claims, and section IDs, ensuring that a figure referenced in the blog is identical to the one on the poster and the one highlighted in the video.

ResearchStudio-Reel posters surpass author-created ground truth on aesthetics.

Evaluated by two held-out VLM judges on the Paper2Poster benchmark.

The system provides native, editable deliverables for all three artifacts.

Posters ship as PowerPoint files, videos as editable slide decks, and blogs as Word documents. 100% of artifacts remain editable, avoiding the "one-way render" trap of prior systems.

Why is this approach better than using a single, monolithic model to generate all three artifacts?

Monolithic systems suffer from "isolated extraction," where each artifact re-derives figures and metadata from scratch, leading to factual inconsistencies. By using a shared extraction layer, ResearchStudio-Reel ensures cross-artifact consistency and allows each generator to focus on its specific domain (e.g., layout for posters, narration for video).

What happens if the system fails to generate a perfect poster on the first try?

The system uses a deterministic fill loop that logs which move was applied to which section. If a poster fails to converge, the process is diagnosable rather than a "black box" failure, and the system can trip a circuit breaker to ship the best-measured state rather than grinding indefinitely.

The Last Mile of Research

We expose the fragmented, manual last‑mile of research dissemination and propose a unified skill composition.

Research dissemination—turning a paper into a poster, a talk video, and a blog post—remains a manual “last mile” that authors must execute after the camera‑ready deadline.

Three recurring gaps make this stage brittle: (G1) isolated extraction forces each artifact to re‑parse the paper, breaking factual consistency; (G2) one‑way renders produce PDFs, MP4s, or HTML that cannot be reopened in PowerPoint or Word; (G3) soft quality gates rely on VLM‑derived preference scores that accept layouts with empty, load‑bearing sections.

It treats the last‑mile pipeline as a composition of five reusable skills that share a single extracted “asset bundle” and enforce hard pass/fail render gates.

**Figure 1.** Three editor-ready artifacts from one paper. From a single accepted PDF, ResearchStudio-Reel produces a print-ready conference poster, a narration-aligned talk video, and a bilingual blog spread, shown here across example papers. Every deliverable stays editable in its native tool (PowerPoint for the poster and the video deck, Word for the blog), and the three are cross-linked into one navigable surface. A single shared paper2assets extraction (Figure 2) keeps the artifacts factually consistent rather than re-deriving the paper three times.

The inefficiency of manual, isolated artifact creation is the core problem this work eliminates.

Prior Work in Dissemination

Survey of prior single‑artifact dissemination tools and agent frameworks.

Related work falls into four threads, each targeting a single dissemination artifact: poster, video/slide, blog/summary, and the underlying agent frameworks that power them.

Paper‑to‑poster systems generate static visual summaries from a manuscript, typically outputting a PDF or PNG that cannot be edited further.

Early upstream system that maps a research paper to a poster layout.

Uses a “Poster Tree” intermediate representation to guide layout decisions.

Splits poster creation into three agents handling visual content, textual content, and assembly.

Applies aesthetic‑rule prompts to steer visual style during poster synthesis.

Combines retrieval of existing layouts with an agent‑less layout‑violation detector.

Reformulates poster creation as an editing‑agent problem.

Retrieves nearest‑neighbor layouts from the SciPostLayout dataset.

Generates HTML‑based typographic posters, enabling web rendering.

Dataset of annotated poster layouts used for training and evaluation.

Video and slide pipelines chain agents for script, narration, visuals, and final MP4, but the resulting media cannot be edited after rendering.

Early system that generates presentation slides from a paper.

Transforms document content into slide format via a multi‑agent planner.

Converts structured documents directly into PowerPoint decks.

Generates slides and then assembles them into a video.

Operates at the boundary between slide creation and video generation.

Agent that refines PowerPoint decks using learned style cues.

Plans video narration, visuals, and timing from a paper.

End‑to‑end system that produces a narrated video from a manuscript.

Generates lecture‑style videos with slide‑aligned narration.

Long‑form summarization systems compress a paper into text, but they do not output author‑editable documents or handle multilingual registers.

Summarizes scientific articles into concise abstracts.

Produces structured paragraph‑level summaries for scientific papers.

Generates long‑form summaries using a hierarchical transformer.

Applies direct preference optimization to long‑document summarization.

Adapts summaries to specific audience registers (e.g., lay‑person).

Generates lay‑person explanations of scientific content.

General agentic frameworks define reasoning loops and tool use, while skill libraries provide reusable contracts for specific tasks.

Combines reasoning and acting in a single LLM loop.

Framework for orchestrating multiple LLM agents with shared state.

Meta‑level system that generates and runs task‑specific agents.

API that lets LLMs invoke external functions as tools.

Similar to OpenAI’s offering, enabling LLMs to call external utilities.

Collections of reusable skills for web navigation, data extraction, and more.

Skill set focused on action‑condition‑task primitives.

Skill runtime for code generation and execution within Claude agents.

OpenAI model specialized for code synthesis, used as a skill backend.

Across all four threads, prior systems suffer from three gaps: duplicated extraction (G1), one‑way renders (G2), and soft VLM‑based quality gates (G3). ResearchStudio‑Reel uniquely combines a shared extractor, editable multi‑artifact outputs, and hard categorical render gates, delivering a unified interactive presentation surface.

The Shared Extraction Layer

Paper2Assets extracts a single reusable bundle from a PDF, eliminating duplicated extraction for downstream generators.

Current dissemination pipelines re‑extract figures, captions, and metadata for each output, which wastes compute and creates inconsistencies. This duplicated‑extraction problem (G1) forces three separate fix‑ups whenever a single source error occurs.

Paper2Assets works like a master copy of a manuscript that downstream editors pull from, guaranteeing every generated artifact stays in lockstep.

Step 1 extracts raw text → “Introduction … Conclusion”.

Step 2 extracts the caption “Figure 1: Model architecture” and saves `fig1.jpg`.

Step 3 builds the JSON bundle: `{ "checksum": "0x1A2B3C", "figures": [{ "id": "fig1", "file": "fig1.jpg", "caption": "Model architecture" }], "metadata": { "title": "...", "authors": [...] } }`.

Step 4 adds the nine‑section summary entries (Problem, Motivation, …, Takeaway) as short strings.

Step 5 creates the narration list `["Intro", "Method", "Result", "Conclusion"]` preserving reading order.

The same JSON bundle can be streamed to Poster, Video, and Blog generators, guaranteeing that every artifact cites the identical figure file and uses the identical narration sequence.

How does Paper2Assets differ from the per‑generator extraction used in prior systems?

Prior pipelines invoke a full PDF parser inside each generator, so Figure 1 may be cropped three times with three independent AI models. Paper2Assets runs the parser once, stores the clean figure and its caption in a shared bundle, and all generators read that single, verified artifact, eliminating redundant work and guaranteeing identical crops.

Pull the full text and raw figure images from the PDF, preserving page breaks.

Apply a deterministic prefix that strips chrome residues, baked‑in captions, and adds uniform white margins.

Run a visual‑AI model to propose a tight bounding box for each figure.

Verify the AI crop with a sub‑agent that re‑reads the original PDF region; split the image if two figures are packed together.

Synthesize metadata (title, authors, institutes, venue, code links) from the first page and, for arXiv papers, the abstract page.

Write the nine‑section structured summary, each section containing a short essential entry and a supplemental entry.

Fetch institution and venue logos from Wikimedia Commons / Wikidata, validate file types, and render QR codes for the links.

Emit the canonical record files (JSON manifest, text dump, JPEG figures) that downstream skills consume.

**Figure 2.** The ResearchStudio-Reel pipeline. One PDF in, three editor-ready artifacts out, with one shared extraction stage in the middle. A single Paper2Assets pass produces the bundle that Paper2Poster, Paper2Video, and Paper2Blog each consume verbatim, and Paper2Reel binds the three into one navigable surface. Sharing the same section identifiers, figure handles, and claim anchors keeps the artifacts mutually cross-referenced rather than disjoint.

Automated Poster Generation

Turns a shared asset bundle into a polished, multi‑format conference poster.

The poster generator must satisfy five recurring constraints: avoid a combinatorial template explosion, converge a narrow fill loop, stay under the model’s context window, guarantee figures fill their cards, and produce a truly editable export.

Given a single “asset bundle” (paper spec, cleaned figures, logos, QR), the system builds a fixed‑size conference poster by sampling four independent design axes and then iteratively polishing each section until every panel reads “FULL”.

How does Paper2Poster differ from a conventional “poster template” system?

Traditional systems store a fixed set of complete page templates; Paper2Poster instead composes a poster on‑the‑fly from four independent axes, so adding a new style or column layout never multiplies the number of full‑page templates.

The loop treats each poster section as a measured container, assigns it a categorical “fill verdict”, and applies a single, size‑aware edit per iteration until every container lands in the “FULL” band (90 %–98 % of its card).

Verdict EMPTY triggers the “append paragraph” move; the measurement reports a pixel delta of +120 px needed to reach the lower bound of SPARSE (0.70 × 800 = 560 px).

The agent inserts a 120‑pixel‑tall supplemental paragraph, raising content height to 580 px.

New $fullRatio = 580/800 = 0.725$, now in the SPARSE band.

SPARSE triggers “pad prose”; the reported delta is +40 px to reach the lower edge of FULL (0.90 × 800 = 720 px).

Padding adds 40 px of whitespace, raising content height to 620 px.

New $fullRatio = 0.775$, still SPARSE; the loop repeats until the delta would overshoot FULL, at which point the move is skipped and the next round targets the next section.

The loop’s discrete, size‑aware edits avoid the classic “add‑one‑sentence‑and‑overshoot” oscillation that plagues naïve continuous optimisation.

Why not treat the fill problem as a continuous optimisation (e.g., gradient‑based layout adjustment)?

Because the “FULL” band is extremely narrow; a continuous update would repeatedly overshoot and bounce between SPARSE and SPILLAGE. The staged‑fill loop uses categorical verdicts and pixel‑precise deltas, guaranteeing monotonic progress toward a fixed point.

**Figure 3.** The Paper2Poster pipeline. A Paper2Assets bundle (paper spec, cleaned figures, logos, QR) drives an agent that picks the Method plus secondary figures and composes a self-contained poster.html along four axes: column layout, visual style, title-band header, and the Scan-to-Read block. A staged-fill loop then measures each section (slack + polish) and edits one section per round until every panel reads FULL (90–98%) and every figure is large enough on one axis. Narration audio and header logos are packed in, and the converged page is rendered to PDF and PNG and to an editable, native-shape PowerPoint, released only through a mandatory deliverables gate.

**Figure 4.** The staged-fill loop, visualized on the Latent Diffusion Models poster. A debug overlay boxes every section and colors it by fill verdict (red / amber for EMPTY / SPARSE, green for FULL, orange / magenta for SPILLAGE / OVERFLOW), annotated with its fill percentage. (a) Initial explorations: the freshly composed draft is uneven, with several underfilled sections and small figures. (b) Fill-loop in progress: the loop measures each section and edits one per round, so cards pass through OVERFLOW and SPARSE as content is added or trimmed. (c) Poster completed: the loop stops once every section reads FULL (90–98%) and every figure is large enough, yielding the shipped poster.

Automated Video Generation

Transforms a shared asset bundle into a synchronized, auditable video package.

Generating a video from a paper is more than stitching slides together; the output must stay in lockstep with narration, captions, and visual pointers.

It treats the shared Paper2Assets bundle as a single source of truth and orchestrates a deterministic pipeline that yields a fully‑editable deck, a subtitle‑free MP4, and a burned‑in subtitle MP4, all aligned to a pre‑planned narration.

How does Paper2Video differ from a naïve “slide‑to‑video” converter?

A naïve converter would render the PPTX first and then try to trim or speed‑up the video to meet a length target. Paper2Video instead plans the narration length up‑front, rewrites the script when necessary, and guarantees that every visual cue, subtitle, and audio window is pre‑aligned before any rendering occurs.

Step 1: The planner measures 20 s total script length, which is 10 s short of the target.

Step 2: It expands each snippet by adding a brief “overview” sentence (≈5 s each), reaching 30 s.

Step 3: TTS generates two audio clips (15 s each) and produces word‑level timestamps.

Step 4: ppt‑master builds a PPTX with two slides, each anchored to its section ID.

Step 5: `visual_cues`.json links the word “figure” in the first snippet to the geometry of Figure 1 on slide 1.

Step 6: The renderer creates `video_no_subtitles`.mp4 (30 s, silent alignment verified), then burns the subtitle sidecar to obtain video.mp4.

The example shows that length control is achieved by content rewriting, not by cutting the final video, which preserves narrative coherence and cue timing.

Generate a section‑level narration script with stable IDs from the shared asset bundle.

Estimate script duration; if it exceeds the user‑specified target, request semantic rewrites until it fits.

Run the full ppt‑master workflow with the script, assets, and optional visual‑anchor hints to produce

Resolve visual cues: map script anchors to slide geometry, produce

Render

Burn subtitles from the sidecar into

Write

Execute

**Figure 5.** **Paper2Video overview.** The skill reuses the Paper2Assets bundle, plans narration and duration, delegates deck authoring to the full ppt-master workflow, synthesizes aligned audio and captions, renders visual attention cues, and packages the editable deck with captioned and no-subtitle videos. The root deliverables are video.pptx, video.mp4, and `video_no_subtitles`.mp4, while timelines, captions, audio clips, and visual cues stay under assets/, the auditable intermediates directory.

**Figure 6.** Paper2Video deliverable showcase. The figure pairs the editable video.pptx with the captioned video.mp4 and summarizes the user-facing controls checked by the package gate: target duration, highlight style, caption mode, and video specification.

Automated Blog Generation

Paper2Blog turns a shared asset bundle into synchronized bilingual Word articles validated by a strict gate.

Creating consistent bilingual blog posts from a research paper is error‑prone and labor‑intensive, especially when editors need ready‑to‑revise Word files.

Paper2Blog stitches a single evidence map to two language‑specific drafts, then assembles them into Word files that pass a strict package gate.

Evidence map records the result, the DOI, and the three figure identifiers.

Chinese outline orders sections as “背景 → 方法 → 结果”, English outline orders as “Introduction → Method → Results”.

Both drafts pull the same “accuracy = 92%” and the same DOI from the map.

Figure selection picks Fig 1 and Fig 2 (the only ones referenced in the result paragraph); Fig 3 is omitted.

Each draft embeds the chosen figures, resizes them to 300 px width, and writes language‑matched captions.

Word packages are written as `blog_en`.docx and `blog_zh`.docx, then handed to the package gate.

The map guarantees factual parity across languages while allowing the outlines to adapt the narrative flow to each audience.

How does Paper2Blog differ from a simple translate‑then‑format pipeline?

Instead of translating a single monolingual draft, Paper2Blog generates two independent drafts from a shared evidence map. This guarantees that factual statements, figure references, and source links stay identical, while each draft can obey its own editorial register.

The package gate validates that both Word files are complete, visually tidy, and contain identical scientific content before they are released.

Why is a separate package gate needed after the language generation step?

The generation models can produce correct text but have no notion of Word layout constraints. The gate catches visual artefacts—mis‑sized images, orphan tails, blank pages—that would otherwise require manual re‑formatting, ensuring the output is truly editor‑ready.

**Figure 7.** Paper2Blog pipeline. The skill reuses the Paper2Assets bundle, builds one shared evidence map, selects a shared article figure set, writes two language-specific outlines and DOCX files, and runs a strict package gate. The root deliverables are the Chinese article and the English article. Outlines, previews, and QA reports stay in the skill's auditable intermediates directory.

**Figure 8.** **Paper2Blog DOCX showcase.** The figure shows the two required Word deliverables, the English article and the Chinese article, together with the layout checks discussed in the text: typography balance, figure fit, caption placement, and pagination risk.

By grounding both drafts in a single evidence map and enforcing strict visual quality, Paper2Blog delivers ready‑to‑edit bilingual articles that stay scientifically consistent while respecting each language’s editorial style.

Convergence and Interaction

Paper2Reel stitches generated assets into a poster‑first interactive viewer.

Existing research‑dissemination pipelines treat posters, videos, and blogs as separate outputs, forcing users to juggle multiple files and lose context.

Paper2Reel is a thin orchestration layer that reads the completed poster, video, slide, and blog files and, using an alignment sidecar, builds a single interactive viewer where every section is synchronized across media.

The viewer loads the sidecar and renders the poster with blocks A, B, C.

Hovering block B highlights it and shows a tooltip “Method”.

Double‑clicking block B opens the modal; the video pane seeks to 0:31, the blog pane displays the “Method” paragraph, and slide thumbnail 1 appears below the video.

Clicking the subtitle toggle loads the Chinese caption sidecar; captions appear in sync with the video.

Dragging the splitter to the right expands the blog pane, letting the reader read the full paragraph while the video continues playing.

The sidecar provides a deterministic, single‑source mapping, so the UI never has to guess filenames or parse timestamps on the fly.

**Figure 9.** **Paper2Reel interaction showcase.** (1) Hovering a poster section highlights the active block while neighboring sections fade. (2) Double-clicking the section opens the synchronized modal, with video playback, caption control, and slide thumbnail on the left, a language switch in the header, and the aligned blog passage on the right.

How does Paper2Reel differ from a static website that merely links a poster, a video file, and a blog article?

A static site would require the user to click separate links and manually keep track of which video segment matches which blog paragraph. Paper2Reel’s alignment sidecar encodes that correspondence ahead of time, and the UI automatically synchronizes hover, modal opening, video seeking, subtitle toggling, and slide navigation, turning three independent artifacts into a single, context‑preserving reading experience.

Evaluation and Results

ResearchStudio‑Reel unifies posters, videos, and blogs while beating baselines on the poster benchmark.

ResearchStudio‑Reel extracts a shared “asset bundle” from a paper once and then generates synchronized posters, videos, and bilingual blogs from that bundle.

ResearchStudio‑Reel (Claude Code) attains the highest aesthetic and information scores among all automated systems and surpasses the author ground‑truth posters.

Aesthetic mean 3.52 vs 2.94 (ground truth); Information mean 3.90 vs 3.63; wins overall on 84 %–93 % of papers.

We evaluate three families of systems on the Paper2Poster benchmark: single‑shot LLM baselines, multi‑step poster‑pipeline baselines, and two ResearchStudio‑Reel configurations (Claude Code and Codex) that keep the skill fixed while swapping the agent harness and generator model.

**Table 1.** Evaluation of poster generation systems across aesthetic, information, and quiz metrics, alongside available pipeline artifacts.

**Table 5.** **Per-criterion scores under each judge, side by side.** The two held-out judges whose mean forms Table 1: Claude (claude-opus-4.8, left block) and GPT (gpt-5.5, right block). Aesthetic and Information sub-criteria on 1–5 (higher better); Quiz is §PaperQuiz answer accuracy (%). Sub-criteria abbreviated El(ement), En(gagement), La(yout), Lo(w-level), L(o)g(ic), Co(ntent), Det(ail), Und(erstanding). Best value per column among the systems in bold and second best underlined. *Baseline systems are our own Claude Code + claude-opus-4.8 measurements; the Codex row is our skill under Codex + gpt-5.5 on a benchmark subset.

**Figure 10.** Qualitative ablation study. The author ground-truth (top left) is the human reference; the other five are all our method, holding the ResearchStudio-Reel skill, prompt, and pipeline fixed while varying only the harness and base model. Every variant converges to a full, legible single page; they differ in figure choice, phrasing density, and accent, not in structural soundness. All settings use high reasoning effort except the panel marked max reasoning (top-right); the Codex panel runs gpt-5.5 at its default effort.

**Table 2.** Paper2Video capability audit. We compare whether each system produces an editable PPTX deck, and delivers narration, subtitles, timed highlight cues, and duration control.

**Table 3.** **Paper2Blog capability audit.** We compare whether each system accepts paper inputs and produces a blog-style summary with bilingual delivery, embedded figures, editable DOCX output, and layout checks.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers