Skip to content
Content
Skill

/paper-orchestra

Orchestrate the full PaperOrchestra (Song et al., 2026, arXiv:2604.05018) five-agent pipeline to turn unstructured research materials (idea, experimental log, LaTeX template, conference guidelines, optional figures) into a submission-ready LaTeX manuscript and compiled PDF.

From plugin
paperorchestra
6969 skills

Claude Code

$ npx -y skills add Ar9av/PaperOrchestra --skill paper-orchestra --agent claude-code

SKILL.md

paper-orchestra.SKILL.md
name: paper-orchestra
description: Orchestrate the full PaperOrchestra (Song et al., 2026, arXiv:2604.05018) five-agent pipeline to turn unstructured research materials (idea, experimental log, LaTeX template, conference guidelines, optional figures) into a submission-ready LaTeX manuscript and compiled PDF. TRIGGER when the user asks to "write a paper from my experiments", "turn this idea and these results into a paper", "generate a conference submission", "run paper-orchestra on X", or otherwise wants the end-to-end paper-writing pipeline. Coordinates the outline-agent, plotting-agent, literature-review-agent, section-writing-agent, and content-refinement-agent skills.
data_access_level: raw

paper-orchestra (Orchestrator)

Top-level driver for the PaperOrchestra pipeline. Read this document and follow the steps below. The detailed prompts and rules live in each sub-skill's `SKILL.md` and `references/` directories — you (the host agent) will load them as you go.

> Source paper: Song et al., *PaperOrchestra: A Multi-Agent Framework for > Automated AI Research Paper Writing*, arXiv:2604.05018, 2026. > <https://arxiv.org/pdf/2604.05018>

What this skill produces

A complete submission package `P = (paper.tex, paper.pdf)` written into `workspace/final/`, plus a full audit trail under `workspace/` (outline, figures, refs, drafts, refinement worklog, provenance snapshot).

Inputs (the (I, E, T, G, F) tuple from the paper)

The workspace MUST contain:

| File | Symbol | Required | Description | |---|---|---|---| | `workspace/inputs/idea.md` | `I` | yes | Idea Summary (Sparse or Dense variant — see `references/io-contract.md`) | | `workspace/inputs/experimental_log.md` | `E` | yes | Experimental Log: setup, raw numeric data, qualitative observations | | `workspace/inputs/template.tex` | `T` | yes | LaTeX template for the target conference (with `\section{...}` commands) | | `workspace/inputs/conference_guidelines.md` | `G` | yes | Formatting rules, page limit, mandatory sections | | `workspace/inputs/figures/` | `F` | no | Optional pre-existing figures. If empty, the plotting agent generates everything. |

`scripts/init_workspace.py` will scaffold this layout. `scripts/validate_inputs.py` will check it before the pipeline runs.

Pipeline (read `references/pipeline.md` for the full diagram)

