REVERE: Reflective Evolving Research Engineer

Balaji Dinesh Gangireddi; Aniketh Garikaparthi; Manasi Patwardhan; Arman Cohan

cs.SEMar 21, 2026

REVERE: Reflective Evolving Research Engineer

Authors: Balaji Dinesh Gangireddi, Aniketh Garikaparthi, Manasi Patwardhan, Arman Cohan

Organizations: TCS Research · Yale University

Abstract

Existing prompt-optimization techniques rely on local signals, causing poor generalization across tasks. In addition, they also rely on weak update mechanisms, such as full-prompt rewrites or unstructured merges, which cause knowledge loss and unstable adaptation. These limitations are magnified in research-coding workflows, which involve heterogeneous repositories and weak feedback, limiting abstraction and learning across tasks. We introduce Reflective Evolving Research Engineer (REVERE), a lightweight, self-adapting agent framework that learns from a Global Training Context, distills recurring cross-repository failure modes into reusable heuristics, and applies targeted, code-based edits to agent prompts. REVERE is evaluated across settings ranging from long-horizon to single-shot benchmarks, and improves over prior expert-crafted instructions by 4.50% on SUPER, 1.3% on ResearchCodeBench, and 4.89% on ScienceAgentBench. It does so at nearly 10x lower cost and 2.7x faster adaptation than existing prompt-optimization baselines, demonstrating that self-adapting agents with continual learning and global memory consolidation can meaningfully evolve their capabilities over time.

Figures & tables

Figure 1: The REVERE Framework A given task agent’s prompts, represented as editable Fields (System, Task, Cheatsheet), are optimized by a Reflector agent using a code-edit tool and guided by a Global Training Context and local, per-batch Evaluation Context.

Figure 2

Method	GT	SUPER (%)			RCB (%)	SAB (%)
Method	GT	Landmarks	Output Match	Overall	Accuracy	SuccessRate	CodeBERTScore
		long-horizon			single shot	interactive - ReAct
Baseline	–	24.70	9.30	17.00	27.80	20.90	67.50
SOTA †	–	35.80	14.80	25.30	31.90	23.50	88.20
Offline Adaptation
GEPA	✗	$0.00_{{\color[rgb]{0.6797,0.3867,0.3945}\scriptstyle-35.80}}$	$18.60_{{\color[rgb]{0.3867,0.6797,0.4648}\scriptstyle+3.80}}$	$9.30_{{\color[rgb]{0.6797,0.3867,0.3945}\scriptstyle-16.00}}$	$25.69_{{\color[rgb]{0.6797,0.3867,0.3945}\scriptstyle-6.21}}$	$17.42_{{\color[rgb]{0.3867,0.6797,0.4648}\scriptstyle+6.08}}$	$77.80_{{\color[rgb]{0.6797,0.3867,0.3945}\scriptstyle-10.94}}$

Table 1: Offline adaptation Results. Reported values are mean over 5 runs. ✓/✗ denote with/without ground-truth (GT) hints; (–) indicates inference-only.

+x

and

-x

showing gains and drops relative to Static SOTA results marked by † .

Method	SUPER Bench (%)			RCB (%)	SAB (%)
Method	Landmarks	Output Match	Overall	Accuracy	SuccessRate	CodeBERTScore
	long-horizon			single shot	interactive
Baseline - Test Tasks	24.70	9.30	17.00	27.80	20.96	67.50
Baseline - All Tasks	19.63	10.40	15.01	43.80	20.58	66.86
Online Adaptation
ACE - Test Tasks	26.80 ${{\color[rgb]{0.3867,0.6797,0.4648}\scriptstyle+2.10}}$	11.10 ${{\color[rgb]{0.3867,0.6797,0.4648}\scriptstyle+1.80}}$	18.95 ${{\color[rgb]{0.3867,0.6797,0.4648}\scriptstyle+1.95}}$	15.50 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-12.30}}$	11.30 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-9.66}}$	66.50 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-1.00}}$

Table 2: Online Adaptation results. All Tasks: performance on full benchmark; Test Tasks: Results on Test set tasks,

{{\color[rgb]{0.3867,0.6797,0.4648}\scriptstyle+x}}

and

{{\color[rgb]{0.6797,0.3867,0.3945}\scriptstyle-x}}

with respect to baseline.

Method	SUPER Bench (%)			RCB(%)	SAB (%)
Method	Landmarks	Output Match	Overall	Acc.	SuccessRate	CodeBERTScore
	long-horizon			single shot	interactive
