Error-Driven Data Expansion (EDDE)

• EDDE is a data-centric methodology that transforms model errors into targeted data samples to cover challenging and underrepresented cases.
• It employs a closed-loop process incorporating seed extraction, sample generation, and verification to refine data and enhance model adaptation.
• Empirical outcomes show significant improvements in benchmarks, with enhanced pass@1 rates and overall accuracy in both code generation and tool-use scenarios.

Error-Driven Data Expansion (EDDE) is a data-centric methodology developed to enhance the adaptation and robustness of LLMs in tasks where data scarcity or distribution shift limits traditional training efficacy. EDDE systematically identifies a model's failure cases and utilizes them as the foundation for generating structurally similar but contextually varied new training samples, with the goal of efficiently covering hard or underrepresented regions in the problem space. This approach is integral to frameworks such as LoopTool for tool-using LLMs and DEED for code generation, where it delivers improvements in model generalization and state-of-the-art results on challenging benchmarks (Zhang et al., 12 Nov 2025, Jiang et al., 2024).

1. Conceptual Underpinnings

EDDE is grounded in the principle that model errors—rather than being discarded—serve as high-value seeds for generating additional, targeted data. Unlike static or uniformly sampled data augmentation, EDDE constructs new samples by synthesizing variants around observed failures, thereby “growing” the local error region in the training distribution. This targeted expansion seeks to maximally exploit each failure by interpolating in both structural and contextual dimensions, exposing the model to new variations of challenging cases and mitigating overfitting to a small set of mistakes (Zhang et al., 12 Nov 2025).

In DEED, this approach is applied to code generation: generation failures under test suites are revised (either via an auxiliary model or a prompting strategy) into correct samples, and the original model is fine-tuned on this constructed set. For robust tool use in LLMs, LoopTool employs EDDE as part of a closed feedback loop consisting of capability probing (GCP), automated label verification (JGLV), and error-driven expansion—iteratively evolving both data and the model (Jiang et al., 2024, Zhang et al., 12 Nov 2025).

2. Formal Framework and Algorithmic Realization

Formally, EDDE operates over a model’s error seed set, defined at iteration $j$ as $$\mathcal{D}_j^{\mathrm{ES}} = \mathcal{D}_j^{\mathrm{MR}} \cup \mathcal{D}_j^{\mathrm{LR}}$$, where $\mathcal{D}_j^{\mathrm{MR}}$ contains model-wrong seeds and $\mathcal{D}_j^{\mathrm{LR}}$ contains label-wrong seeds as identified through post-hoc judgement (Zhang et al., 12 Nov 2025). For each $s \in \mathcal{D}_j^{\mathrm{ES}}$, the method samples $k$ new examples $x'$ from a proposal distribution:

$Q_j(x'\mid s) \propto \exp(-\Delta(s, x'))$

