MetaShare: Failure-Aware Collective Self-Improvement for Open-Ended Agents

Vishal Bhutani; Prasang Gupta; Sumanth Chundru; Kevin Paul

cs.MAOct 15, 2026

MetaShare: Failure-Aware Collective Self-Improvement for Open-Ended Agents

Authors: Vishal Bhutani, Prasang Gupta, Sumanth Chundru, Kevin Paul

Organizations: PricewaterhouseCoopers (PwC)

Abstract

Humans often learn fastest not by repeating success, but by remembering which failures not to repeat. Open-ended self-improving agents can share experience across lineages, as in GEA, or edit their own improvement mechanisms, as in DGM-Hyperagents, yet failed improvement attempts are rarely retained as reusable cross-branch knowledge, and search can collapse onto redundant strategies. We introduce MetaShare, a failure-aware framework that records successful and unsuccessful agent modifications together with signed performance deltas. Before each generation, MetaShare retrieves diverse high-performing strategies alongside high-confidence failures from other lineages, letting agents reuse effective mechanisms while avoiding known dead ends. A task-blind auditor periodically injects absent or underrepresented mechanism categories, while embedding-based de-ranking limits redundancy during retrieval. Multiple meta-agents propose modifications in parallel at heterogeneous temperatures behind a deterministic selector that gates applicability, scope, compilability, and size. Experiments across paper review, coding, math grading, robotics reward design, and financial audit-risk assessment show that MetaShare's median matches or exceeds DGM-Hyperagents' final performance and reaches its own best-performing agent in 1.7--2.9 $\times$ fewer evolution iterations.

Figures & tables

Figure 1: MetaShare converts evaluated outcomes into signed, reusable lessons. A measured scaffold change becomes a positive (helped, reuse) or negative (hurt, avoid) lesson, passed to generation $t{+}1$ to exploit gains and skip known failures.

Figure 2: MetaShare architecture. Top : one generation—select parent $a_{p}$ , build the signed-guidance context $C_{g}$ (adopt/avoid/must-try), let $K$ meta-agents propose patches, admit one through a deterministic gate, then apply and score it to yield $a_{c}$ . Bottom : each evaluated modification becomes a signed record in a bounded cross-lineage pool; failure-aware diverse retrieval rebuilds $C_{g}$ , and a task-blind auditor injects Must-Try classes from a scrubbed digest.

Figure 3: MetaShare vs. DGM-H across all evaluation domains. Left : final score (

\uparrow

); right : generation of the selected best (

\downarrow

), with per-domain speed-up. Error bars are 95% bootstrap CIs where available. DGM-H values for paper review, robotics, and IMO (scores, intervals, and generations) are as reported by Zhang et al. (2026) , not rerun; the Polyglot and audit-risk DGM-H bars are our five-run reimplementation. Dashed lines mark the static, no-self-improvement baseline ( Zhang et al., 2026 ; Luong et al., 2025 ) (none for Polyglot or audit risk). NMAE (

\downarrow

) is

0.175

vs.

0.157

(IMO-full) and

0.357

vs.

0.312

(audit risk). For Polyglot both arms hold the task-agent on o3-mini here, with the DGM-H baseline rerun on a Sonnet-4.5 meta-agent (Sonnet-3.5 deprecated); Sec. 5.2 analyzes model-routing separately.

Domain (budget)	DGM-H	Ours	Ratio
Paper Review (100)	83M	52M	$0.6\times$
Polyglot (100) †	135M	163M	$1.2\times$
IMO-grading (200)	88M	213M	$2.4\times$

Table 1: Estimated total token count (millions, input

+

output), MetaShare (Ours) vs. the DGM-H baseline, following DGM-H’s protocol ( Zhang et al., 2026 ) . Baseline self-modification is DGM-H’s reported estimate (

\sim

33M tokens per 100 iterations, scaled to each budget); totals are medians over five runs to the selected checkpoint; Ratio is Ours

/

baseline. † Polyglot baseline re-measured on the matching model (Claude 4.5) for parity.

