💻 computer science

Multi-Turn Agentic Scientific Literature Search via Workflow Induction

PaperPilot is a multi-turn scientific literature search agent that frames search as an inducible, editable workflow of executable operators, demonstrating through experiments that this approach significantly improves retrieval performance and eliminates execution errors compared to standard tool-based agents.

Original authors: Jisen Li (University of Illinois Urbana-Champaign, Together AI), Bingxuan Li (University of Illinois Urbana-Champaign), Nanyi Jiang (University of Pennsylvania), Xuying Ning (University of Illinois Ur

Published 2026-07-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jisen Li (University of Illinois Urbana-Champaign, Together AI), Bingxuan Li (University of Illinois Urbana-Champaign), Nanyi Jiang (University of Pennsylvania), Xuying Ning (University of Illinois Urbana-Champaign), Xiyao Wang (University of Pennsylvania), Yifan Shen (University of Illinois Urbana-Champaign), Heng Wang (University of Illinois Urbana-Champaign), Yuqing Jian (Together AI), Xiaoxia Wu (Together AI), Ben Athiwaratkun (Together AI), Pan Lu (Stanford University), Jiaxuan You (University of Illinois Urbana-Champaign), Bingxin Zhao (University of Pennsylvania)

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to find a specific recipe in a massive, chaotic library of cookbooks. You tell a librarian, "I want a recipe that builds on this one dish I made last week."

If you ask a traditional search engine (or a basic AI), it might just grab a few books that have the same words as your request. It's like the librarian shouting, "Here are five books with 'chicken' in the title!" and handing them to you. You might get lucky, but often you get books that are too old, too modern, or about a completely different type of chicken dish.

If you ask a standard AI agent, it tries to be smart by reading your request and guessing what you mean. But it's like a librarian who is trying to read your mind without asking questions. If you say, "This is too broad," the AI might just rewrite your sentence to be shorter, rather than actually changing how it looks for the books. It's stuck in a loop of guessing.

Enter PAPERPILOT.

The authors of this paper created a new kind of "super-librarian" agent called PAPERPILOT. Instead of just guessing or shouting keywords, PAPERPILOT treats finding a paper like building a custom machine (or a workflow) to do the job.

Here is how it works, using simple analogies:

1. The "Lego Blueprint" (The Workflow)

Instead of just searching, PAPERPILOT builds a step-by-step blueprint (called a DAG or Directed Acyclic Graph) out of "Lego blocks." Each block is a specific tool:

Block A: "Find papers that cite this one."
Block B: "Filter out anything older than 2020."
Block C: "Sort by how similar the math is."
Block D: "Read the abstract and check if it mentions 'AI'."

The agent doesn't just run one search; it assembles these blocks into a unique machine designed specifically for your request.

2. The "Conversation" (Multi-Turn Interaction)

The magic happens when you talk to the agent.

You: "I want papers that build on this one."
PAPERPILOT: "Okay, I've built a machine. But before I run it, do you want papers from the last 5 years, or all time? Do you want papers that use the same method, or just the same topic?"
You: "Only the last 5 years, and only if they use the same method."
PAPERPILOT: "Got it."

Instead of just saying "Okay," PAPERPILOT physically edits the blueprint. It takes the "Time" block and changes it from "All Time" to "Last 5 Years." It swaps the "Topic" block for a "Method" block. It refines the machine itself based on your feedback.

3. The "Training" (Learning to Build Better Machines)

The researchers taught PAPERPILOT how to do this by showing it thousands of examples of perfect blueprints.

First, they showed it the "correct" way to build the machine (Supervised Learning).
Then, they played a game: they took a good machine and broke it (e.g., they removed a filter or used the wrong tool). They asked the AI, "Which version is better?" The AI learned to prefer the working machine over the broken one. This is called Preference Optimization.

The Results: Why It Matters

The paper tested this system against other smart search tools. Here is what they found:

Better Accuracy: When PAPERPILOT was allowed to chat and refine its "machine," it found the right papers much more often. It went from finding the right paper 58% of the time to 77% of the time.
Zero Broken Machines: A major problem with AI agents is that they sometimes try to build a machine that doesn't work (like trying to filter by a tool that doesn't exist). PAPERPILOT reduced these errors from 9.5% down to 0%. It learned to build stable, working workflows.
Cheaper and Faster: Even though it is a smaller, cheaper computer model, it performed better than much larger, more expensive systems because it didn't waste time guessing; it built the right tool the first time.

The Bottom Line

The paper argues that searching for scientific papers shouldn't be a "one-shot" guess. It should be a collaborative process where the AI builds a custom search strategy, you give it feedback, and it edits its own strategy until it gets it right.

PAPERPILOT proves that if you give an AI the ability to build and edit its own search plan (like a mechanic tuning a car engine) rather than just reading your words, it becomes a much more powerful and reliable research assistant.

Technical Summary: PAPERPILOT – Multi-Turn Agentic Scientific Literature Search via Workflow Induction

1. Problem Formulation

Scientific literature search is increasingly complex, often requiring more than a single keyword query to satisfy user intent. Researchers must navigate citation neighborhoods, compare methodologies, filter distractors, and refine search strategies based on evolving preferences (e.g., specific citation directions, recency, or application domains).

Existing agentic search systems typically rely on fixed retrieval pipelines or implicit language-only reasoning. These approaches suffer from two main limitations:

Lack of Control: Search strategies are difficult to inspect or refine when users provide feedback (e.g., "focus on more recent work").
Static Intent Handling: Ambiguous information needs often require interactive disambiguation, which fixed pipelines fail to address effectively. Current agents often treat user feedback merely as additional query text rather than instructions to modify the retrieval behavior itself.

