💻 computer science

ReCreate: Reasoning and Creating Domain Agents Driven by Experience

The paper introduces ReCreate, an experience-driven framework that automatically generates and adapts domain-specific agents by leveraging interaction histories through an agent-as-optimizer paradigm, outperforming both human-designed and existing automated methods.

Original authors: Zhezheng Hao, Hong Wang, Jian Luo, Jianqing Zhang, Yuyan Zhou, Qiang Lin, Can Wang, Hande Dong, Jiawei Chen

Published 2026-04-29

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhezheng Hao, Hong Wang, Jian Luo, Jianqing Zhang, Yuyan Zhou, Qiang Lin, Can Wang, Hande Dong, Jiawei Chen

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: Building Robots is Hard Work

Imagine you want to build a specialized robot to fix broken cars, another to bake perfect cakes, and a third to solve math puzzles. Right now, every time you want a new robot for a new job, a human expert has to sit down and write a very detailed instruction manual (called a "scaffold") for it. They have to tell the robot exactly how to think, what tools to use, and what steps to take.

This is slow, expensive, and hard to scale. If you want a robot for 100 different jobs, you need 100 different human-written manuals.

The Old Way: Guessing and Checking

Some researchers tried to automate this. They built a "meta-robot" that tries to write these manuals. But the old method was like playing a game of "Hot or Cold."

The meta-robot writes a manual.
It tests the robot.
It gets a score (e.g., "You got 60% right").
The score is the only feedback. It doesn't say why the robot failed. Was it the wrong tool? Did it forget a step? Did it look at the wrong file?

Because the meta-robot didn't know why it failed, it had to guess blindly, trying millions of random changes until it got lucky. This took a lot of computer power and money.

The New Way: ReCreate (The "Experience-Driven" Mechanic)

The authors of this paper propose ReCreate. Instead of just looking at the final score, ReCreate acts like a master mechanic who watches the robot work, sees exactly where it stumbled, and fixes the manual based on that evidence.

Think of it like this:

Old Way: You take a test, get a "C," and the teacher just says, "Try harder next time." You don't know which questions you got wrong or why.
ReCreate: You take a test, get a "C," and the teacher pulls out the video recording of you taking the test. They point to the specific moment you got confused, say, "Ah, you didn't read the instructions carefully," and then rewrites the instruction manual to prevent that specific mistake next time.

How ReCreate Works (The Three Magic Tools)

ReCreate uses a special "Optimizer Agent" (a super-smart AI) that goes through three steps to improve the robot's manual:

1. The Detective (Experience Storage & Retrieval)
When a robot fails, ReCreate doesn't just throw away the attempt. It saves the entire "movie" of what happened: what the robot thought, what tools it clicked, and where it got stuck.

Analogy: Imagine a detective who doesn't just look at the crime scene, but has access to the suspect's entire diary, phone logs, and security footage. When the robot fails, ReCreate searches this "diary" to find the exact moment things went wrong.

2. The Editor (Reasoning–Creating Synergy)
Once the Detective finds the problem, the Editor steps in. It reads the evidence and decides how to fix the manual.

Analogy: If the robot kept forgetting to check if a file was empty, the Editor doesn't just say "be better." It adds a specific new rule to the manual: "Always check if the file is empty before opening it." Or, if the robot kept doing the same boring math over and over, the Editor writes a new "tool" (a script) to do that math automatically.

3. The Teacher (Hierarchical Updates)
This is the most important part. Sometimes a robot learns a trick that only works for one specific puzzle. ReCreate makes sure the robot doesn't get "stuck" on that one trick. It looks at many different failures and asks, "Is this a one-time mistake, or is this a pattern?"

Analogy: If a student fails a math test because they forgot to carry the one, the teacher doesn't just tell them to "do better on that one test." The teacher realizes the student has a pattern of forgetting to carry numbers and updates the student's entire study guide to include a permanent rule about carrying numbers. ReCreate turns specific fixes into general rules that work for the whole domain.

The Results: From Seed to Master

The paper tested ReCreate in four different worlds:

Software Engineering: Fixing bugs in code (like GitHub).
Data Science: Cleaning data and making charts.
Math: Solving complex math problems.
Digital Assistance: Managing apps and digital tasks.

They started with a "seed" manual that was very basic—almost empty.

The Result: ReCreate took these tiny, weak manuals and evolved them into powerful, specialized agents.
The Score: In almost every test, the agents created by ReCreate performed better than agents designed by human experts. They also performed better than other AI methods that tried to build agents automatically.

Why It Matters (According to the Paper)

The paper claims that by letting AI learn from its own "experience" (the detailed logs of what it did) rather than just a final score, we can automatically build specialized robots for any job. It's cheaper, faster, and creates smarter agents than the old "guess and check" methods.

In short: ReCreate is a system that teaches AI agents by showing them their own mistakes in detail, then rewriting their instruction manuals to ensure they never make those same mistakes again. It turns a "black box" of trial-and-error into a "white box" of clear, logical improvement.

1. Problem Definition

The paper addresses the challenge of Domain Agent Creation: the automatic construction of specialized LLM agents for specific real-world domains (e.g., software engineering, data science, mathematics) starting from minimal seed information.

