Deploying LLM agents in specialized domains often require fine-grained task-specific procedures and knowledge a general model lacks, yet parameter training is costly and non-interpretable, and hand-engineered agent systems shift the cost to expert labor. Episodic memory updates at context level, but single agent adaptation struggles to alleviate cross-task interference, especially with complex tasks such as multi-application navigation or data pool analysis. Although multi-agent evolution alleviates this problem, existing methods lack clear definitions on update rules and rely on the backbone model to decide where and how much the system changes. This ill-scoped evolution makes learning follow the backbone's structural preferences rather than the observed failures: one backbone accumulates skills while another spawns agents. We present EMMA (structured Episodic Memory for Multi-Agent workflow synthesis), which treats the configuration of a multi-agent system (controller routing memory, specialists inheriting a generalist prompt, and per-step procedural skills) as episodic memory. EMMA makes the ownership and admissibility of updates explicit: a reflector assigns each diagnosed failure to the scope owning its correction and proposes one edit within it, and backbone-independent guards keep every accepted edit scoped, incremental and bounded. Across KramaBench, AppWorld and BBEH with five backbones and four baselines (ACE, GEPA, EvoMAS and ADAS), EMMA attains the best overall performance on every benchmark, up to 32.5% over the strongest baseline, maintains consistent improvements across backbones, and uses 17-38% fewer training executions than the most efficient baseline.
Figures & tables
Figure 1: Ill-scoped versus scoped updates. (a) Without scope constraints, the update is a backbone habit: Opus 5 accumulates skills, DeepSeek v3.2 repeatedly creates agents (one mark per created artifact). (b) EMMA assigns the diagnosed failure to a scope and makes one bounded edit within it.
Figure 2: EMMA architecture. The controller selects controller-memory entries, plans, and dispatches one step at a time to a sub-agent with its assigned skills; step outputs drive replanning, and a step that overflows its sub-agent is re-split. The three memory levels persist across tasks and are written only during training; the execution environment is created per attempt and discarded.
Figure 3: EMMA training procedure. (1) Rollout in a fresh environment; (2) a binary gate from the task’s own signal; (3) structured reflection over the whole trajectory (localize, classify, generalize, minimize); (4) one guarded edit within the designated scope; (5) re-run until success or the revision budget is spent, then an end-of-task controller update; the memory is frozen after one pass.
Scope z
Meaning
Level
Available actions Act(z)
execution_slip
knew the method, slipped once
plan directive (this task)
revise_plan , no_change
agent_behavior
a general working habit failed
agent prompt
refine_prompt
procedure
method for a class of sub-problems wrong/missing
skill pool
revise_skill , create_skill
missing_capability
no agent in the pool can do this work
skills, then agents
create_skill , create_agent
routing
subtasks correct; decomposition/dispatch wrong
controller memory
memory_note , revise_plan ; create_agent on overflow
Table 1: Ownership rules: failure scopes z and available actions Act(z) . A lesson at the wrong level never fires again or contaminates unrelated tasks; the scope–action guard enforces this table.
KramaBench
BBEH-mini
Method
O-5
S-5
GLM-5
DSv3.2
K2.5
Mean
O-5
S-5
GLM-5
DSv3.2
K2.5
Mean
ACE
0.694
0.545
0.602
0.478
0.579
0.580
0.780
0.514
0.353
0.492
0.448
0.517
GEPA
0.663
0.509
0.634
0.514
0.602
0.584
0.764
0.658
0.527
0.501
0.576
0.605
EvoMAS
0.654
0.516
0.600
0.476
0.524
0.554
0.650
0.541
0.478
0.478
0.462
0.522
ADAS
0.709
0.584
0.530
0.481
0.504
0.562
0.690
0.595
0.500
0.516
0.519
0.564
EMMA (ours)
0.766
0.641
0.693
0.585
0.586
0.654
0.804
0.647
0.617
0.563
0.685
0.663
Table 2: KramaBench (macro accuracy over 76 held-out tasks) and BBEH-mini (accuracy, 368 held-out examples). Best per column in bold , second underlined ; Mean averages over backbones.
Split
Method
O-5
S-5
GLM-5
DSv3.2
K2.5
Mean
normal
ACE
83.3 / 75.0
84.5 / 73.2
61.3 / 35.7
65.5 / 48.2
66.7 / 35.7
72.3 / 53.6
GEPA
92.9 / 87.5
77.4 / 55.4
63.7 / 39.3
41.7 / 7.1
53.6 / 19.6
65.9 / 41.8
EvoMAS
94.6 / 89.3
69.0 / 44.6
16.7 / 1.8
31.5 / 10.7
44.6 / 30.4
51.3 / 35.4
ADAS
90.5 / 83.9
67.9 / 53.6
22.0 / 12.5
0.0 / 0.0
3.6 / 0.0
36.8 / 30.0
EMMA (ours)
96.4 / 94.6
89.9 / 82.1
78.6 / 57.1
77.4 / 57.1
78.6 / 64.3
84.2 / 71.0
challenge
ACE
88.0 / 81.3
80.6 / 65.5
56.1 / 36.0
46.0 / 24.5
66.2 / 46.0
67.4 / 50.7
Table 3: AppWorld , TGC / SGC (%) on test_normal (168 tasks) and test_challenge (417 tasks). Best in bold , second underlined , ranked per metric. For ADAS on DeepSeek v3.2 and Kimi-K2.5, no discovered program beat the hand-written seed, which is reported.
Figure 4: Cross-family consistency. Held-out performance per backbone (from Tables 2 and 3 ); shaded columns are open-weight backbones.
Table 8
Appendix figures & tables6 assets
Supplementary material from the paper’s appendix.
Appendix
Setting
Value
Training passes
1, fixed task order
Training gate
KramaBench: Opus 4.5 judge; AppWorld: unit tests; BBEH: exact match
Revisions per task K / log inspections per revision
5 ( ≤6 executions) / 3
Refusal feedback rounds before forced no_change
3
End-of-task controller-memory entries
≤2
Pool caps: agents (incl. seed) / skills; chars per prompt / skill
10 / 40; 6,000 / 3,000
Appendix
Table 6: Configuration of EMMA.
Action
Level
Durable
Payload
no_change
none
no
the failure is not addressable by the program
revise_plan
plan directive
this task only
a directive the next attempt’s planner must follow
memory_note
controller memory
yes
topic, one to three sentences, generality label
refine_prompt
agent prompt
yes
the complete edited prompt of a participating agent
revise_skill / create_skill
skill pool
yes
skill text and its “when to use” description
create_agent
agent pool
yes
name, description, specialization (inherits the generalist)
Appendix
Table 7: Reflector action vocabulary.
Benchmark
Total
Train
Eval
Split construction
KramaBench
104
28
76
deterministic, stratified by domain and difficulty
AppWorld
—
90
168 (normal) / 417 (challenge)
upstream splits, unmodified
BBEH-mini
460
92
368
seed 42, 4 train / 16 eval per category
Appendix
Table 8: Benchmark splits.
archeo.
astro.
biomed.
environ.
legal
wildfire
total
Train
4
4
3
5
7
5
28
Eval
8
8
6
15
23
16
76
Appendix
Table 9: KramaBench per-domain split.
Method
Unit of update
Where to edit
Bound on edit
Leakage check
Acceptance
ACE
delta bullets in one playbook
single level
incremental; de-duplication
not described
best-validation playbook
GEPA
one component prompt
round-robin scheduler
none (full rewrite)
not described
minibatch improvement
EvoMAS
whole configuration
meta-model
one component type per mutation
not described
evaluator reward − cost
ADAS
whole agent program (code)
meta-agent
none (novelty, debugging)
not described
archived after evaluation
EMMA
one entry at one level
diagnosed scope, as in Table 1
prompt preservation, bounded growth, change of strategy
answer and task text
re-run on a fresh environment
Appendix
Table 10: How a single update is constrained.
Level
Entry
Responsibility
Observed evidence
Controller memory
single csp_solver step, one continuous pass
decomposition and dispatch
the plan uses one solving step and repeats the routing rule
Agent configuration
csp_solver specialization
model construction, debugging, verification
the specialist completes in 9 rounds and reports a verified solution
Procedural skill
zebra-csp-encode-and-verify
clue encoding and correctness checks
the skill is assigned; the trace reports clue checks and a blocking re-solve for uniqueness
Appendix
Table 11: Three memory levels on a held-out zebra puzzle.
Recent advances have improved the adaptive capabilities of LLM-based multi-agent systems (MAS) through memory-, skill-, and learning-based approaches, yet these approaches remain challenged by noisy trajectories, insufficient modeling of memory-skill relations, and reliance on additional training or high-quality supervision. To address these limitations, we propose ConMem, a relation-aware and training-free framework that enables efficient multi-agent adaptation through cross-experience coordination. Specifically, ConMem distills historical interaction trajectories into structured memory cards to capture reusable strategies and cues, organizing them into a relation-aware memory graph. At runtime, ConMem retrieves cards according to task needs and coordinates them through the card graph to resolve strategy conflicts and recover their dependencies. Combined, these modules yield structured and relation-aware guidance, enabling robust, lightweight adaptation in multi-agent systems without additional training. Extensive experiments across multiple benchmarks and mainstream MAS architectures show consistent gains over existing memory architectures, with improved inference-time efficiency through pruning more than 50% of expanded candidates and reducing planning overhead by over 80%. Our codes are available at https://anonymous.4open.science/r/ConMemCode
Zhixun Tan, Qiang Chen, Tairan Huang +2
Central South University · The Hong Kong University of Science and Technology
Memory helps LLM-based multi-agent systems reuse experience, but stored advice can be flawed or applied in the wrong situation. Team-level success or failure alone cannot reliably show whether a memory needs correction or should not have been used. We propose DiscernMem, a training-free framework that improves both memory quality and memory use. To improve quality, Defect-Aware Memory Refinement (DMR) compares team executions with a single memory and with no memory, diagnoses rule defects, and tests repairs on current and earlier tasks to guard against losing previously useful behavior. To guide appropriate use, Boundary-Learning Meta-Memory (BLM) records each memory's past uses and effects, learning when its owner role should apply or avoid it based on task context and incoming messages. Together, these components help teams correct flawed experience while retaining useful rules that were applied incorrectly. Experiments with Qwen3-4B-Instruct-2507 on four benchmarks show that DiscernMem achieves the highest average score on AutoGen, CAMEL, and MacNet, exceeding the strongest reported baselines by 0.51-4.32 points. It leads on code generation and symbolic planning across all three systems, including a PDDL score of 37.71 versus 28.48 on CAMEL.
Yipeng Hao, Yuxuan Cai, Wenkai Ji +6
School of Computer Science and Technology, East China Normal University, Shanghai · Ocean University of China · Tongji University +1
LLM-based multi-agent systems generate collaboration traces that record how agents plan tasks, verify intermediate results, and repair failures. Reusing these procedures requires preserving an action's prerequisites and the outputs needed by subsequent agents. Our empirical studies show that grouping these dependencies into functional memory units improves their retention, while connecting units increases retrieval of the units and links jointly required by a task. The preferred combination of units also changes between instructions and checklists, even when each combination's content is fixed across formats. Updating choices from the outcomes of each combination and format pairing outperforms scoring combinations and formats separately. These findings motivate MACE, a memory-agent co-evolution framework that adapts memory organization and agent memory use through execution feedback. Its MemGoG structure represents functional units as subgraphs of related conditions, actions, and outputs, connecting them through support, conflict, and repair relations. MACE Loop selects task-relevant units and relations within a memory budget and provides each agent with instructions or checklists for its current operation. It records the selected units, presentation formats, agent outputs, and task outcomes to update unit scores and relations for retrieval and inform subsequent presentation choices. Across eight benchmarks, MACE outperforms ten baselines with an average score of 81.11%, compared with 78.97% for the strongest baseline, SAGE.