Source-linked AI summary
ReCreate: Reasoning and Creating Domain Agents Driven by Experience
Zhezheng Hao, Hong Wang, Jian Luo, Jianqing Zhang, Yuyan Zhou, Qiang Lin, Can Wang, Hande Dong, Jiawei Chen
TL;DR
Domain-specific agent scaffolds are costly to design manually, while existing automated methods mainly optimize black-box performance scores and overlook evidence explaining agent behavior. ReCreate uses interaction experience in an agent-as-optimizer framework to update scaffolds, achieving consistent gains across diverse domains even from minimal seeds.
Problem
Domain agents remain human-designed because domains require distinct knowledge and priors, while automated methods commonly rely only on performance metrics and overlook execution evidence explaining success or failure.
Method
ReCreate uses an agent-as-optimizer design that stores and retrieves experience, maps execution evidence into scaffold updates, and extracts reusable domain-level patterns.
Results
ReCreate achieves consistent performance gains over human-designed agents and existing agent-creation methods across thirteen benchmarks and four domains, including from minimal seed scaffolds.
Takeaways & Limitations
Interaction experience enables scaffold updates grounded in concrete evidence while improving task generalization across diverse domains.
Takeaways & Limitations
ReCreate updates textual and code-level scaffolds but not infrastructure such as harnesses and environments, and it does not update base-model parameters.
Abstract
from arXiv · showhide
Large Language Model agents are reshaping the industrial landscape. However, most practical agents remain human-designed because tasks differ widely, making them labor-intensive to build. This situation poses a central question: can we automatically create and adapt domain agents in the wild? While several recent approaches have sought to automate agent creation, they typically treat agent generation as a black-box procedure and rely solely on final performance metrics to guide the process. Such strategies overlook critical evidence explaining why an agent succeeds or fails, and often require high computational costs. To address these limitations, we propose ReCreate, an experience-driven framework for the automatic creation of domain agents. ReCreate systematically leverages agent interaction histories, which provide rich concrete signals on both the causes of success or failure and the avenues for improvement. Specifically, we introduce an agent-as-optimizer paradigm that effectively learns from experience via three key components: (i) an experience storage and retrieval mechanism for on-demand inspection; (ii) a reasoning-creating synergy pipeline that maps execution experience into scaffold edits; and (iii) hierarchical updates that abstract instance-level details into reusable domain patterns. In experiments across diverse domains, ReCreate consistently outperforms human-designed agents and existing automated agent generation methods, even when starting from minimal seed scaffolds.
1 Introduction
LLM agents increasingly perform complex tasks, but their domain-specific scaffolds remain labor-intensive to design manually. ReCreate addresses this gap by using interaction experience as evidence for scaffold refinement and reports consistent gains across diverse evaluations.
- LLM agents rely on scaffolds that specify prompting, task decomposition, execution, tools, and environment-feedback integration.
- Manual scaffold design is labor-intensive because different domains require distinct knowledge and priors, motivating automatic domain agent creation.
- Existing automated generation methods typically use performance metrics to iteratively propose, evaluate, and refine candidate scaffolds.
- ReCreate reframes scaffold creation as white-box optimization driven by trajectories, evaluation logs, and environment states that explain success or failure.
- ReCreate combines experience storage and retrieval, reasoning–creating synergy, and hierarchical updates to convert execution evidence into reusable scaffold modifications.
- Across thirteen benchmarks and four domains, ReCreate shows consistent performance gains over human-designed agents and existing agent-creation methods.
2 Preliminaries
An agent scaffold is the editable software layer surrounding a base LLM, organized into complementary modules that support domain-specific execution. Domain agent creation constructs such a scaffold from a base model, verifiable tasks, and minimal domain information.
- An LLM agent consists of a base model ϕ and an editable scaffold A that makes the model executable in an environment.
- The scaffold includes role and object instructions defining the agent’s identity, domain priors, and high-level behavior.
- Process and strategy guide step-by-step reasoning, intermediate checks, and termination criteria.
- Action and tool modules expose reusable capabilities such as memory and search tools, while memory and retrieval control stored information access.
- Domain agent creation constructs a scaffold from a base LLM ϕ, a verifiable task distribution D, and minimal domain information I for reliable domain-level generalization.
3 Motivation: Experience Matters
Interaction experience exposes concrete behavioral patterns that can guide targeted scaffold changes. ReCreate uses these patterns to add rules, create validation tools, and modify workflows rather than relying only on outcome scores.
- Interaction experience records trajectories, execution results, and evaluation results, exposing agents’ action paths and reasoning processes.
- Experience can reveal missing domain rules, such as requiring train/validation splits instead of reporting training accuracy alone.
- Dedicated tools can replace repetitive or error-prone checks and ensure validations are applied consistently.
- Workflow failures may result from incorrect action ordering, as in committing changes before submission and producing an empty evaluation patch.
- Adding a pre-submission git diff –cached validation step improves SWE-bench pass rate by over 2%.
- These examples motivate an experience-driven optimizer that inspects execution traces and converts behavioral evidence into targeted scaffold updates.
4 Method
ReCreate formulates domain-agent creation as iterative scaffold optimization driven by interaction experience rather than performance metrics alone. Its agent-as-optimizer design retrieves evidence, converts it into scaffold updates, and aggregates local refinements into reusable domain patterns.
- Problem Formulation: ReCreate models domain-agent creation as a bi-level process in which a task agent solves tasks while ReCreate-Agent iteratively updates its scaffold.The process starts from minimal domain information and alternates task execution, feedback collection, and scaffold updates.
- Overall Workflow: ReCreate is designed to create domain agents from minimal seeds and is reported to achieve superior, low-cost adaptation across diverse domains.The framework is presented as an automated analogue of iterative human software refinement.
- Experience Storage and Retrieval: Interaction experience preserves trajectories, execution results, evaluation results, and environment context for evidence-based scaffold refinement.The stored experience can include codebases, databases, sandbox states, and the current scaffold, supporting selective inspection instead of loading everything.
- Reasoning–Creating Synergy: ReCreate-Agent iteratively reasons over retrieved experience to identify why an agent succeeds or fails and translate that evidence into scaffold changes.This reasoning–creating pipeline connects execution behavior with targeted updates rather than treating agent generation as black-box metric optimization.
- Hierarchical Local-to-Domain Updates: Hierarchical updates buffer instance-level candidate changes and synthesize them into domain-level patterns to reduce task-specific overfitting.The mechanism couples local update UPD with domain update DOMUPD, retaining generalized refinements for the final scaffold.
- Overall Workflow: Algorithm 1 initializes a scaffold from minimal information, derives local updates from sampled-task experience, evaluates on a held-out test set, and returns the final scaffold.The dataset is split into development and test sets, with development experience used for creation and the test set used for evaluation.
5 Experiments and Results
ReCreate is evaluated across four domains using benchmark comparisons, behavioral analysis, ablations, update dynamics, and cost-effectiveness studies. It consistently improves over competing approaches while showing that experience inspection and complementary update components support performance and generalization.
- Experimental Setup: ReCreate is evaluated across thirteen benchmarks spanning Software Engineering, Data Science, Mathematics, and Digital Assistance.The experiments use representative subsets including Django and SymPy for SWE and multiple DA-Code subsets for Data Science.
- Main Results: ReCreate improves the overall score by more than 5% over the strongest competing method across all benchmarks.The framework consistently exceeds human-designed scaffolds and self-evolving baselines, with especially clear gains on Data Science, Mathematics, and Digital tasks.
- Main Results: ReCreate improves the overall average by more than 7% over automated agent-generation methods without requiring predefined modules.Instead, it updates the scaffold directly from execution experience rather than searching or composing agents from a component pool.
- Behavioral Analysis: Inspection occupies roughly 65%–76% of ReCreate-Agent actions, compared with 24%–35% for creation across examined sub-domains.The agent therefore spends more actions locating and verifying evidence than proposing scaffold edits; evidence sources and update targets vary by domain.
- Observation-Level Ablation: Removing any experience component degrades performance, with full-trajectory removal causing the largest and most consistent drop across five domains.Execution and evaluation feedback provide outcome anchors, while the environment contributes runnable inspection and debugging support.
- Action-Level Ablation: Removing either the creation router or DOMUPD hurts performance, while the two components respectively support execution reliability and cross-task generalization.Without the router, updates focus on instance prompts; without DOMUPD, they become biased toward instance details.
- Reasoning-Level Ablation: ReCreate with Claude-opus consistently surpasses human-designed scaffolds, whereas ReCreate with gpt-5-mini fails to outperform them in most domains.The comparison indicates that stronger reasoning capability improves interpretation of interaction experience and translation into scaffold updates.
- Cost-Effectiveness: ReCreate reduces scaffold-optimization cost by roughly 36% to 82% compared with ADAS.The reported efficiency is attributed to convergence with a small development set and fewer iterations despite using a strong ReCreate-Agent.
6 Conclusion
ReCreate is an experience-driven framework that creates domain agents by optimizing scaffolds from interaction experience rather than relying solely on performance metrics. Its agent-as-optimizer design uses three components to ground scaffold updates in evidence and improve generalization across domains, including from minimal seed scaffolds.
- ReCreate creates domain agents by learning from interaction experience instead of relying solely on performance metrics.
- Its agent-as-optimizer design uses three components to support evidence-grounded scaffold updates and task generalization.
- Across diverse domains, ReCreate consistently improves performance over baselines, even when initialized with minimal seed scaffolds.
7 Limitations
The paper’s scope is limited to textual and code-level scaffold optimization, excluding infrastructure adaptation and base-model parameter updates. Related work spans module search, scaffold generators, automated tools, context learning, and memory evolution.
- Limitations: ReCreate optimizes textual and code-level scaffold elements, including prompts, reasoning strategies, and tool implementations.It does not extend to infrastructure adaptations such as harnesses and environments.
- Limitations: ReCreate does not update base-model parameters, leaving integration with model fine-tuning as a computationally expensive future direction.
- Related Work: Automated agent generation methods search predefined module spaces or train scaffold generators to propose agent designs.
- Related Work: ReCreate instead uses full interaction experience, including trajectories, logs, artifacts, and verifier outputs, to propose targeted scaffold edits.
- Related Work: Other research lines autonomously expand tool sets, optimize context, and evolve memory across episodes.
C Discussions
ReCreate frames domain-agent creation as agent-as-optimizer: an autonomous loop that inspects experience, reasons about failures, and updates shared scaffolds. Its parallel evolution pipeline synthesizes instance-level edits into reusable domain-level changes across benchmarks.
- Agent-as-optimizer: ReCreate changes optimization from prompting based on static context to doing through an Inspect → Reason → Optimize loop.The ReCreate-Agent retrieves trajectories, execution diffs, or evaluation results to diagnose failure modes.
- Comparison to Self-Evolve: Unlike self-evolving methods, ReCreate targets domain-level generalization through hierarchical updates rather than only instance-level success.
- Comparison to Self-Evolve: ReCreate can create agents from scratch and uses fine-grained execution evidence to produce grounded scaffold edits.
- Implementation: The parallel evolution pipeline runs task instances under a shared scaffold, records execution artifacts, and synthesizes per-instance updates into the next scaffold.
- Implementation: A DomainAdapter separates domain-specific loading, execution, and evaluation from evolution logic, which remains identical across five benchmarks.
- Implementation: ReCreate supports lazily loaded skill-style tools and controlled memory retrieval to expand capabilities without saturating the context window.
E Limitations of Human-designed Scaffolds
Human-designed scaffolds substantially affect what a fixed base model can solve. Across five agents using the same model, scaffold differences leave measurable recoverable headroom and alter the agent’s search behavior.
- 37 issues, or 20% of the union, are solved by the same model under some scaffold but missed by the strongest human-designed scaffold.The union contains 184 issues, while the strongest scaffold solves 147.
- Only 52 issues are solved by all five scaffolds, indicating that scaffold differences affect more than surface output guidance.The paper links this limited intersection to different search behavior, including what to inspect, which checks to run, and how to iterate.
- Even the best scaffold misses 37 union issues, while other scaffolds miss 65–82 issues solved by at least one alternative scaffold.
- These results show that a substantial portion of apparent model limitation under one scaffold is recoverable through another scaffold using the same base model.
F Detailed Information for Datasets
The experiments span software engineering, data-science code generation, mathematics, and interactive tool-use benchmarks. ReCreate remains competitive across sampling temperatures and generalizes across base models, outperforming human-designed scaffolds across evaluated domains.
- Datasets: The evaluation covers SWE-Bench Verified, DS-1000, AIME24/AIME25, MATH500 topic subsets, and AppWorld.These benchmarks test repository-level patching, executable code generation, mathematical reasoning, and multi-step tool use.
- Robustness: ReCreate maintains comparable performance across different sampling temperatures when using Claude Opus 4.5 as the ReCreate-Agent.The authors interpret this stability as evidence that strong models have approached stable domain-agent creation capability.
- Base-model generalization: ReCreate remains consistently better than baseline across all evaluated domains when Claude Opus 4.5 serves as both meta-agent and task agent.This analysis addresses whether the main gains arise solely from the selected ReCreate-Agent’s stronger reasoning capability.
- Base-model generalization: ReCreate beats human-designed scaffolds on 12/13 Gemini tasks and 13/13 GPT-4o-mini tasks, with average pass-rate gains of +8.3 and +8.7 points.The largest reported gain occurs on DS-1000, reaching up to +37.6 points.
I Significance Test
The study tests ReCreate against human-designed, self-evolve, and agent-generation baselines across 13 datasets containing 1,681 instances. ReCreate’s improvements are statistically significant at α = 0.05.
- Test design: McNemar paired significance tests compare ReCreate with the best baseline in each of three baseline categories across all 13 datasets.The analysis includes human-designed, self-evolve, and agent-generation baselines over N=1681 test instances.
- Results: ReCreate achieves statistically significant gains over the evaluated baselines at α = 0.05.The result is reported for comparisons against the best baseline in each baseline category.
J Sensitivity Analysis
Sensitivity analyses examine development-set size and composition, while accompanying cases illustrate how execution experience drives scaffold changes. Larger development sets improve performance, composition changes remain stable, and ReCreate converts experience into reusable scaffold components.
- Development-set sensitivity: Performance improves as the development-set size increases, although ReCreate already beats compared baselines using only 20 development samples.The authors describe larger development sets as providing more experience for scaffold updates and leaving room for further improvement.
- Development-set sensitivity: Changing the composition of 50-instance development sets leaves performance stable, with a standard deviation of 0.28.The analysis uses three randomly sampled development sets from SWE-bench Full excluding SWE-bench Verified.
- Django case study: The Django case evolves a minimal seed scaffold into system, instance, and memory templates, plus actionable memories and custom tools.The framework uses interaction experience to create domain-specific prompts, workflows, memory interfaces, and tools.
- Experience-driven updates: ReCreate’s optimizer inspects trajectories, diagnoses success and failure patterns, and evolves prompts, workflows, tools, and memory mechanisms.Its system prompt defines the agent’s mission as improving future performance on tasks in the same domain.
- Hierarchical synthesis: Batch synthesis aggregates instance-level scaffold modifications into a unified global scaffold intended to generalize across the domain.The synthesis prompt reviews proposed modifications from multiple instances before producing the global scaffold.