Configuration	Train	Val	Gens $\downarrow$
Success only	0.68 [.68,.69]	0.69 [.69,.72]	63
+ failure ( $k{=}1$ )	0.70 [.69,.70]	0.73 [.72,.74]	60
+ parallel ( $k{=}3$ )	0.77 [.76,.79]	0.78 [.76,.83]	48
+ auditor (full)	0.81 [.79,.83]	0.83 [.80,.88]	36
Pool disabled, $k{=}3$	0.70[.70,.71]	0.72 [.72,.73]	55

Table 2: Component ablation on paper review: best-so-far accuracy (median over five paired runs; 95% bootstrap CI) on train and validation—also the checkpoint-selection split—and generations-to-best on validation (Gens

\downarrow

). The first four rows add one component at a time; the last is the compute-matched reference, with the pool disabled at the full system’s proposal count (

k{=}3

Configuration	Accuracy	Gens $\downarrow$
w/o auditor	0.30 [.30,.31]	80
Shuffled failures	0.38 [.37,.39]	65
Full ( $k{=}3$ , hetero temps)	0.45 [.44,.46]	42
Pool disabled, $k{=}3$	0.28 [.28,.30]	100 †

Table 3: Single-component removals from full MetaShare on the 225-task Polyglot benchmark (median over five runs, 95% bootstrap CI; Gens

\downarrow

= generations to best). The last row is the compute-matched reference—pool disabled at

k{=}3

—which lands on the

k{=}1

DGM-H baseline. All arms start from GPT o3-mini. † Best reached at the end of the 100-generation budget, so a lower bound.

Appendix figures & tables14 assets

Supplementary material from the paper’s appendix.

Appendix

Parameter	Value	Role
$C$	$10$ generations	cadence of the task-blind audit; an audit also requires at least five records in the pool
Pool bound	$100$ records	capacity of the strategy pool; on overflow the records with the largest $\|\delta_{i}\|$ are retained, so the strongest positive strategies and the most informative failures both survive eviction
$K_{s}$	$5$	positive retrieval budget
$K_{f}$	$5$	failure retrieval budget
Token budget	$20k$	approximate size of the retrieved context
Embedding model	text-embedding-ada-002	embeds each record for the de-ranking step

Appendix

Table 4: Memory and retrieval settings that take the same value in every domain

Domain	$\gamma$	$\tau$	$K$	$\theta$
Paper review	$0.0$	$0.92$	3	$[0.0,\,0.35,\,0.7]$
Polyglot coding	$0.4$	$0.92$	3	$[0.0,\,0.45,\,0.75]$
IMO grading	$0.0$	$0.85$	3	$[0.0,\,0.35,\,0.75]$
Robotics reward	$0.0$	$0.85$	3	$[0.0,\,0.35,\,0.75]$
Audit risk	$0.0$	$0.85$	3	$[0.0,\,0.3,\,0.7]$

Appendix

Table 5: Per-domain settings: the staged-evaluation threshold

\gamma

, the de-ranking threshold

\tau

, the number of parallel meta-agents

K

and their decoding temperatures

\theta

, as recorded in the run metadata

Setting	Value
Audit model	Claude Sonnet-4.5
Temperature	0.0
Max output tokens	8000
Pool entries per audit	up to 56; a per-call cap on the size of the digest, below the pool bound of Table 4
Diff truncation	2500 characters per entry, added lines only
Requested output	numbered list of 6–10 mechanism categories

Appendix

Table 6: Auditor configuration.

Label	Definition
prompt_engineering	Changes to system prompts, instructions, or personas
tool_creation	Adding new tools or capabilities
memory_system	Adding performance tracking, history, or knowledge bases
evaluation_logic	Changes to how the meta agent evaluates performance
self_modification	Meta agent changing its own improvement logic
structural_refactor	Reorganizing code without functional change

Appendix

Table 7: The fixed mechanism-type vocabulary. Every record carries exactly one of these six labels.

Function	Returns	Passes when
scope_ok(diff)	$\{0,1\}$	the diff modifies at least one allowed file
applies(diff, repo)	$\{0,1\}$	git apply --check succeeds against the parent repository, i.e. the patch is applicable without altering the working tree
compiles_after(diff, repo)	$\{0,1\}$	the allowed files, copied into a scratch repository with the diff applied, all pass python -m py_compile
size_band(diff)	$\{0,1\}$	added plus removed lines fall within $[\text{MIN\_LINES\_CHANGED},\text{MAX\_LINES\_CHANGED}]$

Appendix

Table 8: The four axes of the admissibility gate.

Component	Specification
CPU nodes	$5\times$ Azure Standard D8as v5: 8 vCPU, 32 GiB memory, 2 threads per core
GPU nodes	$5\times$ Azure Standard NC8as T4 v3: 8 vCPU, 56 GiB memory, 1 thread per core, NVIDIA T4
Operating system	Linux, Ubuntu 24.04 LTS
Python	3.12.3
Container runtime	Docker; each of the $K$ parallel proposals runs in its own container and repository copy, and each domain evaluation runs in its own container
Key libraries	litellm 1.74.9 (all model calls), docker 7.1.0 (sandboxes), GitPython 3.1.44 (diff extraction and patch application), datasets 3.6.0, pandas 2.3.2, sympy 1.14.0, backoff 2.2.1, requests 2.32.4

Appendix

Table 9: Computing infrastructure used for the reported experiments.

#	Inherent Risk Factor	Definition
1	Account nature	Whether the account is routine and recurring, or unusual and non-recurring.
2	Misstatement history	Whether the account has a history of proposed or booked audit adjustments.
3	Fraud indicators	Whether fraud risk factors, or prior instances of fraud, are present in the account.
4	Control deficiency history	Whether significant deficiencies or material weaknesses have historically related to the account, as opposed to lesser or no identified deficiencies.
5	Transaction volume and value	The number of transactions processed through the account and their monetary magnitude.
6	Transaction complexity	How complex the transactions processed through the account are.

Appendix

Table 10: Definitions of the 15 Inherent Risk Factors (IRFs).

Split	Clients	High	Medium	None	Total
Train	8	457	420	2344	3221
Validation	2	132	127	506	765
Test	5	130	105	675	910
Total	15	719	652	3525	4896

Appendix

Table 11: Class balance of the audit-risk labels by split. Each count is one labelled assessment of a single account group against a single factor.

Run	Gens	Accuracy	NMAE	Gens	Accuracy	NMAE
	DGM-H			MetaShare
1	46	0.448	0.309	30	0.512	0.342
2	42	0.445	0.366	24	0.544	0.305
3	44	0.450	0.370	26	0.550	0.309
4	45	0.452	0.371	27	0.553	0.302
5	43	0.456	0.369	25	0.560	0.302

Appendix

Table 12: Audit-risk results per run on the held-out test split. Accuracy is aggregated as the median over runs and NMAE as the mean, as described above; lower NMAE is better.

Risk factor	DGM-H	MetaShare	$\Delta$
Account nature	0.10	0.06	$-0.04$
Misstatement history	1.00	1.00	$+0.00$
Fraud indicators	0.04	0.57	$+0.53$
Control deficiency history	1.00	1.00	$+0.00$
Transaction volume and value	0.30	0.05	$-0.25$
Transaction complexity	0.01	0.15	$+0.14$

Appendix

Table 13: Accuracy per risk factor on the held-out test split, as the median over five runs.

\Delta

is MetaShare minus DGM-H.

Run	Best accuracy	Generations to best
1	0.902	8
2	0.907	9
3	0.912	10
4	0.917	10
5	0.922	10
Median	0.912	10

Appendix

Table 14: Per-run Polyglot results on the small+medium set (60 tasks), with Claude Sonnet-4.5 as both task- and meta-agent, matching the GEA configuration. “Generations to best” is the iteration at which the reported score first appears.

Figure 4: Best score so far against evolution iteration on the 60-task small+medium Polyglot subset. The MetaShare curve is the best of our five runs, ending at

0.922

; the median over the five is

0.912

(Table 14 ). The DGM and GEA curves are digitised from the published figure in Weng et al. (2026) : plateau levels and the iterations at which they begin were read off the plot, so they are approximate and indicate shape rather than exact values. Dashed line: reported open-source state of the art. Note that the initialisations differ—both baselines begin from an agent already scoring

\approx 0.38

, whereas MetaShare begins from an agent that solves nothing.

Run	DGM-H	MetaShare	$\Delta$
1	21	27	$+6$
2	22	26	$+4$
3	21	27	$+6$
4	22	27	$+5$
5	21	24	$+3$
Median	21	27	$+6$

Appendix

Table 15: Cumulative unique Polyglot tasks solved per run, out of the 60-task small+medium subset, over a matched 100-generation budget.

Mechanism type	Gen. 1–19 (pre-audit)	Gen. 20–24 (post-audit)
evaluation_logic	12	1
prompt_engineering	7	0
tool_creation	0	1
structural_refactor	0	1
memory_system	0	0
self_modification	0	0

Appendix

Table 16: Mechanism types in the pool of one Polyglot run that begins on GPT o3-mini, before and after the generation-20 audit fired. Types are assigned by the post-hoc classifier of Sec. B.6 ; the six available types are listed in Table 7 .

Self-Improving Agents

Self-improving agents use experience and feedback to update their models, memories, skills, or workflows for better future task performance.

See all 171 papers

SAGE: A Quantitative Evaluation of Socialized Evolution in Agent Ecosystems
Jun 2, 2026Linyue Pan, Yaoming Zhu, Lin Qiu +2Multi-Agent Collaboration AI Agent Benchmarks
Tsinghua University, China · Meituan, China
Co-Evolving Agents: Learning from Failures as Hard Negatives
Nov 27, 2025Yeonsung Jung, Trilok Padhi, Sina Shaham +4Hard Negative Mining Self-Improving Agents
KAIST · Georgia State University · Independent Researcher +2
Learning from Revision Consequences: Hindsight Meta-Experience Distillation for Self-Improving Agents
Oct 6, 2026Qianhan Feng, Zhongzhen Huang, Yakun Zhu +2LLM Agent Skill Learning Self-Improving Agents
The Chinese University of Hong Kong · Shanghai Jiao Tong University · Shanghai Innovation Institue

Jun 2, 2026J/K move · Enter open · S save

SAGE: A Quantitative Evaluation of Socialized Evolution in Agent Ecosystems

Linyue Pan, Yaoming Zhu, Lin Qiu, Xuezhi Cao+1

Tsinghua University, China · Meituan, China

Multi-Agent Collaboration AI Agent Benchmarks Multi-Agent Systems Self-Improving Agents

Open paper AskPDF arXiv

Self-improving language agents are typically evaluated in isolation: an agent attempts a task, receives feedback, and iteratively refines its own behavior. Yet agents increasingly operate alongside peers whose strategies and outcomes are publicly visible. This raises an under-studied question: when does shared experience produce improvements that self-improvement alone cannot achieve? We introduce SAGE (Social Agent Group Evolution),an evaluation framework that compares two compute-matched conditions: SocialEvo, where agents from five distinct model families co-evolve with access to all peers' histories; and SelfEvo, where each agent receives the same number of task attempts but sees only its own past, which is conventional in self-improving agent studies. We instantiate SAGE in three arenas: open-ended ML research, long-horizon economic planning, and strategic multiplayer play, evaluated across multiple evolutionary rounds. We find that group history is not a universal amplifier: the strongest agent does not exceed its self-evolution ceiling. However, agents that plateau under self-improvement can achieve significant breakthroughs when peer experience is available. In competitive settings, counterfactual controls reveal that agents improve generally rather than developing opponent-specific strategies. Across different forms of shared history, filtered peer traces and reflective summaries often outperform raw logs, indicating that social gains depend on abstraction rather than exposure volume. These findings reveal that peer-history gains are agent-specific, arena-dependent, and contingent on the capacity to abstract transferable knowledge from public traces.

Abstract

Self-Improving Agents

Explore similar work

SAGE: A Quantitative Evaluation of Socialized Evolution in Agent Ecosystems

Co-Evolving Agents: Learning from Failures as Hard Negatives

Learning from Revision Consequences: Hindsight Meta-Experience Distillation for Self-Improving Agents