Step 1: Outline           ──▶  outline.json                       (1 LLM call)
Step 2: Plotting     ─┐
                      ├──▶  figures/*.png + captions.json         (~20-30 calls)
Step 3: Lit Review   ─┘                                           (~20-30 calls)
                          intro_relwork.tex + refs.bib

Step 4: Section Writing  ──▶  drafts/paper.tex                    (1 LLM call)
Step 5: Content Refine   ──▶  final/paper.tex + final/paper.pdf   (~5-7 calls, ~3 iters)

Step 2 and Step 3 are independent and **MUST run in parallel** when your host supports parallel sub-agents. If not, run Step 3 first (it has the longer wall time due to Semantic Scholar rate limits) and Step 2 second.

Critical pre-instruction (read once, apply always)

Before any LLM call that *writes* paper content (outline, intro/related work, section writing, refinement), you MUST prepend the **Anti-Leakage Prompt** at `references/anti-leakage-prompt.md` to your system prompt. This is verbatim from Appendix D.4 of the paper and prevents pre-training-data leakage. The paper applies it uniformly across all baselines for fair comparison; we apply it for fidelity *and* to keep generated papers grounded in the user's inputs.

Step-by-step execution

0. Pre-flight Checks

Before running the pipeline, perform the following quality gates in order:

# 1. Scaffold the workspace
python skills/paper-orchestra/scripts/init_workspace.py --out workspace/
# user drops their inputs into workspace/inputs/

# 2. Validate required files are present and well-formed
python skills/paper-orchestra/scripts/validate_inputs.py --workspace workspace/

# 3. Check input density — idea and experimental log must meet minimum thresholds
python skills/paper-orchestra/scripts/check_idea_density.py \
    --idea workspace/inputs/idea.md \
    --log workspace/inputs/experimental_log.md

# 4. Cross-validate consistency between idea and experimental log
python skills/paper-orchestra/scripts/validate_consistency.py \
    --idea workspace/inputs/idea.md \
    --log workspace/inputs/experimental_log.md

If `validate_inputs.py` or `check_idea_density.py` fail (exit code 1 or 2), stop and tell the user what's missing or below threshold — do not proceed until fixed.

`validate_consistency.py` produces warnings only (exit code 1 = WARN, non-blocking); report warnings to the user but continue.

**Before failing on missing inputs**, check whether aggregation can supply them:

| Inputs state | Action | |---|---| | `idea.md` and `experimental_log.md` both present and non-empty | Continue to Step 1. | | Either is missing/empty, and the user mentioned a directory | Load and run `agent-research-aggregator` with that directory as `--search-roots`, then re-validate. | | Either is missing/empty, no directory mentioned | Ask the user: "Your workspace is missing `idea.md` / `experimental_log.md`. Do you have a folder with research notes or agent history I can aggregate from? If so, tell me the path — or drop the files manually into `workspace/inputs/`." |

If validation still fails after aggregation (e.g. `template.tex` or `conference_guidelines.md` are missing), stop and tell the user exactly which files remain outstanding.

**Also probe the TeX installation** (once per workspace, result cached):

python skills/paper-orchestra/scripts/check_tex_packages.py \
    --out workspace/tex_profile.json

The Section Writing Agent reads `tex_profile.json` to decide which LaTeX patterns to use (e.g., `Figure~\ref{}` vs `\cref{}`, whether to include `\usepackage{microtype}`, etc.). This eliminates compile-time package failures tha

Read more
@ar9av
Ships withpaperorchestra

A pluggable skill pack that lets any coding agent in Claude Code, Cursor, Antigravity, Cline, Aider, OpenCode, etc. which can run the PaperOrchestra multi-agent pipeline for turning unstructured research materials into a submission-ready LaTeX paper.

Stars on GitHub

Momentum

stars in total
696
Star history of Ar9av/PaperOrchestra on GitHub, a chart by star-history.com

Other skills on paperorchestra.

outline-agent

outline-agent

Step 1 of the PaperOrchestra pipeline (arXiv:2604.05018). Convert (idea.md, experimental_log.md, template.tex,…

paper-autoraters

paper-autoraters

Run the four paper-quality autoraters from PaperOrchestra (arXiv:2604.05018, App. F.3) — Citation F1 (P0/P1 partition +…

paper-writing-bench

paper-writing-bench

Reverse-engineer raw materials (Sparse idea, Dense idea, experimental log) from an existing AI research paper to build a…

More skills from other plugins.

prompt-lookup

prompt-lookup

Activates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use…

@gh-f@gh-fInstall Skill
ppt-master

ppt-master

AI-driven presentation workflow for generating editable PPTX decks and slides, reconstructing page visuals, creating reusable…

@hugohe3@hugohe3Install Skill
morph-ppt

morph-ppt

Use this skill when the user wants a .pptx with smooth cross-slide animation — PowerPoint Morph transitions, Keynote-style…

officecli11d33k
@iofficeai@iofficeaiInstall Skill

Questions about paper-orchestra.

Which coding agents can use paper-orchestra?
paper-orchestra installs in Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and Windsurf with the skills CLI, using each agent's flag shown on this page. Flowy's auto-invocation, which fires a skill when your prompt matches, runs in Claude Code only.