Current Limitation: Most practical agents are manually designed by humans. This is labor-intensive and difficult to scale because different domains require distinct knowledge, priors, and workflows.
Limitations of Existing Automation: Recent automated agent generation methods (e.g., ADAS, AgentSquare) treat agent creation as a black-box optimization problem. They rely solely on final performance metrics (e.g., pass/fail rates) to guide updates.
- Blindness: They lack insight into why an agent failed, leading to inefficient trial-and-error.
- Cost: They require large-scale evaluations for every candidate scaffold, resulting in high computational and financial costs.
- Overfitting: They often struggle to generalize from specific task instances to broader domain patterns.

2. Methodology: The ReCreate Framework

ReCreate proposes a white-box, experience-driven optimization paradigm. Instead of relying on scalar scores, it leverages the full interaction experience (execution trajectories, environment states, logs, and evaluation results) to iteratively refine agent scaffolds.

Core Design: Agent-as-Optimizer

ReCreate introduces an Agent-as-Optimizer design where a "ReCreate-Agent" (a meta-agent) acts as an autonomous engineer. It inspects the execution history of a task agent, diagnoses failures, and edits the agent's scaffold. The framework consists of three key components:

Experience Storage and Retrieval Mechanism:
- Stores full interaction episodes (trajectories, execution outputs, evaluation logs, and environment context like codebases).
- Uses an evidence retriever to index critical events (errors, failing tests). This allows the ReCreate-Agent to jump directly to relevant context rather than processing massive logs linearly, enabling on-demand inspection.
Reasoning–Creating Synergy Pipeline:
- Reasoning (Inspection): The ReCreate-Agent analyzes the retrieved evidence to determine the root cause of success or failure (e.g., missing validation steps, inefficient tool usage, wrong workflow order).
- Creating (Modification): Based on the diagnosis, the agent decides which scaffold component to edit. The scaffold is decomposed into four editable modules:
  - Role & Object: System instructions and domain priors.
  - Process & Strategy: Reasoning workflows and termination criteria.
  - Action & Tool: Available tools and scripts.
  - Memory & Retrieval: Memory management strategies.
- A Creation Router guides the agent to select the appropriate edit (e.g., "Add a rule," "Create a new tool," "Modify the workflow") grounded in specific evidence.
Hierarchical Local-to-Domain Updates:
- Instance Level: The agent generates candidate updates ( $\Delta A$ ) for specific tasks, accompanied by justifications. These are buffered rather than immediately applied.
- Domain Level: A synthesis step aggregates these instance-level proposals to extract reusable domain patterns. This filters out task-specific noise and prevents overfitting, ensuring the final scaffold generalizes across the domain.

Workflow (Algorithm 1)

Initialize a minimal scaffold ( $A_0$ ) from domain info ( $I$ ).
Run the agent on a batch of development tasks.
Collect interaction experience ( $\tau$ , execution results, evaluation results).
The ReCreate-Agent inspects failures/successes and proposes local updates.
Local updates are synthesized into a global domain update.
Repeat until convergence or max iterations.

3. Key Contributions

ReCreate Framework: A novel framework that shifts agent creation from black-box metric optimization to white-box, experience-driven reasoning.
Agent-as-Optimizer Paradigm: A design that enables an LLM to autonomously debug and evolve other agents by interpreting execution traces and environment states, rather than just optimizing prompts.
Comprehensive Evaluation: Demonstrated superior performance across 13 benchmarks in 4 domains (Software Engineering, Data Science, Mathematics, Digital Assistance), outperforming both human-designed agents and existing automated generation methods.

4. Experimental Results

The authors evaluated ReCreate using gpt-5-mini as the task agent and claude-4.5-opus as the ReCreate-Agent.

Performance Gains:
- ReCreate consistently outperformed human-designed scaffolds and self-evolving baselines (e.g., LIVE, OPRO, ExpeL) across all domains.
- Average Improvement: +6.55% over the runner-up in Software Engineering (SWE), +6.60% in Data Science (DS), +4.01% in Math, and +2.63% in Digital Assistance.
- Comparison to Generation Methods: Outperformed automated generation methods (ADAS, AgentSquare) by an average of 7%, highlighting the value of using rich interaction experience over scalar scores.
Cost Efficiency:
- ReCreate reduced optimization costs by 36% to 82% compared to ADAS. It achieves this by converging faster using rich signals from interaction experience, requiring fewer iterations and a smaller development set (only ~20 samples).
Ablation Studies:
- Experience Components: Removing full trajectories caused the largest performance drop, proving that step-by-step reasoning traces are crucial for diagnosis.
- Reasoning Capability: Using a weaker ReCreate-Agent (gpt-5-mini) failed to outperform human designs in most domains, indicating that strong reasoning capabilities are essential for interpreting experience and generating effective edits.
- Hierarchical Updates: Removing the domain-level synthesis (DOMUPD) led to overfitting and lower generalization.

5. Significance and Implications

Automation of Expertise: ReCreate demonstrates that LLMs can automate the labor-intensive process of designing specialized agent scaffolds, potentially replacing human experts in creating domain-specific workflows.
Shift in Optimization Paradigm: It moves the field from "Optimization by Prompting" (static, linear) to "Optimization by Doing" (dynamic, inspect-reason-optimize loops).
Generalizability: The framework is domain-agnostic. It successfully created specialized agents for software engineering (fixing GitHub issues), data science (generating code), and math problems starting from minimal seeds.
Scalability: By leveraging experience-driven updates, ReCreate offers a scalable path to building robust agents for open-world scenarios where manual engineering is infeasible.

In conclusion, ReCreate establishes that interaction experience is a richer and more effective signal for agent creation than performance metrics alone, enabling the automatic synthesis of high-performing, specialized agents that rival or exceed human-designed solutions.