The paper posits that scientific literature search should be framed as a multi-turn interactive workflow induction problem, where the agent constructs and refines an executable search strategy based on user feedback.

2. Methodology: PAPERPILOT

The authors introduce PAPERPILOT, a multi-turn agentic system that treats literature search as the induction of an executable Directed Acyclic Graph (DAG) of search operators.

2.1 Workflow Induction Framework

Instead of a fixed pipeline, PAPERPILOT constructs a dynamic DAG for each user request:

Toolset (PAPERPILOT-TOOLSET): A library of typed paper-search operators, including keyword search, citation expansion (forward/backward), filtering, scoring, reranking, and evidence extraction.
DAG Structure: Nodes represent instantiated operators ( $v_i = (o_i, \theta_i)$ ), and edges represent the flow of intermediate outputs (paper sets, scores, keywords, evidence). The system enforces type consistency between nodes.
Adaptive Execution: The agent selects relevant operators and configures their parameters (e.g., search keywords, citation direction, filter predicates) based on the specific search intent (e.g., "strong baselines" vs. "emerging follow-up work").

2.2 Interaction Loop

The system operates in a multi-turn setting:

Initialization: Given an anchor paper ( $p_0$ ) and a user query ( $q$ ), the agent induces an initial workflow ( $G_0$ ).
Execution: The workflow is executed node-by-node, caching intermediate outputs.
Feedback & Refinement: The user (or a simulator) provides feedback ( $f_t$ ). The agent refines the workflow ( $G_{t+1}$ ) by editing the DAG structure, modifying operator parameters, or adjusting intermediate candidate sets.
Finalization: After a finite number of turns, the agent outputs a ranked paper list with evidence.

2.3 Training Strategy

PAPERPILOT-9B is trained using a two-stage supervision pipeline to learn valid DAG generation and robust editing:

Data Construction: High-quality workflow trajectories are generated by a strong teacher model across five search directions (predecessor, successor, sibling, benchmark, survey).
Supervised Fine-Tuning (SFT): The model is trained on 5,540 workflow supervision examples where the gold paper appears in the top-5 results.
Preference Optimization (DPO): To improve stability and error handling, the authors construct preference pairs by corrupting successful workflows with structural and semantic errors (e.g., invalid references, missing inputs, dropped nodes). The model is optimized to prefer the correct workflow over the corrupted one using an IPO-style DPO objective.

3. Key Contributions

Workflow Induction Formulation: The paper formulates multi-turn scientific search as the induction of executable DAG-structured workflows, converting user feedback into concrete edits to search strategies rather than just query text.
PAPERPILOT-9B Model: A 9B-parameter agent trained with workflow imitation and preference optimization over corrupted workflows, demonstrating improved retrieval quality and workflow stability.
Reproducible Benchmark: A hold-out evaluation set with controlled interaction protocols (using an LLM-based user simulator) to enable fair comparison across single-turn and multi-turn settings.

4. Experimental Results

The system was evaluated on a benchmark covering five scientific search directions, comparing PAPERPILOT-9B against base models (Qwen3.5-9B, Qwen3.5-397B) and larger proprietary systems (GPT-5.4, OpenAI DeepResearch).

4.1 Retrieval Performance

In the multi-turn setting, PAPERPILOT-9B significantly outperformed the base Qwen3.5-9B toolset agent:

Hit@5: Increased from 58.0 to 77.0.
MRR: Increased from 47.5 to 59.4.
nDCG@10: Increased from 26.8 to 32.5.
Workflow Stability: Execution errors were reduced from 9.5% to 0%.

Notably, PAPERPILOT-9B surpassed the single-turn GPT-5.4 Web Search baseline on Hit@5, Hit@10, Hit@15, and MRR, despite using a smaller model and lower inference costs.

4.2 Cost-Effectiveness

PAPERPILOT offers a favorable cost-performance tradeoff:

OpenAI DeepResearch: Costs ~$6.09 per case with 72.0 Hit@5.
PAPERPILOT-9B: Costs ~$0.018 per case while achieving 77.0 Hit@5.
GPT-5.4 with Toolset: Achieved the highest absolute performance (84.0 Hit@5) at $0.15 per case.

4.3 Ablation and Analysis

Workflow Editing: PAPERPILOT-9B showed superior local-edit consistency (add, modify, remove nodes) compared to base models, confirming that training helps the model treat feedback as structural instructions.
Search Scale: Increasing the candidate pool size beyond $K=8$ –$10$ generally degraded performance, suggesting that larger pools introduce distractors that weaken downstream filtering.
Human Study: In a study with human participants, PAPERPILOT achieved a 74.7% success rate and a Top-1 Distance of 2.4, significantly outperforming GPT-5.4 (32.0% success) and OpenAI DeepResearch (8.0% success).

5. Significance and Claims

The paper claims that explicit, editable search workflows provide an effective and controllable interface for aligning literature search agents with complex, evolving scientific intents.

Key takeaways emphasized by the authors:

Control vs. Implicit Reasoning: Moving from implicit language reasoning to explicit DAG induction allows users to directly inspect and refine the search strategy.
Stability through Training: Training on corrupted workflows is essential for smaller models to maintain stability during multi-turn interactions, preventing the error accumulation seen in untrained agents.
Practicality: The approach demonstrates that high-quality scientific search does not require massive proprietary models; structured tool use and workflow control can yield superior results with significantly lower costs.

The authors acknowledge limitations, including reliance on a predefined operator library, potential biases from teacher-model trajectories, and the use of simulated user feedback rather than real-world interaction. They suggest future work should explore broader domains and adaptive operator libraries.