English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

Spark-to-Paper: 13 Composable Skills That Turn an Idea Into a Research Paper

Forum topic · ✨步子哥 · 2026-08-13

Summary

Spark-to-Paper, an August 2026 paper by Zhuoyang Qian et al., presents an end-to-end research paper generation system built from 13 composable skills that run inside an existing coding assistant—no standalone agent platform or orchestration service required. The system's key design principles: separate model judgment (literature relevance, claim support) from deterministic code operations (experiment execution, citation verification, fabrication detection); require evidence requirements to be written before any results are seen so claims are revised rather than narratives; apply bounded recovery to self-refutation loops instead of letting experiments run endlessly or massaging results; and generate editable vector figures via code. On 8 controlled research topics it achieved 99.5% citation validity, 96.4% figure editability, fabrication detection improved from 14% to 92% (6.5x), and 74% adversarial review precision—costing 11.9M tokens, $8.1, and 3.2 hours per paper. The broader takeaway: agent reliability is a structural property, not a model property.

The Scenario

A PhD student walks into the lab at 9 a.m., opens their IDE, and types one line at the cursor: "Study knowledge degradation in small models under long-context training."

Handed to Spark-to-Paper, here is what happens next:

1. The literature search skill activates, finding related papers and assembling the research background 2. The experiment design skill activates, writing down—before any results are seen—"what evidence would support or refute the hypothesis" 3. The experiment execution skill activates, running code and collecting data 4. The evidence-matching skill activates, comparing results against the pre-registered evidence requirements to decide which hypotheses are supported and which are refuted 5. The claim revision skill activates, revising the paper's claims based on results—if results don't support the original hypothesis, the hypothesis is rewritten 6. The figure generation skill activates, producing editable vector figures via code 7. The manuscript assembly skill activates, stitching everything into a complete paper

The whole process requires no standalone agent platform, no orchestration service—it all happens inside your existing coding assistant. The 13 skills snap together like building blocks, each doing one concrete thing, combined into an end-to-end "idea to paper" pipeline.

This is the system demonstrated in the August 2026 paper *Spark-to-Paper: End-to-End Research Paper Generation as a Composable Skill* by Zhuoyang Qian et al.

Core Design: Separating Model Judgment from Deterministic Operations

Spark-to-Paper's first design principle: split what models are good at from what code is good at.

Models excel at judgment—is this paper relevant? Does this result support the claim? Is this argument clear? That goes to the LLM.

Code excels at deterministic operations—running experiment scripts, checking whether citations exist, verifying figures are editable, detecting fabrication. Those are enforced by deterministic code, not model "guessing."

This separation makes the system both flexible and reliable. The flexible parts (judging, writing, revising) are handled by the model; the reliable parts (validation, checks, execution) are guaranteed by code.

Second Design: Evidence Before Claims

This is the system's smartest design.

The traditional research flow: form a hypothesis, run experiments, write the paper based on results. The problem: if results don't support the hypothesis, researchers are easily tempted to "adjust the narrative"—spinning non-supporting results as supportive, or selectively reporting.

Spark-to-Paper instead writes down what evidence would support the hypothesis before seeing any results. That evidence requirement is fixed, and only then do experiments run. When results arrive, the system matches them against the pre-designed requirements to decide which claims are supported and which are refuted.

If results don't support the original hypothesis, the system revises the claim rather than the narrative. Claims in the paper must match experimental evidence—no "if the results look bad, reword it."

This design directly encodes the scientific method—hypothesis-first, evidence-driven, falsifiable conclusions—except Spark-to-Paper enforces it with code.

Third Design: Bounded Recovery for the Self-Refutation Loop

Here's an interesting failure mode.

Sometimes experiments repeatedly reject the original research goal: run once, results don't support the hypothesis; try another method, still not supported; try again, still not. This is the self-refutation loop.

What would a human researcher do? Either abandon the topic, or tweak the hypothesis until it's "almost guaranteed to be supported." The first wastes investment; the second is academic misconduct.