REVERE	38.10	31.40	34.70	35.40	30.60	83.3
REVERE w / o Cheatsheet	30.70 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-7.40}}$	16.70 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-14.70}}$	23.70 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-11.00}}$	30.60 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-4.80}}$	20.90 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-9.70}}$	78.30 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-5.00}}$
REVERE w / o Auxiliary context	24.80 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-13.30}}$	24.10 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-7.30}}$	24.40 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-10.30}}$	31.90 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-3.50}}$	25.80 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-4.80}}$	79.80 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-3.50}}$
REVERE w / o Reflection history	25.90 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-12.20}}$	9.30 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-22.10}}$	17.60 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-17.10}}$	32.60 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-2.80}}$	22.50 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-8.10}}$	75.90 ${{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-7.40}}$

Table 3: Ablation on Offline Adaptation. Results correspond to a representative run,

{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle-x}}

indicates difference with respect to REVERE (full model)

Figure 3: Performance Analysis on the adapted agent on SUPER Overall metric. (A) Performance trajectory across iterations. (B) Per-task performance vs. total tool calls; orange = REVERE (GT), blue = Baseline. (C) Tool usage across variants (Baseline, GEPA, ACE, REVERE w/o GT, REVERE w/ GT). Note: GEPA iterations denote total candidates and are normalized to the axis scale; the blue marker indicates the Pareto-selected prompt.

Figure 4: Efficiency analysis of REVERE (A) Illustrates wall-clock time for offline adaptation of REVERE with baselines. (B) Compares computational cost (USD) on the SUPER task in an offline setting across REVERE, ACE, and GEPA, decomposed by architectural components. Dashed lines indicate sole adaptation cost. (C) Distribution of outcomes across code-edit tool calls in the ground-truth setting across all benchmarks.

Appendix figures & tables15 assets

Supplementary material from the paper’s appendix.

Appendix

Benchmark	Tasks	Task Input	Ground Truth	Cost P.T	Resource Limits (Calls / Exec Time)
Super-Expert	45	Query, GitHub repo, commit	Expert trajectory	$1–3	100 iters / 20 min
Setting up, and executing tasks from research repositories.
ResearchCodeBench	212	Paper, masked code, context files	Target code	$\sim$ $0.2	1 Call / 10 min
Code completion by implementing methodology from the paper.
ScienceAgentBench	102	Task instruction, dataset path	Gold Python file	$\sim$ $0.3	20 iters / 40 min
Scientific coding tasks spanning multiple domains for data-driven discovery.

Appendix

Table 4: Benchmark datasets used in our evaluation, with task counts, task inputs, ground-truth (GT) content provided to REVERE under the GT-assisted offline setting, approximate per-task inference cost (Cost P.T), and per-task resource limits set for each task (no. of LLM calls and time for agent + evaluation execution). Costs are estimates based on gpt-4.1.

Method	GT	SUPER Bench (%)			RCB (%)	ScienceAgentBench (%)
Method	GT	Landmarks	Output Match	Overall	Accuracy	SuccessRate	CodeBERTScore
		long-horizon			single shot	interactive - ReAct
Offline Adaptation
GEPA	✗	$0.0_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 0.0}}$	$18.6_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 0.85}}$	$9.30_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 0.42}}$	$25.69_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 0.00}}$	$17.42_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 1.35}}$	$77.80_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 2.33}}$
GEPA	✓	$1.93_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 2.15}}$	$2.60_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 1.0}}$	$2.27_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 0.99}}$	$10.44_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 3.12}}$	$17.09_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 2.70}}$	$78.53_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 1.84}}$
ACE	✗	$19.53_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 10.01}}$	$18.51_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 3.62}}$	$19.02_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 3.2}}$	$21.99_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 3.28}}$	$8.60_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 7.27}}$	$53.48_{{\color[rgb]{0.418,0.4453,0.5}\scriptstyle\pm 8.08}}$

Appendix

Table 5: Offline Adaptation Results; RCB: ResearchCodeBench; with (✓) and without (✗) ground-truth (GT) Hints,

\pm

: standard deviation (Std Dev) across 5 runs.

Figure 5: Welch t-test : REVERE *** $p<0.001$ , ** $p<0.01$ ; * $p<0.05$ ; $ns$ $p\geq 0.05$ ; $t>0$ means REVERE has higher mean

Figure 6: Offline Adaptation score with 95%

CI

, where GT ✓= Adapted with ground-truth hints; ✗= Adapted with-out ground-truth hints;

Figure 7: Prompt Analysis : (A) Illustrates prompt component growth in token length across iterations on the SUPER benchmark, comparing REVERE components , GEPA query, and ACE cheatsheet. (B) Illustrates final adapted prompt lengths (in tokens) across benchmarks, used in offline adaptation results with ground truth.

Method	Levenshtein Retention	Git Retention	Semantic Similarity
GEPA – full prompt rewrite	0.11	0.03	0.62
ACE – incremental delta updates	0.86	0.92	0.99
REVERE – targeted edits	0.84	0.89	0.94

