Paper Assembly
Run an end-to-end academic paper pipeline with checkpoints so a solo builder can resume literature, experiments, figures, and writing without losing state.
Overview
Paper Assembly is an agent skill most often used in Build (also Validate and Ship) that orchestrates a nine-phase paper pipeline with checkpointing and resumption from a paper directory.
Install
npx skills add https://github.com/lingzhi227/agent-research-skills --skill paper-assemblyWhat is this skill?
- Chains nine pipeline phases from literature through review with explicit inputs and outputs per phase
- Propagates state between phases and supports checkpointing and resumption via assembly_checker.py
- Scans the paper directory, reports missing artifacts, and suggests the next dependency-safe step
- References orchestration patterns for state management in paper-assembly/references
- Argument-hint accepts a paper-directory or paper plan as the orchestration root
- 9 pipeline phases checked by assembly_checker
- checkpoint.json output for resumption
Adoption & trust: 561 installs on skills.sh; 114 GitHub stars; 3/3 security scanners passed (skills.sh audits); trending (+100% hot-view momentum).
What problem does it solve?
You have scattered paper artifacts across literature, code, and drafts but no single view of what is done, what blocks the next step, or how to resume after a break.
Who is it for?
Solo researchers or indie ML writers assembling a full paper repo with multiple agent skills and needing durable pipeline state.
Skip if: Quick blog posts, one-off summaries, or teams that already use a fixed journal template with no multi-phase agent workflow.
When should I use this skill?
Assembling a complete paper from components; managing state between literature, plan, code, experiments, figures, tables, writing, and review.
What do I get? / Deliverables
You get a dependency-ordered execution plan, completed phase handoffs, and a checkpoint report listing gaps plus the next skill to invoke in the chain.
- checkpoint.json completeness report
- Dependency-ordered phase execution plan
- Identified next pipeline skill and missing artifacts list
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build → docs because the skill’s output is a complete paper artifact tree and orchestrated writing deliverables, even though it starts upstream in research. Assembly centers on manuscript structure, tables, figures, and review-ready docs rather than app frontend or deploy infra.
Where it fits
After literature review, run planning phase outputs into a structured task list before any experiment code lands.
Sync figures, tables, and writing skills so the manuscript directory matches the dependency graph.
Resume from checkpoint when experiment code exists but figure artifacts are still missing.
Use the review phase slot in the nine-step table once drafts and supplements are assembled for critique.
How it compares
Use instead of manually chaining literature and writing skills without a shared checkpoint or completeness scanner.
Common Questions / FAQ
Who is paper-assembly for?
Solo and indie builders running the agent-research-skills paper stack who need one orchestrator across literature, experiments, figures, and manuscript phases.
When should I use paper-assembly?
Use it when starting or resuming a paper directory: after partial literature work in Idea/Validate, while generating code and experiments in Build, or before final review in Ship when artifacts must line up across phases.
Is paper-assembly safe to install?
Review the Security Audits panel on this Prism page and inspect assembly_checker.py and scripts under your skills path before running against sensitive research data.
Workflow Chain
Requires first: literature search
Then invoke: research planning
SKILL.md
READMESKILL.md - Paper Assembly
# Paper Assembly Orchestrate the entire paper pipeline end-to-end with state management and checkpointing. ## Input - `$0` — Paper project directory or paper plan ## References - Orchestration patterns and state management: `~/.claude/skills/paper-assembly/references/orchestration-patterns.md` ## Scripts ### Check pipeline completeness ```bash python ~/.claude/skills/paper-assembly/scripts/assembly_checker.py --dir paper/ --output checkpoint.json python ~/.claude/skills/paper-assembly/scripts/assembly_checker.py --dir paper/ --verbose ``` Scans paper directory, checks 9 pipeline phases, reports missing artifacts, suggests next steps. ## Workflow ### Step 1: Assess Current State 1. Scan the paper directory for existing artifacts 2. Identify which phases are complete vs pending 3. Build a dependency graph of remaining work ### Step 2: Execute Pipeline Phases Run phases in dependency order: | Phase | Skill | Input | Output | |-------|-------|-------|--------| | 1. Literature | literature-search, literature-review | Topic | Knowledge base, BibTeX | | 2. Planning | research-planning | Knowledge base | Paper structure, task list | | 3. Code | experiment-code | Plan | Training/eval pipeline | | 4. Experiments | experiment-design | Code | Results JSON/CSV | | 5. Figures | figure-generation | Results | PNG figures | | 6. Tables | table-generation | Results | LaTeX tables | | 7. Writing | paper-writing-section | All above | main.tex sections | | 8. Citations | citation-management | Draft | references.bib | | 9. Formatting | latex-formatting | Draft | Formatted LaTeX | | 10. Compilation | paper-compilation | All | PDF | | 11. Review | self-review | PDF | Review scores | ### Step 3: State Propagation After each phase completes: 1. Save output artifacts to the paper directory 2. Propagate results to downstream phases 3. Update the progress checkpoint file ### Step 4: Quality Gates Before proceeding to the next phase: - Verify all required outputs exist - Check for consistency (e.g., all cited keys in .bib) - Validate figures/tables match experimental results ### Step 5: Final Assembly 1. Merge all sections into main.tex 2. Verify all \includegraphics files exist 3. Verify all \cite keys exist in .bib 4. Compile to PDF 5. Run self-review for quality check ## Orchestration Patterns ### Sequential Pipeline (AI-Scientist) ``` generate_ideas → experiments → writeup → review ``` ### Multi-Agent State Broadcasting (AgentLaboratory) ```python # Propagate results to all downstream agents set_agent_attr("dataset_code", code) set_agent_attr("results", results_json) ``` ### Copilot Mode (AgentLaboratory) Human can intervene at any phase boundary for review/correction. ## Checkpoint Format ```json { "project": "paper-name", "phases_completed": ["literature", "planning", "code"], "current_phase": "experiments", "artifacts": { "literature": "knowledge_base.json", "plan": "research_plan.json", "code": "experiments/", "results": null }, "last_updated": "2024-01-15T10:30:00Z" } ``` ## Rules - Never skip phases — each depends on previous outputs - Save checkpoints after every phase completion - Human review is recommended at phase boundaries - All numbers in the paper must trace to actual experiment logs - Re-run downstream phases if upstream changes ## Related Skills - Upstream: all other skills (this is the orchestrator) - Downstream: [paper-compilation](../paper-compilation/), [self-review](../self-review/) - See also: [research-planning](../research-planning/) # Paper Assembly Orchestration Patterns Extracted from AI-Scientist (launch_scientist.py), AI-Researcher (main_ai