🤖 AI

daVinci-Agency: Unlocking Long-Horizon Agency Data-Efficiently

The paper introduces daVinci-Agency, a data-efficient framework that leverages authentic Pull Request sequences to synthesize high-quality, long-horizon training data for Large Language Models, enabling significant performance gains in complex agentic workflows without prohibitive annotation costs.

Original authors: Mohan Jiang, Dayuan Fu, Junhao Shi, Ji Zeng, Weiye Si, Keyu Li, Xuefeng Li, Yang Xiao, Wenjie Li, Dequan Wang, Pengfei Liu

Published 2026-02-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mohan Jiang, Dayuan Fu, Junhao Shi, Ji Zeng, Weiye Si, Keyu Li, Xuefeng Li, Yang Xiao, Wenjie Li, Dequan Wang, Pengfei Liu

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

The Big Problem: The "Short Attention Span" of AI

Imagine you have a brilliant student who is amazing at answering single questions, like "What is 2+2?" or "Write a poem about a cat." This student is a Large Language Model (LLM).

However, if you ask this student to build a house, they struggle. They might lay the foundation, then forget they need a roof, or they might build a wall in the wrong place and not realize it until the very end. In the world of AI, this is called a long-horizon task. It's a job that requires many steps, where mistakes made early on can ruin the whole project later.

The paper argues that current AI models fail at these long jobs because they haven't been trained on data that shows them how to plan ahead, stay consistent, and fix their own mistakes over a long period.

The Solution: Learning from "Software Evolution"

The authors (from SII, SJTU, and GAIR) realized that the best way to teach an AI how to handle long, complex projects is to look at how real humans build software.

The Analogy: The "Pull Request" Chain
In software development, when a programmer wants to add a feature or fix a bug, they don't just dump the finished code. They submit a "Pull Request" (PR).