Appendix

Table 6: Prompt retention across consecutive adaptation iterations on SUPER. GEPA’s near-zero retention reflects the semantic drift from full-prompt rewriting. ACE’s near-perfect retention reflects its append-only design: new content is structurally and semantically similar to existing content, so little changes between iterations. REVERE’s intermediate retention (

\sim

0.85–0.95) reflects targeted restructuring: stable content is preserved while only relevant portions are modified.

Method	split	join	replace	append	extend	insert	+=	strip	startswith	endswith	find	index	count
REVERE (full)	63.1	62.7	7.5	6.0	0.0	45.9	14.2	29.9	18.7	0.7	6.7	3.4	0.0
w/o GTC	75.7	73.5	4.3	14.3	2.6	53.5	11.7	24.8	12.6	0.9	3.0	9.6	0.0
w/o Auxiliary context	59.9	58.3	11.5	12.0	0.5	34.4	11.5	32.8	14.1	4.2	1.6	3.6	0.5
w/o Reflection history	65.9	65.5	3.7	6.4	0.4	51.3	16.5	33.0	19.9	0.7	4.1	4.5	0.0

Appendix

Table 7: Percentage of code-based edits using each Python string operation, for REVERE (full model) and its ablation variants (SUPER, ground-truth setting). The diverse operation mix – spanning restructuring ( split , join ), targeted correction ( replace ), and expansion ( insert , append ) – confirms genuine restructuring rather than simple accumulation, and this pattern holds across ablations, indicating it is not an artifact of any single GTC component. For reference, GEPA’s full rewrites are functionally equivalent to 100% replace operations, and ACE’s append-only curator uses 100% append / += operations. w/o Cheatsheet is omitted, as it only removes the cheatsheet field at test time and does not alter the training-time edit mechanism.

Row	Task Model	Reflector	Same/Cross	Test Subset (27)	Full Set (45)
1	GPT-5.4	(unadapted)	–	48.40	47.56
2	GPT-5.4-mini	(unadapted)	–	41.99	43.27
3	Gemini-3-Flash	(unadapted)	–	38.07	37.09
4	GPT-5.4-mini	GPT-5.4-mini	Same	33.66	39.12
5	GPT-5.4-mini	GPT-5.4	Cross	51.48	48.85
6	GPT-5.4-mini	GPT-5.2	Cross	50.00	47.07

Appendix

Table 8: Heterogeneous Reflector/task-model configurations under offline adaptation. The Same/Cross column indicates whether the Reflector and task model belong to the same model family. Rows 1–3 report unadapted baselines for each task model. Rows 4–6 isolate Reflector strength on a weak task model (GPT-5.4-mini). Row 7 reports the same-family Gemini-3-Flash configuration. Rows 8–11 isolate Reflector strength on a strong task model (GPT-5.4); row 10 ( bolded ) pairs GPT-5.4 as the task model with Gemini-3-Flash as the Reflector, a cross-family configuration where the task model and Reflector come from different AI labs.

Category	Description	Found Solution
Dependencies	Build/install failures or missing libraries for training/fine-tuning.	• Use pip install --only-binary=:all: ... • Pin numpy / sklearn / Cython to highest available wheel
Environment	Environment/version mismatches causing runtime errors.	• Enumerate/validate environment variables and dependency availability • Debug versions/signatures: inspect.signature(func) • Reconfigure environment: if no gpu available configure cuda() to cpu
Configuration	Wrong CLI args/configs or missing scripts.	• Verify argument names: train_file , validation_file , data_dir • Enumerate run_*.sh candidates and match closest
Data - Acquisition	Missing datasets or incorrect asset content.	• Inspect README/scripts; attempt wget / gdown / curl • Inspect content directly using head , cat , less , file
Data - Preprocessing	Incompatible dataset schema/fields or container formats.	• Write wrapper to rename or transform fields • Decompress .csv ; check for embedded .jsonl / .tsv
Execution Issues	Scripts produce no metrics or import errors.	• Check output directory and config paths • Fix hardcoded outputs • Patch imports/ sys.path ; test package and script entrypoints

Appendix

Table 9: Autonomously identified Failures and Solutions of base prompt across research repositories by REVERE .

Figure 8: Evolution of the prompt $\mathcal{F}_{x}$ across online adaptation iterations. Snapshots from the first, twelfth, thirtieth, and final iterations illustrate how semantically grouped instruction capsules are incrementally refined. Additions (green), modifications (orange), and removals (red) show that adaptation proceeds via structured accumulation rather than prompt rewriting.

Adaptation	Start Prompt	Full Set (45 Tasks)			Test Set (27 Tasks)
		Output Match	Landmarks	Overall	Output Match	Landmarks	Overall
