---
title: 'AgentPack: Collaborative Code-Editing Corpus'
url: https://www.emergentmind.com/topics/agentpack
type: topic
---

# AgentPack: Collaborative Code-Editing Corpus

AgentPack is a large-scale corpus comprising 1,337,012 real-world code edits co-authored by software-engineering agents—Claude Code (Anthropic), OpenAI Codex, and Cursor Agent—and humans in public GitHub repositories between April 1 and August 15, 2025. The primary objective of AgentPack is to provide high-quality, naturally labeled code-editing exemplars suitable for fine-tuning and analyzing large language models (LLMs) on code-editing tasks. The dataset uniquely focuses on human–agent collaborative activity filtered via maintainer approval, distinguished by semantically scoped patches with detailed, agent-generated rationales and natural language intentions [2509.21891].

## 1. Source Agents and Dataset Scope

AgentPack identifies code-editing events through agent-specific commit and pull request signatures:

- **Claude Code**: Commits contain the annotation `Co-Authored-By: Claude <noreply@anthropic.com>`.
- **OpenAI Codex**: Pull request descriptions include links to `chatgpt.com/codex/tasks`.
- **Cursor Agent**: Commits bear the author line `Cursor Agent <cursoragent@cursor.com>`.

The corpus spans 59 GB, drawn from material accepted into default branches ("main" or "master"). The time window commences one week after the Claude Code launch (2025-04-01) and ends on 2025-08-15. This interval captures the initial widespread adoption of these agents in open-source workflows.

## 2. Identification, Curation, and Quality Control Pipeline

AgentPack employs a multi-stage pipeline for data identification, curation, and quality assurance:

1. **Event Detection**: Public GitHub Archive (GH Archive) events are queried for push and pull_request activity, matching agent-specific signatures.
2. **Repository Cloning and Merge Filtering**: For each repository containing candidate agent–human co-authored edits, a shallow bare clone is performed, retaining only those commits merged into the default branch, thus leveraging the project maintainers' review process as an implicit human-in-the-loop quality control mechanism.
3. **Patch Extraction and Noise Reduction**: The complete git diff (all hunks) is extracted per commit, with patches referencing files under `node_modules/` removed to avoid contaminating the corpus with third-party vendor code.
4. **Metadata Integration**: Commit metadata—including timestamp, agent label, and original (agent-generated) description—are joined with patch content to form individual AgentPack items.

An illustrative scoring function for prioritizing high-signal commits is defined as

$$
s(\text{commit}) = \alpha\,f_{\mathrm{scope}}(\text{commit}) + \beta\,f_{\mathrm{clarity}}(\text{message})
$$

where \(f_{\mathrm{scope}}\) favors edits affecting fewer files, and \(f_{\mathrm{clarity}}\) rewards message length, with $\alpha, \beta > 0$ as tunable weights.

## 3. Adoption Trends and Quantitative Metrics

AgentPack documents rapid adoption of LLM-based agents in software-engineering practice:

- **Aggregate Commits Over April–August 2025**:
    - Claude Code: ~854,946 commits
    - Codex: ~372,006 commits
    - Cursor Agent: ~110,060 commits

Cumulative commit rate functions $C_a(t)$ track agent-specific uptake, and the adoption ratio is given by

$$
R_a(t) = \frac{C_a(t)}{C_{\mathrm{total}}(t)}
$$

with $C_{\mathrm{total}}(t) = \sum_{a} C_a(t)$. Claude Code exhibited the fastest growth (steep increase May–June), peaking mid-May (~10,000 commits/week), followed by a plateau. Codex peaked in June, whereas Cursor Agent usage increased steadily but at a lower rate, suggesting more targeted deployment scenarios.

## 4. Structural Properties of Edits

AgentPack's code edits display distinct structural characteristics in comparison to historical human-only corpora:

- **Median Per-Edit Statistics**:
    - Files touched: 2
    - Patch size: 70 lines (added + removed)
    - Hunks per file: 1.5
    - Commit message length: 323 characters