Step 1: They submit a small change (PR #15).
Step 2: Reviewers say, "This looks good, but you missed a safety net."
Step 3: The programmer fixes it and submits a new change (PR #21) that builds on the first one.
Step 4: This continues for several rounds until the feature is perfect.

The authors call this a "Chain of Pull Requests." It's like a story where each chapter depends on the previous one, and the characters (the code) evolve and improve over time.

The Innovation: daVinci-Agency

The team created a new system called daVinci-Agency. Instead of making up fake scenarios or paying humans to write long stories for the AI to learn from (which is expensive and slow), they went to GitHub (a giant library of real software projects) and harvested these natural "Chains of Pull Requests."

They turned these real-world development stories into training data.

The Training: They took a model (GLM-4.6) and showed it these chains.
The Lesson: The AI learned that to succeed, it must:
- Decompose: Break a huge goal into small, manageable steps.
- Stay Consistent: Remember the original goal even after 50 steps.
- Refine: Look at its own mistakes (bugs) and fix them without starting over.

The "Magic" Result: Small Data, Big Gains

Usually, to make an AI smarter, you need to feed it millions of examples.

The Old Way: Train on 66,000 examples (like other datasets in the paper).
The daVinci Way: Train on just 239 examples.

The Result:
Despite using 200 times less data, the model trained on daVinci-Agency performed significantly better than models trained on massive datasets.

On a test called Toolathlon (where the AI has to use tools to solve problems), the model improved by 47%.
On SWE-bench (a test for fixing real software bugs), it also scored much higher.

Why? Because the 239 examples were high-quality. They weren't random; they were real stories of how complex problems are solved over time. The AI didn't just memorize facts; it learned the habit of persistence and correction.

What the AI Actually Learned (The "Meta-Skills")

The paper shows that the AI didn't just get better at coding; it got better at thinking.

Before: If the AI made a mistake, it would get confused, wander off into irrelevant topics, or give up (called "escapism").
After: When the AI made a mistake, it paused, realized, "Wait, I'm doing this wrong," and fixed it. It learned to plan and stay on track.

Efficiency: Doing More with Less

The paper also found that the new AI is more efficient.

Analogy: Imagine two people trying to solve a maze.
- Person A (Old AI): Runs into every dead end, screams, and tries 100 different wrong paths.
- Person B (daVinci AI): Looks at the map, sees the dead ends, and takes the direct path.
The daVinci-trained AI used fewer words (tokens) and fewer tool clicks to solve the same problems. It didn't waste energy on confusion.

The "Scaling" Discovery

Finally, the authors tested what happens if they make the training stories even longer.

They found that if they trained the AI on chains with more steps (longer Pull Request chains), the AI got even better.
This suggests that the more "long-distance" thinking the AI practices, the better it becomes at solving very long, complex problems.

Summary

daVinci-Agency is a new way to train AI agents. Instead of forcing them to memorize millions of short, fake tasks, it teaches them by showing them real, long stories of how humans build software. By learning from these natural "chains of events," the AI learns to plan, stay consistent, and fix its own mistakes, becoming much smarter and more efficient with far less data than before.

Technical Summary: daVinci-Agency – Unlocking Long-Horizon Agency Data-Efficiently

1. Problem Statement

While Large Language Models (LLMs) have demonstrated proficiency in short-term tasks, scaling them to long-horizon agentic workflows remains a significant challenge. The primary bottleneck is the scarcity of high-quality training data that captures authentic long-dependency structures and cross-stage evolutionary dynamics.

Existing data synthesis methods face two critical limitations:

Synthetic Trajectories: Methods relying on single-feature scenarios or teacher-bounded distillation often fail to capture realistic failure modes, error accumulation, and iterative refinement patterns. They treat steps independently, lacking the causal dependencies essential for persistent goal-directed behavior.
Manual Annotation: High-fidelity supervision through human annotation is prohibitively expensive and difficult to scale.

Consequently, current models struggle with maintaining direction, mitigating cumulative errors, and performing iterative refinement over extended interaction spans.

2. Methodology: daVinci-Agency

The authors propose daVinci-Agency, a novel data synthesis paradigm that reconceptualizes training data construction through the lens of real-world software evolution. The core insight is that GitHub Pull Request (PR) sequences naturally embody the supervision signals required for long-horizon learning.

2.1 Core Mechanism: Chain-of-PRs

Unlike isolated issue fixes, software development involves continuous iteration where multiple PRs align with a single functional goal. daVinci-Agency systematically mines structured supervision from chains of PRs (sequences of semantically linked PRs where $PR_i$ iterates upon, fixes, or extends $PR_{i-1}$ ). This structure enforces three critical mechanisms:

Progressive Task Decomposition: Achieved via continuous commits and sub-queries that break complex objectives into verifiable submission units.
Long-Term Consistency: Enforced through unified functional objectives across the chain, requiring the agent to maintain state coherence as the codebase evolves.
Verifiable Refinement: Derived from authentic bug-fix histories and feedback loops, teaching the agent to correct errors based on prior states.

2.2 Data Curation Pipeline

The framework operates through a rigorous pipeline:

Data Sourcing: Nine representative, mature GitHub repositories (e.g., Scipy, Django) were selected based on scale (>7,000 PRs), community interactivity, and linguistic diversity.
PR Chain Construction: Using GitHub API metadata, the system constructs dependency topologies where PRs are linked by semantic references (e.g., "fixes #15").
Query Formulation: For each PR in a chain, a sub-query is synthesized. Crucially, implementation details are withheld to force the agent to navigate and localize code, while a global overview of the entire chain is provided to ensure macroscopic understanding.
Rollout & Rejection Sampling: Agents (using GLM-4.6 as the rollout model) execute tasks sequentially across the PR chain. A state transition mechanism ensures code changes from previous stages propagate to the next. A strict rejection sampling process (using an evaluator with a threshold $s \ge 0.8$ ) filters trajectories, retaining only those with high semantic fidelity to the ground truth patches.

3. Key Contributions

A Scalable Data Paradigm: The introduction of daVinci-Agency, which utilizes real-world PR evolution to construct verifiable long-horizon training data without relying on expensive human annotation or single-feature synthesis.
Data Efficiency: Demonstrating that fine-tuning on a remarkably small dataset (239 samples) yields broad improvements, outperforming baselines trained on datasets orders of magnitude larger (e.g., 66k samples).
Meta-Skill Acquisition: Providing evidence that the paradigm effectively teaches three critical meta-skills: task decomposition, long-term consistency, and iterative refinement.
Scaling Laws: Unveiling specific data scaling laws for long-horizon tasks, showing that extending both the training horizon (chain length) and inference-time interaction budgets significantly enhances agent performance.

4. Experimental Results

The authors evaluated fine-tuned models (specifically GLM-4.6, Qwen3 series) across diverse benchmarks including SWE-bench, Toolathlon, DS-1000, and $\tau^2$ -Bench.

Performance Gains: Fine-tuning GLM-4.6 on just 239 daVinci-Agency samples resulted in a 47% relative gain on Toolathlon and a 148% improvement in long-horizon performance compared to models trained on larger, less structured datasets.
Comparison with Baselines: The model outperformed baselines trained on SWE-Smith (66k samples) and CC-Bench (260 samples), particularly in tasks requiring cross-stage evolution.
Ablation Studies:
- Removing the cross-stage evolution (SinglePR variant) led to decreased performance, confirming the necessity of multi-PR chains.
- Chronologically ordered chains without semantic links (TemporalChain) showed limited benefits, highlighting that intrinsic evolutionary logic is more critical than mere sequence length.
Efficiency: Models trained on daVinci-Agency demonstrated significantly reduced token consumption (e.g., 113.6K fewer tokens on SWE-bench for GLM-4.6) and tool usage, indicating higher information density per token and better context management.
Scaling Analysis: Extending training trajectories from ~59k to ~85k tokens (by completing longer PR chains) yielded further performance gains, validating the scaling potential of long-horizon sequential structures.

5. Significance and Claims

The paper claims that daVinci-Agency establishes a principled path to unlock the intrinsic long-horizon potential of agents. Its significance lies in:

Overcoming Data Scarcity: It demonstrates that modeling real-world evolutionary trajectories offers a scalable alternative to synthetic or manually annotated data.
Internalization of Behavior: The results suggest that agents can internalize complex, persistent goal-directed behaviors (planning, consistency, error correction) when exposed to high-quality structural data, rather than just surface-level patterns.
Self-Distillation Potential: Since the training trajectories were generated by the model itself (GLM-4.6), the performance gains are attributed to the model's self-exploration and optimization within a curated environment, rather than knowledge distillation from a superior "teacher."

The authors conclude that while current implementations are limited to chains of up to 5 PRs due to success rate constraints, the observed scaling laws suggest that extending these chains is a viable and promising direction for future research in long-horizon agentic systems.