where $\Delta(s, x')$ quantifies structural divergence, enforcing that $x'$ preserves the core functional challenge—e.g., tool calls, argument schema—while varying in scenario constraints, such as user goals or contextual modifiers.

The generic EDDE process includes:

• Seed Extraction: Collect error cases output by the model, partitioned by verification.
• Sample Generation: For each seed, prompt a generative model (e.g., Qwen3–32B for LoopTool) with fixed system instructions and randomized scenario templates to output $$\mathcal{D}_j^{\mathrm{ES}} = \mathcal{D}_j^{\mathrm{MR}} \cup \mathcal{D}_j^{\mathrm{LR}}$$0 new variants.
• Verification: Filter the expanded set via syntactic (rule-based) and semantic (judge-model) checks to remove ill-formed or unproductive samples.
• Iteration: Aggregate the newly generated examples, combine with existing failure seeds and other high-value subsets, and retrain or fine-tune the target model (Zhang et al., 12 Nov 2025).

In code generation scenarios (DEED), error-driven expansion additionally involves a revision process: the erroneous code is automatically revised via a specialized model, with the revision chosen for minimal edit distance to the error and required to pass tests. Model adaptation then proceeds via full or parameter-efficient fine-tuning (such as LoRA) on the revised set, iterating until error generation stagnates (Jiang et al., 2024).

3. Implementation Recipes and Variants

The central procedures of EDDE are domain-adaptable, but exhibit concrete instantiations in published frameworks:

Framework	Seed Source	Expansion Model	Verification/Selection
LoopTool	GCP + JGLV	Qwen3-32B w/ scenario mods	RuleCheck + JudgeCheck
DEED	Test-failing outputs	Self-Revise LLM	TestEval (suite-based)

In LoopTool, EDDE is triggered after each training round by GCP and JGLV. For each error seed, a system prompt configures the generator as an "API-call generator" tasked with producing structurally identical but contextually diversified dialogues. User prompts insert the required rigid features (tool subset, argument schema) and sample from ~10 scenario templates (e.g., "time zone UTC–5, budget under $50"). Variants are accepted only if they pass both structural and judge-model validation.

DEED for code adaption relies on error outputs failing a test suite. These errors are revised (via FT or prompting) into passing variants as close as possible (minimal Levenshtein distance) to the original error, and the student model is fine-tuned on aggregates of these revised pairs. For both approaches, the maximum number of iterations and hyperparameters (such as $\mathcal{D}_j^{\mathrm{ES}} = \mathcal{D}_j^{\mathrm{MR}} \cup \mathcal{D}_j^{\mathrm{LR}}$1 and scenario template library size) are set based on empirical convergence and generalization tradeoffs (Zhang et al., 12 Nov 2025, Jiang et al., 2024).

4. Data Efficiency and Empirical Outcomes

EDDE demonstrates marked improvements in data-limited adaptation tasks and robustness on hard distribution tails. In code generation (DEED), average improvements of 25–100% (relative) in pass@1 are observed compared to strong baselines, with convergence typically reached in two EDDE iterations. For example, DEED yields pass@1 on HumanEval of 38.6% (vs. 29.8%, +29.5%) and on DataScience of 5.3% (vs. 2.6%, +103.8%), using no more than 200 training examples per benchmark (Jiang et al., 2024).

In LoopTool, ablation studies demonstrate that removing EDDE causes reductions of 1.2–1.5 percentage points in overall accuracy on complex tool-call benchmarks such as BFCL-v3 and ACEBench. Importantly, accuracy on the original failure (seed) set improves by approximately 10% absolute over iterations with EDDE, as opposed to near-stagnant recovery if errors are simply recycled. Inclusion of EDDE enables the 8B model to surpass even its 32B data generator in performance, illustrating the method's impact on sample efficiency and closing generalization gaps (Zhang et al., 12 Nov 2025).

5. Interactions with Closed-Loop Data Evolution

EDDE is most effective when integrated within a closed feedback system that systematically identifies, verifies, and exploits failure regions. In such architectures, e.g., LoopTool, EDDE interacts with modules for capability probing (GCP) and judgement-guided label verification (JGLV):

1. GCP marks prediction-reference mismatches.
2. JGLV partitions these into model-failure or label-error seeds.
3. EDDE generates and verifies structural variants around these seeds.
4. Data aggregates are updated; model retraining follows.

This loop continues until maximum iterations or stagnation of new error discovery. The synergy across modules ensures not only that error-driven expansion addresses a model's current weaknesses, but also that label noise is minimized and expansions target genuinely hard regions (Zhang et al., 12 Nov 2025).

6. Sensitivity, Ablation, and Design Choices

Empirical ablations in both DEED and LoopTool reveal key design sensitivities:

• Number of Expansion Iterations: Performance saturates within 2 iterations; additional rounds yield diminishing returns (Jiang et al., 2024).
• Source and Quality of Expansion Seeds: Self-revised errors outperform both raw in-domain data and human-revised errors. Replacing the revision model with large general-purpose LLMs raises revision pass rates but does not confer additional gains to the adapted model (Jiang et al., 2024).
• Prompt Components: Removal of failed test cases, error messages, or correct solutions from revision prompts degrades the performance of both revision and student models. Failed test cases are the most critical input signal (Jiang et al., 2024).
• Scenario Template Diversity: For tool-use scenario expansion, the constraint library size directly impacts the diversity and utility of generated hard cases (Zhang et al., 12 Nov 2025).

In all examined setups, EDDE is responsible for stable gains within the hardest evaluation subsets and consistent incremental improvement at the overall benchmark level (e.g., +1.2–1.5%, per-iteration) (Zhang et al., 12 Nov 2025).

7. Context and Prospective Extensions

EDDE represents a paradigm shift towards self-refining, model-aware data generation pipelines. By systematically generating adversarially hard or unseen cases in the model’s failure region, it enables robust specialization under data constraints and rapidly closes generalization gaps. Future adaptations may further automate the scenario diversification constraint design, generalize to domains beyond code and tool use, or integrate self-improving judge or reviser models for even greater data synthesis efficiency.

The approach demonstrates that rigorous error mining and targeted expansion, coupled with closed-loop verification, are pivotal to scaling LLM reliability in dynamic and high-variance practical deployments (Jiang et al., 2024, Zhang et al., 12 Nov 2025).