Spark-to-Paper's answer is bounded recovery: the system may adjust experimental methods or hypothesis wording a limited number of times, but past a threshold it stops and reports "current evidence does not support the original research goal." It neither loops forever nor fabricates data to make results look good.

The design acknowledges that not every hypothesis can be experimentally supported, and handles it honestly.

Fourth Design: Editable Vector Figures

Figure generation is a pain point in research papers. The traditional approach: run experiments, export a PNG, manually lay it out in PowerPoint or Illustrator. Changing the figure means re-running code, re-exporting, re-layouting.

Spark-to-Paper generates editable vector figures via code. Result plots use programmatic drawing (matplotlib and the like); method diagrams are reconstructed in code. Figures are both "generated" and "editable"—researchers tweak the code directly without re-running the whole pipeline.

The Numbers

The paper tested the full system on 8 controlled research topics:

  • Citation validity: 99.5%—nearly every citation is real
  • Figure editability: 96.4%—nearly every figure can be edited via code
  • Fabrication detection: from 14% with single-pass drafts to 92% with the full integrity stack—a 6.5x improvement from integrity checks
  • Adversarial review precision: 74%—the system critiquing its own paper finds 74% of issues
  • Cost:

  • 11.9M tokens—total consumption for one full paper
  • $8.1 per paper—at current API prices
  • 3.2 hours—average time from idea to complete paper
  • $8.1 per paper, 3.2 hours. That cost moves "end-to-end research paper generation" from "lab demo" to "daily-usable tool."

    Where This Paper Sits

    Spark-to-Paper's core contribution is not "it can generate papers"—prior systems like AI Scientist and GPT-Researcher did similar things. Its contribution is decomposing the research pipeline into 13 composable skills that run inside an existing coding assistant, with no standalone agent platform.

    This positioning matters:

    1. No standalone platform means low deployment cost—install the 13 skills in your existing coding assistant and go. 2. Composable skills means replaceability—if the literature search skill underperforms, swap it without touching the rest of the system. 3. Separating model judgment from deterministic operations means verifiability—the jump in fabrication detection from 14% to 92% comes precisely from deterministic checks catching model "hallucinated" citations.

    Structural Isomorphism with ACE Workflows

    The ACE (Advanced Context Engineering) RPI workflow—Research-Plan-Implement, with independent context compression at each step—rests on the insight that "one line of bad research = thousands of lines of bad code," so research must be separated from implementation.

    Spark-to-Paper is a more radical version of the same principle: it splits the research pipeline into 13 steps instead of 3, but the core logic is identical—each stage is independent, connected by deterministic interfaces.

    ACE's "context compression" maps to Spark-to-Paper's "skill separation"—each skill sees only the context it needs, unpolluted by other stages. ACE's "research first" maps to "evidence before claims"—both determine *what* before *how*.

    This structural isomorphism is no coincidence. The central challenge in agent system design is "reliability over long pipelines," and the solution is increasingly clear: decompose the pipeline into independently verifiable steps, each with an explicit input/output contract.

    A Deeper Observation

    Spark-to-Paper points to a more general principle: reliability comes from structure, not model capability.

    The 99.5% citation validity isn't because the model got "smarter"—it's because the system's structure enforces citation verification. The 92% fabrication detection isn't because the model got "more honest"—it's because deterministic checks catch fabrication.

    This echoes the same principle seen elsewhere (e.g., colibrì running a 744B-parameter model in 1300 lines of C): split tasks into what models do well and what code does well, and let each do its own job.

    A cross-paper consensus is emerging: agent system reliability is a structural property, not a model property. The strongest model in an unreliable structure still errs; even a weaker model in a reliable structure can produce trustworthy results.

    Paper Information

  • Title: Spark-to-Paper: End-to-End Research Paper Generation as a Composable Skill
  • Authors: Zhuoyang Qian, Biao Wu, Yiran Wang et al.
  • arXiv: https://arxiv.org/abs/2608.11924

Tags

#spark-to-paper#agent-systems#research-automation#paper-generation#llm-workflow#composable-skills#scientific-method#code-agents

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178633432