Unadapted	Baseline	42.60	52.50	47.60	40.70	56.00	48.40
Unadapted	Counter-instructed	35.10	44.70	39.90	34.40	45.20	39.80
REVERE	Baseline	46.90	71.70	59.30	46.80	67.00	56.90
REVERE	Counter-instructed	43.70	68.30	56.00	41.20	69.60	55.40

Appendix

Table 10: Online adaptation from a counter-instructed starting prompt vs. the standard baseline prompt, on SUPER using GPT-5.4.

Figure 9: Offline adaptation trajectory per task on the SUPER benchmark (Judge Score). Each point represents a single test task plotted against its total tool calls. Labels denote adaptation stage: base = baseline (pre-adaptation), 0--3 avg = average Judge Score across epochs 0–3, and 4 = final adapted score at epoch 4. Arrows trace the trajectory of each task from baseline through adaptation. Tasks are colored by their outcome group: green = exploratory improvement, red = declining, blue = steady improvement; gray points denote training-split tasks. The bottom panel shows the methodological domain of each task (e.g., parameter-efficient training, NLI/QA, prompt-based), with test tasks highlighted in their outcome color to reveal which domain clusters benefit from adaptation and which do not.

Metric	Static SOTA	REVERE
Avg. CBS on passing programs only	84.2	77.0
Programs that fail to run (of 102)	19	9

Appendix

Table 11: CodeBERTScore computed only on programs that pass (SR

=1

), and count of programs that fail to execute, on ScienceAgentBench.

Figure 10: Prompts from SuperBench and ResearchCodeBench used for baseline and static SOTA. Note : The cheat sheet used in all benchmarks is empty, as illustrated by an example in the SuperBench prompts. Note : Minor modifications are made to the original author-provided prompts to ensure compatibility with the implemented system.

Figure 11: Prompts for ResearchCodeBench and ScienceAgentBench . Note : Minor modifications are made to the original author-provided prompts to ensure compatibility with the implemented system.

LLM Agent Self-Improvement

Large language model agent self-improvement studies how agents use experience and feedback to improve their behavior, tools, and workflows.

See all 273 papers

Coding Agents are Strong Prompt Optimizers
Aug 13, 2026Agamdeep Singh, Srishti Gautam, Priyanshu Gupta +3Automatic Prompt Optimization Coding Agents
Microsoft
SePO: Self-Evolving Prompt Agent for System Prompt Optimization
Jun 3, 2026Wangcheng Tao, Han Wu, Weng-Fai WongLLM Agent Self-Improvement Automatic Prompt Optimization
National University of Singapore · City University of Hong Kong
Recursive self-improvement of AI research agents
Sep 22, 2026Dhruv Srikanth, Bingchen Zhao, Dixing Xu +2LLM Agent Self-Improvement Recursive Self-Improvement
Weco AI

Aug 13, 2026J/K move · Enter open · S save

Coding Agents are Strong Prompt Optimizers

Agamdeep Singh, Srishti Gautam, Priyanshu Gupta, Nikita Mehrotra+2

Microsoft

Automatic Prompt Optimization Coding Agents LLM Agent Skill Learning

Open paper AskPDF arXiv

Search-based prompt optimizers improve prompts through iterative search: they propose edits, execute fresh rollouts, score the resulting trajectories, and retain only edits that improve a validation metric. We show that this optimization loop is unnecessary. Given only a static corpus of agent trajectories, an off-the-shelf coding agent can directly synthesize an optimized prompt, requiring neither environment access nor validation data. We call this approach Coding-Agent Skill Distillation (CASD). The key insight is reflection scope. Rather than reasoning over a small batch of trajectories at each optimization step, the coding agent writes and executes analysis code to compute corpus-wide statistics, identifies systematic failure modes, inspects representative episodes, and distills the resulting insights into behavioral rules. Across four agentic benchmarks (ALFWorld,

τ^2

-bench retail and telecom, and SpreadsheetBench-Verified), under matched data access, a single CASD pass outperforms GEPA, a state-of-the-art reflective prompt optimizer, on three of four benchmarks and outperforms validation-gated reflective search (SkillOpt) on all four, improving the unoptimized baseline by 16.6 percentage points on average versus 10.9 for GEPA and 5.3 for SkillOpt. Because CASD performs a single offline analysis pass rather than iterative search, producing an optimized prompt costs approximately $1.60---over

22\times

cheaper than validation-gated search. Even when competing methods are granted additional validation data and unrestricted environment access, CASD remains ahead on two of four benchmarks. These results suggest that corpus-scale statistical reflection is a viable alternative to iterative search for prompt optimization.

Abstract

LLM Agent Self-Improvement

Explore similar work

Coding Agents are Strong Prompt Optimizers

SePO: Self-Evolving Prompt Agent for System Prompt Optimization

Recursive self-improvement of AI research agents