Comparative benchmarks include CommitPackFT (single-file edits: patch size 4 lines, message length 43 chars) and CanItEdit (patch size 7 lines, message length 57 chars); thus, AgentPack edits are approximately 10× larger, with commit messages 6–10× longer.

Code-edit complexity is quantified as

$$
\mathrm{Complexity}(\mathrm{patch}) = \mathrm{files\_count} \times \log(1 + \mathrm{lines\_changed})
$$

AgentPack's complexity distribution is bimodal at approximately 30 and 120, corresponding to a spectrum from rapid single-file fixes to multi-file refactorings.

| Dataset        | Median Patch Size | Median Message Length |
|----------------|------------------|----------------------|
| AgentPack      | 70 lines         | 323 chars            |
| CommitPackFT   | 4 lines          | 43 chars             |
| CanItEdit      | 7 lines          | 57 chars             |

## 5. Fine-Tuning Experiments and Benchmarking

A subset of 118,848 Python-only edits (≤4096 tokens, ~120M tokens total) was used to fine-tune DeepSeekCoder 1.3B and 6.7B models from the EditCoder family. The prompt template was:

```
## Instruction:
{message}

## Code Before:
{old}

## Code After:
```

Training parameters included the AdamW optimizer, learning rate 2e-5, batch size 64, 3 epochs, and cosine decay with 10% warmup. Benchmark evaluations involved HumanEvalFix (bug-fixing) and CanItEdit tasks, using pass@1 (20 samples, temperature=0.2, top-p=0.95).

**Results:**

| Model              | Base HEF | Base CI | EditCoder HEF | EditCoder CI | AgentPack HEF | AgentPack CI | Δ_HEF | Δ_CI |
|--------------------|----------|---------|---------------|--------------|---------------|--------------|-------|------|
| DeepSeekCoder-1.3B | 0.19     | 0.11    | 0.20          | 0.29         | 0.32          | 0.32         | 0.13  | 0.21 |
| DeepSeekCoder-6.7B | 0.39     | 0.30    | 0.45          | 0.42         | 0.48          | 0.41         | 0.09  | 0.11 |

AgentPack-driven fine-tuning produced significant gains relative to both baseline and existing EditCoder models ($p < 0.05$, paired bootstrapping). Ablations demonstrate that removing multi-file edits reduced $\Delta_\mathrm{HEF}$ by ≈ 0.04, underscoring the value of complex, multi-file examples.

## 6. Distinctive Advantages and Limitations

**Advantages:**

- Rich natural language intent articulation: commit messages in AgentPack are approximately 10× longer than those in human-only datasets.
- Broader operational scope: includes multi-file changes, test additions, refactorings, and documentation edits.
- Human-vetted commit quality: inclusion is restricted to changes merged to mainline branches, leveraging existing project governance processes.

**Limitations:**

- Absence of original user prompts; only agent-generated rationales are present.
- Uncertainty regarding Cursor Agent's backend model identity due to lack of disclosure.
- Possible human modification of some agent-authored commits post-merge.
- Exclusively public-project data; excludes unmerged or private edits, introducing a potential repository bias.

## 7. Implications and Future Directions

AgentPack establishes a paradigm for constructing high-quality code-editing datasets grounded in real-world, human-vetted agent–human collaboration. *A plausible implication is* that the combination of human-in-the-loop quality control, enriched linguistic context, and increased structural scope has direct performance benefits for downstream LLM-based code-editors.

Future avenues include extending coverage to additional programming languages and low-resource ecosystems, reconstructing original prompt–response dialogue contexts, and deploying AgentPack as an RL training environment for software-engineering agents in open-world settings. AgentPack serves as both a benchmark and resource for systematically studying agent integration into software development workflows and informs the next generation of code-editing system development [2509.21891].

Source: https://www.emergentmind.com/topics/agentpack