WorksComputer Science
Which Agent's Skill Should Change? Group-Relative Credit Assignment for Evolving Multi-Agent Teams
Abstract
Cooperative language-model agents can improve without weight updates by revising reusable skills, but only if a shared team reward is traced to the responsible agent and skill. Existing methods credit the skills present in each trajectory, yet presence is not responsibility: a harmful skill active in successful runs still earns positive credit. We present GRSE, Group-Relative Skill Evolution, which assigns behavioral credit by comparison: inspired by GRPO, it executes each question several times under the same skill libraries and contrasts the executions to credit agent–skill pairs, with structured diagnosis of failures. On HotpotQA and LoCoMo with two open-weight actors, GRSE outperforms MASkills, the closest prior method, on HotpotQA and every LoCoMo category except open-domain, with the largest gains on multi-hop questions ( and F1). Its gains rest on better-grounded retrieval rather than answers given without evidence, and its learned skills transfer between the multi-hop tasks. GRSE is robust to corrupted libraries: starting from planted harmful skills, it credits every planted skill with the correct sign and recovers the score of a clean library ( points), whereas MASkills misattributes two and falls below its starting point.
Introduction
Language-model agents increasingly work in teams: one agent collects evidence, another reasons over it, and the team is judged by a single outcome [3, 9, 21, 6, 35, 29, 10, 27, 11]. Improving such a team requires answering a credit assignment question: which agent’s behavior, and which step of it, produced a success or a failure? The question is classical in multi-agent reinforcement learning, where a shared reward is decomposed with difference rewards or counterfactual baselines [26, 7, 17], and it has recently been posed for language-model teams as automated failure attribution [37]. A wrong answer may stem from evidence collection, an incomplete handoff, or downstream reasoning [24, 37], and the agent whose output is wrong is often not the agent whose behavior needs to change. For example, reasoner answers wrongly when the retriever misses the evidence.
We study this problem in a setting where model parameters stay fixed and each agent’s behavior is specified by natural-language skills, reusable procedures that the agent reads and follows [38, 22, 1, 32]. Skills make behavior editable, so credit becomes actionable: once responsibility is located, the responsible procedure can be revised. Existing experience- and skill-learning methods, however, assign credit coarsely, which often distill lessons from whole trajectories, and mainly focus on single-agent setting [19, 30, 15]. Meanwhile MASkill, the recent two-agent SOTA, credits each skill from single trajectory in isolation [32]. However, without a contrast, a skill that is present in every execution also receives credit for the successes it did not cause: in our robustness study, MASkills raises the utility of a planted harmful skill over three iterations, whereas our method labels it harmful and prunes it Appendix § 12. Comparison between executions already guide experience distillation, skill refinement, and prompt optimization [2, 4, 12, 34], but they have not been used to localize a team’s outcome to individual agents’ behaviors.
Behavioral credit assignment in agent teams poses two challenges. First, attribution must look past where an error surfaces. In Figure 1, Agent 2 answers “not mentioned” in three of four executions of the same question, yet Agent 2 behaves correctly given its input. The decisive difference lies in Agent 1’s search query, which retrieves the answer only in the successful execution. Second, an attribution must be specific and checkable before it can drive a revision. A defective procedure, a missing capability, and a tool failure call for different responses, and an explanation that cites no execution step cannot be verified. Across questions, attributions must also be aggregated without counting repeated executions of one question as independent evidence.

Figure 1. Each iteration (1) samples a group of team executions per question (§ 3.1), (2) credits agent–skill pairs by contrasting these executions and diagnoses failures in a structured form (§ 3.2), and (3) aggregates the credit across questions into skill edits, each kept only if it does not lower the validation score (§ 3.3–§ 3.4). The example is from one training run on LoCoMo single-hop questions, in which Agent 1 retrieves evidence and Agent 2 answers. In iteration 1, a failure that surfaces in Agent 2’s answer is traced to Agent 1’s retrieval, and a new retrieval skill is induced. In iteration 3, this skill is credited as harmful in the shown group but helpful across the iteration’s 16 groups, so it is refined rather than pruned. In Agent 1’s search queries, | denotes OR.
We introduce GRSE, Group-Relative Skill Evolution, a training-free framework that evolves cooperative agents’ skills through group relative behavioral credit assignment. Following GRPO (Shao et al., [18], GRSE samples multiple complete team rollouts of the same question under fixed skill libraries and compute relative within-group advantages (§ 3.1). A group-relative critic compares agent behavior and handoffs across these rollouts to assign feedback to individual agent–skill pairs.
A structured diagnosis grounds each attribution in a failure type, cited failed and successful steps, and an edit action, and reference checks reject attributions that the executions do not support (§ 3.2). The accepted attributions are aggregated across questions (§ 3.3) and applied as skill updates through the editing operators and validation gate of MASkills (§ 3.4). Figure 1 shows both levels of attribution within a single run: across agents, responsibility shifts from the answering agent to the retrieving agent; within an agent, a previously learned skill is later credited as harmful and diagnosed as a skill defect. Our contributions are threefold:
We formulate skill evolution for cooperative agents as behavioral credit assignment: with model parameters fixed and skills as editable units, a shared team outcome must be attributed to the agent and skills responsible for it. We address this by jointly comparing same-question team executions, which produces agent–skill feedback while preserving the handoffs needed to interpret each agent’s behavior and the proposed revision.
We make these attributions verifiable and actionable: a structured failure analysis links each attribution to a failure type, checked step references, and an edit action, and cross-question aggregation weighs attributions by the number of distinct questions that support them.
We evaluate GRSE on HotpotQA and LoCoMo with two open-weight actors. GRSE outperforms MASkills on HotpotQA and every LoCoMo category except open-domain. Its credit identifies and removes harmful skills that MASkills retains. Answer-transition and learned-skill analyses show that GRSE’s gains come from fewer broken answers and better-grounded retrieval.
Related Work
Reflection and Experience Memory
Experience-based adaptation stores information from past interactions to guide future decisions. Reflexion Shinn et al. [19] records verbal reflections for subsequent attempts. ExpeL Zhao et al. [38] extracts reusable insights from successes and failures, including comparisons on the same task. A-MEM Xu et al. [30] constructs linked notes and updates their contextual attributes as new memories arrive. ReasoningBank Ouyang et al. [15] distills reasoning strategies, and its memory-aware test-time scaling uses multiple executions to enrich memory curation. These methods actively transform experience rather than simply retaining raw traces. Memory and skills also interact: MemSkill Zhang et al. [36] learns to select memory-management skills and revises its skill bank, while MSCE Tang et al. [20] promotes evidence-supported procedural policies into skills and maintains them using feedback. These methods decide what experience to keep and how to organize it, whereas GRSE instead decides where execution evidence should act, assigning it to editable skills owned by individual agents.
Reusable Skill Discovery and Evolution
Skill libraries turn experience into procedures that can be invoked and revised. Voyager Wang et al. [22] maintains executable code skills, and EvoSkill Alzubi et al. [1] uses an executor, proposer, and skill builder to discover and refine skills from task feedback. SkillRL Xia et al. [28] distills failed trajectories into lessons, organizes skills into general and task-specific categories, and evolves the library alongside reinforcement learning of the agent policy. These methods learn skills for a single executing agent, so they never have to decide which agent’s skill to revise. MASkills Yao et al. [32] extends skill learning to cooperative teams through skill-conditioned credit, hierarchical aggregation, and skill editing, but it credits each trajectory on its own. We retain its skill representation and editing operators and change how credit is formed: GRSE jointly compares same-question team executions, and structured diagnosis links each failure to an agent–skill target, cited execution steps, and a checked edit action.
Group-Relative and Contrastive Feedback
GRPO Shao et al. [18] uses within-question rewards to optimize model parameters. Training-Free GRPO Cai et al. [2] instead distills semantic feedback from rollout groups into experiential context. Several methods already apply comparisons to skills: SkillCAT Chen et al. [4] contrasts same-task success/failure pairs, evaluates patches through replay, and organizes skills for routing. SkillCome Li et al. [12] combines within-group contrast with memories of failure and contrast patterns. CANTANTE Zehle [34] contrasts joint prompt configurations on the same query to provide per-agent optimization signals. In these methods, the contrast either compares outcomes or varies the configuration being optimized. GRSE holds the skills fixed and contrasts the team’s behavior across executions, so that an outcome difference can be traced to an agent, a skill, and a cited step.
Method
GRSE attributes a team’s outcome to the behaviors of individual agents and turns these attributions into revisions of the responsible behavior. Each agent’s behavior is specified by a skill library, while language-model parameters and agent roles stay fixed. Every iteration has three main steps (Figure 1): grouped rollouts provide contrasting executions of the same question (§ 3.1); a group-relative critic assigns behavioral credit to agent–skill pairs and grounds it in structured failure analysis (§ 3.2); and the attributions are aggregated across questions (§ 3.3) and applied as validated skill updates (§ 3.4). Algorithm 1 summarizes the update loop.
Grouped Rollouts and Relative Feedback
For cooperating agents, let be their skill libraries at iteration . Each library contains named instruction artifacts following MASkills [32]. A complete team trajectory records agent actions, messages, tool interactions, and the final answer. Its skill trace identifies candidate agent–skill attribution targets. Trace membership records exposure, while the behavioral evidence supports the critic assessment.
For each question in batch , we sample complete team executions from a fresh context under the same libraries and form
where . We set consistently in our experiments. Following the normalization in GRPO [18], let and . The relative advantage is
Because all executions in a group share the question and the libraries, the differences between high- and low-advantage executions point to the behaviors that decided the outcome, much like a counterfactual baseline in multi-agent reinforcement learning [7]. The critic receives both absolute rewards and relative advantages to compare trajectories and draws on execution evidence to assess skill credit (§ 3.2). Groups with equal-reward carry no contrasts but still show which behaviors consistently fail or succeed, so they are kept by default. We further tested groups with differing rewards following DAPO [33] in our ablation studies (§ 5.5).
Group-Relative Behavioral Critic Assignment
The critic reads all executions of a question together and compares them agent by agent. It can therefore attribute an outcome difference to the agent whose behavior differs between high- and low-advantage executions, rather than to the agent whose output is wrong:
Here contains at most one skill credit per relevant agent and skill . records agent-level feedback not tied to an existing skill and evidence for skill induction. contains structured failure diagnoses of existing skills with checked execution references and edit actions. In Figure 1, iteration 1 yields agent-level credit for Agent 1, since no skill exists yet, and iteration 3 yields a skill credit for Agent 1’s learned retrieval skill.
Skill credit. For each credit , labels the skill as helped, redundant, harmful, or neutral; gives supporting evidence; and suggests a refinement. and identify redundant and conflicting skills, respectively. The critic’s utility score suggests skill usefulness and informs cross-question aggregation and subsequent pruning decisions, while redundancy links guide consolidation. With empty libraries, or supplies evidence for induction.
Structured failure analysis A credit states who is responsible, and a failure analysis states why and where, in a form that can be checked. We represent it as : agent, skill identifier, failure type, failed-step references, optional successful-step references, explanation, proposed correction, and action, respectively. The critic selects from eight predefined failure types: skill not followed, skill defect, missing capability, handoff error, evidence missing, answer format, tool failure, and uncertain attribution. These types distinguish procedural defects from execution errors and failures that do not justify a skill edit. The action is refinement, induction, or no edit. Induction uses to indicate a missing capability.
Attribution checks. The critic interface checks that step references exist, match the named agent, and cite non-full-reward executions for and full-reward executions for . Refinement additionally requires an owned skill recorded in the cited failed rollout and a matching credit. Tool failures and uncertain or unknown responsibility permit only no edit. Accepted diagnoses provide the failure-related edit directions in and the induction evidence in . A correction without a successful comparison is marked as a hypothesis. These checks enforce reference and action consistency. The explanation remains an observational assessment. In Figure 1, iteration 3, the analysis names Agent 1 and its learned skill, classifies the failure as a skill defect, cites the failed rollouts #1 and #4 and the successful rollouts #2 and #3, and proposes a refinement.
Cross-Question Credit Aggregation
A single group shows how one question went and a revision should rest on attributions that recur across questions. We therefore aggregate credit across questions into edit direction for existing skills and evidence for new skills. For existing skills, feedback for is synthesized into an edit direction:
where contains questions with usable credit for that pair. We reuse the MASkills (Yao et al., [32]) aggregation operator, which returns a summary, suggested edit, utility score, and verdict. Let collect these outputs, augmented with category utility summaries when category is enabled.
For skill induction, the organizer groups accepted diagnoses across questions by agents, failure type, skill target, and edit action. Each pattern is assigned support
where extracts the grouping fields. For each agent, induction patterns are ordered by and retained with example diagnoses as evidence . Thus repeated rollouts do not count as additional supporting questions. The aggregated feedback guides edits to existing skills, while provides evidence for inducing new skills.
Credit-Guided Skill Evolution
Given the aggregated edit directions and induction evidence , we evolve each agent’s skill library. With operator schedule and library limit , candidate libraries are
The operators refine credited skills along , prune skills with low utility, consolidate redundant ones, and induce new skills from . Each candidate is validated against the same pre-update team, so that an update whose attribution was wrong is not kept. For fixed validation set and executions per question, define
Let and , where only agent ’s library is replaced. Tolerance gives the update
Accepted candidates are assembled after all agents are tested, and acceptance remains per agent.
Algorithm 1 Group-Relative Skill Evolution
Input: training tasks , validation set , initial libraries , iterations , group size , tolerance , schedule , library limit .
Output: evolved libraries .
for do
Sample .
for all do
Obtain usable via Eq. (3).
end for
for all agents do
Aggregate skill feedback via Eq. (4).
Build from and low-reward groups, or structured patterns (Eq. (5)).
Append structured category utility summaries to when enabled.
Form candidate via Eq. (6).
end for
Compute via Eq. (7).
for all agents do
If unchanged, retain ; otherwise test against and apply Eq. (8).
end for
Assemble, evaluate, and save .
end for
return .
Experiment
Experimental Setup
We follow the setting of MASkills (Yao et al., [32]), the closest prior SOTA for multi-agent skill evolution. Each method consists of two agents with task-specific roles that communicate sequentially, and the second agent produces the final answer. The agents are executed by one of two open-weight actors, Qwen3.8-27B (Qwen Team, 2026) and Gemma-4-31B-it (Gemma Team, [8]), each conditioned on its own skill library. We use these two recent released open-weight model of similar size from different families to test whether credit assignment depends on the actor. A fixed Qwen3.8-27B model serves as critic and skill optimizer for all methods. Model parameters and agent roles stay fixed. The agents change only through their skills, which are revised according to the assigned credit.
All skill-evolution methods start from empty libraries and run for five iterations. GRSE samples four team trajectories per question, whereas MASkills samples one. Final libraries are evaluated with temperature-zero decoding. Detailed model, data and optimization settings appear in Appendix § 10.
Benchmarks
Datasets and metrics. We evaluate on HotpotQA [31] for multi-hop question answering and LoCoMo [14] for long-memory conversational reasoning. We use the distractor–hard subset and report the answer-token F1 for HotpotQA. LoCoMo covers multi-hop, temporal, open-domain, and single-hop questions. We report the category-specific F1 and smoothed BLEU.
Baselines. We group baselines by whether they use the agent team. Single-model baselines answer with one model and no agents or skills. On HotpotQA, we run four prompting methods with the same actor, questions, passages, answer-format instruction, and metric as the agent teams, including IO (direct answer), Chain-of-Thought (CoT; [25]), CoT with self-consistency (CoT-SC; [23]; majority vote over five samples), and Self-Refine [13] (at most three feedback-and-revision rounds). On LoCoMo, the full-context baseline follows the benchmark protocol [14] with the actor model reads the entire conversation and answers directly. Two-agent baselines share the team, roles, and actor with GRSE. The empty-library team is this team before any skill is learned (iteration 0). For HotpotQA, all teams follow the agent prompts and short-answer instructions from the MASkills implementation, with questions and distractor passages supplied by the dataset. For LoCoMo, agent teams use category-specific task prompts. All the prompts are detailed in Appendix § 15. We report each two-agent method as the mean over three training runs, because the learned libraries vary with the sampled rollouts and the critic’s outputs, whereas single-model baselines have no training stage and are evaluated once.
GRSE variants. We report GRSE and GRSE w/o structure analysis, which retains group-relative feedback but omits the prescribed failure-diagnosis schema and its checks, in main analysis. We report GRSE w/o structure and the other three variants in ablation studies: GRSE w/ label retains structured diagnosis and additionally uses dataset labels to condition the critic and organize update evidence; GRSE with samples one trajectory per question; and DAPO filter keeps four rollouts but, following the dynamic sampling of DAPO [33], sends only groups whose rewards differ to the critic.
Results and Discussion
Main Results
Overall, GRSE is the strongest two-agent method on HotpotQA with both actors, outputs MASkills on every LoCoMo category except open-domain, and varies less across runs than MASkill (Table 1 and Table 2).
| Actor Model | Qwen3.8 | Gemma4 |
| Single model, no agents | ||
| IO | 81.6 | 81.3 |
| CoT | 80.7 | 82.5 |
| CoT-SC | 82.6 | 83.3 |
| Self-Refine | 84.1 | 81.1 |
| Two agents, 5 iterations | ||
| Empty library (iter. 0) | 80.6 | 81.6 |
| MASkills | ||
| GRSE (ours) | ||
| GRSE w/o structure |
Table 1. HotpotQA test F1 (×100) with a greedy actor on 500 test questions. Columns give the actor model (Qwen3.8-27B, Gemma-4-31B-it). Qwen3.8-27B is critic and optimizer throughout. Empty library is this system before any skill is learned (iteration 0). Mean over three runs, with SD as a subscript. CoT-SC uses 5 samples, Self-Refine at most 3 feedback rounds. Best per column in bold. Best two-agent setting is underlined.
| Task () | Multi-hop (156) | Temporal (179) | Open-domain (52) | Single-hop (453) | ||||
| Method | F1 | BLEU | F1 | BLEU | F1 | BLEU | F1 | BLEU |
| Actor: Qwen3.8-27B | ||||||||
| Full-context | 49.9 | 40.0 | 48.3 | 25.9 | 36.4 | 31.6 | 70.8 | 57.6 |
| Empty library (iter. 0) | 49.7 | 42.8 | 70.6 | 48.5 | 24.7 | 16.4 | 59.7 | 51.0 |
| MASkills | ||||||||
| GRSE (ours) | ||||||||
| GRSE w/o structure | ||||||||
| Actor: Gemma 4-31B | ||||||||
| Full-context | 48.5 | 37.8 | 55.7 | 30.0 | 18.6 | 12.9 | 71.7 | 57.6 |
| Empty library (iter. 0) | 36.5 | 29.7 | 65.6 | 45.1 | 19.2 | 10.7 | 45.3 | 37.0 |
| MASkills | ||||||||
| GRSE (ours) | ||||||||
| GRSE w/o structure |
Table 2. LoCoMo test results per question category: token F1 and smoothed BLEU () with a greedy actor. Full-context is a single model that receives the entire conversation, following the LoCoMo protocol (no agents or skills). The remaining rows use the two-agent system trained for 5 iterations. Empty library is this system before any skill is learned (iteration 0). Mean over three runs, with SD as a subscript. Qwen3.8-27B serves as critic and optimizer for both skill methods. Best per column in bold; best two-agent result underlined.
HotpotQA. GRSE improves over MASkills with both actors: 83.7 vs. 80.6 F1 with Qwen3.8 (+3.1) and 82.8 vs. 82.3 with Gemma4 (+0.5). With Qwen3.8, it comes within 0.4 F1 of the strongest single-model baseline, Self-Refine (84.1). With Gemma4, all methods lie within 2.2 F1 of one another (81.1–83.3), and GRSE w/o structure is the strongest two-agent setting (83.1).
LoCoMo. GRSE improves over MASkills on every LoCoMo category except open-domain with both actors. On multi-hop, it gains +6.7 F1 and +5.3 BLEU with Qwen3.8 and +3.2 F1 and +2.8 BLEU with Gemma4. On temporal questions, it achieves the highest scores with both actors (73.4 F1 with Qwen3.8 and 67.4 F1 with Gemma4). On single-hop questions, GRSE w/o structure achieves the best two-agent results (67.4 F1 with Qwen3.8 and 57.1 with Gemma4). Open-domain, the smallest category (52 questions), favor MASkills with both actors. Relative to the empty library, the skills learned by GRSE help where those of MASkills can hurt. With Gemma4, both GRSE variants improve over the empty library in every category (GRSE: +1.8 to +11.2 F1), whereas MASkills falls below it on temporal questions ( F1). With Qwen3.8, MASkills likewise falls below the empty library on multi-hop questions ( F1), where GRSE gains . On multi-hop questions, GRSE also varies less across runs than MASkills (F1 SD 0.8 vs. 1.4 with Qwen3.8 and 3.8 vs. 4.5 with Gemma4).
The full-context baseline is an upper-bound-style reference rather than a competitor: it gives a single model the entire conversation, whereas the two-agent systems must first retrieve evidence and answer from that alone. Full-context retains the advantage on single-hop questions with both actors, multi-hop scores with Gemma4, and Open-domain scores with Qwen3.8. Whereas seeing only retrieved evidence, GRSE surpasses it on temporal questions with both actors.
Analysis of Learned Skills
Where do the gains come from? Table 3 tracks each test question from the empty library to the final library. The methods differ mainly in how many correct answers they break: MASkills breaks three times as many as GRSE on HotpotQA with Qwen3.8 ( vs. ) and twice as many on LoCoMo, with Gemma4 ( vs. ), where its losses offset its fixes (: vs. ). With the Gemma4 actor on LoCoMo, declined questions that become correct account for most of GRSE’s gain ( of ), and the last two columns show how they are fixed. MASkills reduces declines without improving retrieval: the share of questions with no cited evidence stays at 22%, and 9 of its 34 D C lack evidence. GRSE lowers this share to 14%, with only 5 of 61 lacking evidence, consistent with crediting Agent 1’s search rather than Agent 2’s answer.
| Contribution to | % of questions | ||||||
| Method | DC | WC | CW | Decl. | No ev. | #DC | |
| HotpotQA, Qwen3.8 | |||||||
| MASkills | 0.0 | – | – | ||||
| GRSE | 0.0 | – | – | ||||
| HotpotQA, Gemma4 | |||||||
| MASkills | 0.0 | – | – | ||||
| GRSE | 0.0 | – | – | ||||
| LoCoMo, Qwen3.8 | |||||||
| MASkills | 18 (0) | ||||||
| GRSE | 22 (0) | ||||||
| LoCoMo, Gemma4 | |||||||
| MASkills | 34 (9) | ||||||
| GRSE | 61 (5) |
Table 3. Answer transitions from the empty to the final library. Each test question is declined (empty or “not mentioned”), correct (F1 ), or wrong under each library. : change in mean token F1 (). DC, WC, CW: contribution to of questions moving from declined to correct, wrong to correct, and correct to wrong; the remaining transitions make up the rest. Decl.: share of declined answers, before after. No ev.: share of questions whose retrieved evidence cites no dialogue turn (e.g., [D3:5]), before after. #DC: number of declined-to-correct questions, with those answered without cited evidence in (). No ev. and #DC are reported for LoCoMo only, as HotpotQA has no retrieval step. All rows are the first run of each method; on LoCoMo, each category has its own library, and empty-library answers come from iteration 0 of the same GRSE run.
What do the learned skills encode? We label every final skill by its primary purpose with
Qwen3.8-27B (Table 9).
On LoCoMo, retrieval procedures are the largest type for every method and actor. With Gemma4, GRSE also learns more abstention rules than MASkills (18% vs. 5%), in line with its declining rather than answering without evidence (Table 3). On HotpotQA with Qwen3.8, GRSE mostly writes answer-format rules (57%), while MASkills mostly writes reasoning procedures (50%). Together with its higher rate of broken answers, this suggests that MASkills’ reasoning rules often redirect answers that were already correct. Appendix § 11 walks through two examples: a Gemma4 retriever that learns to find the turn holding the answer, and a HotpotQA answer that GRSE’s learned skills make it more specific.
Robustness Analysis
A skill library may contain flawed or irrelevant skills, for example when skills are written by hand or reused from another task. We test whether skill evolution can repair such a library on LoCoMo single-hop questions, the category with the largest test set (453 questions), with the Qwen3.8 actor. Instead of an empty library, both methods start from the same corrupt library: each agent keeps one helpful skill and receives two harmful or irrelevant skills phrased as plausible advice, and neither the critic nor the optimizer is told which skills are perturbed. All other settings follow the per-category runs. We run GRSE and MASkills once each, and evaluate the corrupt library and its helpful skills alone as reference.
Table 4 shows that GRSE recovers the score of the helpful skills alone (66.9 vs. 66.7 F1) and halves the abstention rate (9.7→4.6), whereas MASkills ends slightly below its starting point. Group-relative credit assignment attributes the damage to individual skills, so GRSE prunes or locally repairs the harmful ones. MASkills instead merges perturbed content into new skills. Appendix § 12 traces each corrupt skill and walks through individual cases.
| Library | F1 | BLEU | F1 | Abst. (%) |
| Perturbed (start) | 60.6 | 52.1 | – | 9.7 |
| Helpful skills only | 66.7 | 57.4 | +6.1 | 4.2 |
| MASkills | 58.4 | 49.3 | −2.2 | 7.9 |
| GRSE | 66.9 | 57.4 | +6.3 | 4.6 |
Table 4. Repairing a perturbed skill library on LoCoMo single-hop questions (Qwen3.8 actor, 453 test questions, greedy decoding, one run per method). Token F1 and smoothed BLEU (×100) are measured with the final library. F1 is the change in F1 from the perturbed starting library. Abst. is the percentage of refusal answers such as “not mentioned”. Bold marks the best learned library. GRSE beats MASkills by +8.5 F1.
Table 5 examines whether each method credits the planted skills correctly. For every planted skill, we read its utility after the first update (), which aggregates the critic’s credits over all training questions of iteration 1. A credit is correct if it is positive for a helpful skill and negative for a harmful one. GRSE assigns the correct sign to all five helpful and harmful skills and separates the two kinds by 0.31, whereas MASkills gets two of the five wrong and separates them by only 0.03. The clearest failure is Agent 2’s harmful skill verbatim-evidence-guard: MASkills credits it positively and keeps raising its utility over the next two iterations, consistent with crediting a skill for successes in which it is merely present. GRSE instead marks it harmful and prunes it in iteration 3. Both methods assign the irrelevant skill zero utility, but GRSE leaves it untouched, whereas MASkills merges it into Agent 1’s new retrieval protocol. This is the failure mode of trajectory-level credit that motivates group-relative comparison (§ 1).
| Planted skill | Kind | \underline{} | Fate | \underline{} | Fate |
| GRSE | MASkills | ||||
| Agent 1 (retriever) | |||||
| context expansion | help | +0.18 | merged | +0.03 | merged |
| latest session | harm | −0.12 | merged | +0.07 | merged |
| equation solving | irr. | 0.00 | kept | 0.00 | merged |
| Agent 2 (reasoner) | |||||
| answer fidelity | help | +0.09 | refined | +0.02 | merged |
| complete sentence | harm | −0.22 | refined | −0.12 | merged |
| verbatim guard | harm | −0.19 | pruned | +0.04 | merged |
| Correct sign (of 5) | 5 | 3 | |||
| +0.31 | +0.03 |
Table 5. Credit assigned to the planted skills of the robustness study (Figure 4). Kind: helpful (help), harmful (harm), or irrelevant (irr.). : aggregated utility after the first update; it has the correct sign if positive for helpful and negative for harmful skills (red: wrong sign). Fate: the skill’s status by iteration 5, with the iteration of the change as subscript. Same runs as Table 4.
Cross-Task Transfer
Do learned skills only fit the task they were learned on? HotpotQA and LoCoMo multi-hop questions require the same kind of reasoning over different sources, so we swap the final libraries between them (Qwen3.8 actor; Table 6). Transferred libraries of both methods are at least as good as the empty library, so the learned rules carry over domains without harm. The methods differ in what training on the target adds. For GRSE, in-domain libraries beat transferred ones on both targets (+1.9 and +1.2 F1), yet the transferred libraries still improve over the empty library (+1.3 and +1.8), indicating that the skills learned on one task do not overfit to it. For MASkills, the in-domain libraries fall below the transferred ones (−3.5, −2.1) and do not exceed the empty library, consistent with the correct answers its updates break § 5.2.
| Target | LoCoMo MH | HotpotQA |
| Empty | 50.2 | 80.7 |
| MASkills | ||
| In-domain | ||
| Transfer | ||
| GRSE | ||
| In-domain | 53.4 | 83.7 |
| Transfer |
Table 6. Transfer between the two multi-hop tasks (Qwen3.8 actor, test F1 ×100, mean ± SD over three runs). Transfer: final libraries from the other task (HotpotQA libraries on LoCoMo multi-hop questions and vice versa); each agent keeps the target task’s role. In-domain: libraries learned on the target (Table 1 and Table 2).
Ablation studies
To isolate the contributions of structured diagnosis and group sampling, we learn one skill library shared by all four LoCoMo categories (Qwen3.8 actor, one run per setting, 842 test questions). We test four ablation settings: GRSE w/o structure; GRSE with ; GRSE with the DAPO filter; and GRSE w/ label (details see Appendix § 13). From Table 10 we observe that:
| Setting | Multi-hop F1 | Multi-hop BLEU | Temporal F1 | Temporal BLEU | Open-domain F1 | Open-domain BLEU | Single-hop F1 | Single-hop BLEU | All F1 | All BLEU | Avg. F1 | Avg. BLEU |
| Empty library (iter. 0) | 50.9 | 43.5 | 70.8 | 48.2 | 26.8 | 16.7 | 59.6 | 50.8 | 58.3 | 46.7 | 52.0 | 39.8 |
| GRSE | 52.3 | 44.0 | 73.1 | 51.5 | 33.9 | 22.3 | 60.2 | 50.9 | 59.8 | 47.9 | 54.9 | 42.2 |
| w/o structure | 51.5 | 42.1 | 70.6 | 48.5 | 31.6 | 20.9 | 62.0 | 52.4 | 59.9 | 47.7 | 53.9 | 41.0 |
| 53.7 | 44.6 | 72.0 | 51.3 | 30.5 | 19.4 | 60.4 | 51.4 | 59.7 | 48.1 | 54.1 | 41.7 | |
| DAPO filter | 53.4 | 44.0 | 71.6 | 51.0 | 29.8 | 18.1 | 62.6 | 53.4 | 60.7 | 48.9 | 54.4 | 41.6 |
| w/ label | 49.2 | 40.4 | 70.5 | 49.8 | 27.2 | 18.7 | 64.9 | 55.6 | 60.8 | 49.2 | 53.0 | 41.1 |
Table 10. Ablation on LoCoMo with one shared library learned on all four categories together (Qwen3.8 actor, greedy decoding, one run per setting, 842 test questions). Token F1 and smoothed BLEU (×100) per question category, over all questions (All), and averaged over the four categories with equal weight (Avg.). Single-hop questions make up 54% of All. Best per column in bold, second best underlined. w/o structure removes the failure-diagnosis schema and its checks. samples one team trajectory per question instead of four, so no group-relative comparison is possible. DAPO filter keeps four rollouts but, following the dynamic sampling of DAPO, sends only groups whose rewards differ to the critic. w/ label conditions the critic on the question category and groups update evidence by category.
Both components help. Group contrast gives the critic a basis for attribution, and structured analysis checks it. GRSE has the best category average in F1 (54.9) and BLEU (42.2), +2.9 F1 over the empty library, with the largest gains on temporal and open-domain questions. Removing structured diagnosis or group sampling () lowers the average F1 by 1.0 and 0.8 respectively.
Equal-reward groups still inform the critic. The DAPO filter discards the 7–13 of 32 groups per iteration in which all four rollouts receive the same reward. This lowers the category average by 0.5 F1 and 0.6 BLEU, mostly through open-domain questions (−4.1 F1), while single-hop questions gain (+2.4 F1). Even without contrast, equal-reward groups still show the critic which behaviors consistently fail or succeed.
Labels favor the majority category. GRSE w/ label tops the pooled result (All) only through single-hop questions, 54% of the test set (+4.7 F1 and BLEU). It trails GRSE on every other category, most on open-domain (−6.7 F1), and has the lowest category average of all variants (53.0 F1). Label-conditioned evidence thus pulls a shared library toward the largest category, while degrading performance on the remaining ones.
Conclusion
We studied behavioral credit assignment in cooperative language-model teams whose agents keep fixed parameters and act through natural-language skills. GRSE executes each question several times under the same skill libraries, compares the executions agent by agent, and attributes the team’s outcome to individual agent–skill pairs. Structured diagnosis grounds each attribution in checked execution steps, and the resulting credit drives targeted, validated skill updates. On HotpotQA and LoCoMo with two open-weight actors, GRSE outperforms MASkills on HotpotQA and every LoCoMo category except multi-hop, with the largest gains on multi-hop questions, where the answer depends on evidence passed between the two agents. Its gains also rest on better retrieval rather than on fewer declined answers alone. Accurate credit also makes GRSE robust: starting from a library with planted harmful skills, it credits every planted skill with the correct sign and restores the score of a clean library, whereas MASkills, which credits each trajectory on its own, rewards a harmful skill for successes in which it is merely present and ends below its starting point. Learned libraries also transfer between HotpotQA and LoCoMo multi-hop questions without harm, and only GRSE gains further from training on the target task itself. These results suggest that comparing executions of the same task is a practical way to determine which agent, and which of its behaviors, should change.
Limitations
GRSE trades training compute for more accurate credit: executing each question times raises actor-token cost by 1.6–2.9× over MASkills and wall-clock time by 1.3–1.8× (Appendix § 14). The overhead is confined to training, since test-time inference is unchanged. Furthermore, GRSE defined for any number of agents, but we evaluate two-agent sequential teams on two question-answering benchmarks with two open-weight actors and one critic model. Larger teams, non-sequential communication, longer tool-heavy tasks, and other critic models remain to be tested in the future.
Ethical Considerations
In our experiments, we use only publicly available benchmarks, HotpotQA and LoCoMo, under their respective licenses. All models are open-weight and run locally. Because GRSE writes skills in natural language, humans can inspect and edit the learned libraries for safety before deployment.
Acknowledgments
We used LLMs to help draft and restructure parts of the main text and appendices. The authors reviewed and revised all such material and take full responsibility for the methods, experimental results, claims, and references in the paper.
References
Datasets
HotpotQA: distractor setting, development set (all questions labeled hard). Split: 100 training, 50 validation, and 500 test questions (indices 150–649). Source: hotpot_dev_distractor_v1.json from https://hotpotqa.github.io. License: CC BY-SA 4.0.
LoCoMo: 10 conversations, question categories 1–4. Split: 2 training, 2 validation, and 6 test conversations (seed 42, fixed for all runs); open-domain uses 2/2/5, since conv-30 has no open-domain question. Test questions: 156 multi-hop, 179 temporal, 52 open-domain, and 453 single-hop; 842 in Mix. Source: locomo10.json from https://github.com/snap-research/locomo. License: CC BY-NC 4.0.
Model checkpoints (Hugging Face)
Qwen3.8-27B: Qwen/Qwen3.8-27B, revision 1d4bf0f; actor, critic, and optimizer.
Gemma4-31B: google/gemma-4-31B-it, revision 842da37; actor.
Experimental Details
Models and serving. The actor is Qwen3.8-27B (Qwen Team, 2026) or Gemma4-31B-it (Gemma Team, 2026); Qwen3.8-27B serves as critic and optimizer in all runs. All models are served with vLLM 0.29 on two NVIDIA RTX A6000 GPUs each (tensor parallelism 2, context length 65,536), with thinking mode disabled. Generation is capped at 4,096 tokens for the actor, 4,000 for the critic, 1,200 for skill induction and consolidation, and 800 for refinement. The critic decodes in JSON mode with a structured diagnosis that violates the citation constraints is returned once for repair.
Data and checkpoints. Table 7 lists the data, their splits, and model checkpoints. Both datasets are used in their official releases, and both models are loaded from Hugging Face. LoCoMo is split by conversation, so no conversation appears in two splits. The per-category setting trains one library per question category; the mixed setting trains one library on all four categories. Category 5 (adversarial) is excluded, following MASkills and Mem0 [5].
| Dataset | Setting | Split | Source |
| HotpotQA | distractor setting, development set (all questions labeled hard) | 100 training, 50 validation, and 500 test questions (indices 150–649) | hotpot_dev_distractor_v1.json from https://hotpotqa.github.io |
| LoCoMo | question categories 1–4 | 2 training, 2 validation, and 6 test conversations; open-domain uses 2/2/5 | locomo10.json from https://github.com/snap-research/locomo |
| Qwen3.8-27B | Qwen/Qwen3.8-27B, revision 1d4bf0f; actor, critic, and optimizer | ||
| Gemma4-31B | google/gemma-4-31B-it, revision 842da37; actor |
Table 7. Datasets, data splits, and model checkpoints.
Decoding. Training rollouts use each model’s default sampling parameters (temperature 1.0, top- 0.95, top- 20 for Qwen and 64 for Gemma), so that rollouts of the same question can differ. On LoCoMo, validation is greedy; on HotpotQA, validation uses the training sampling parameters. All reported test scores evaluate the final (iteration-5) libraries with greedy decoding. MASkills on LoCoMo follows its released per-category runner,
which decodes the actor greedily throughout.
Hyperparameters. Table 8 lists the training settings. GRSE and MASkills share every setting except the number of rollouts per question: GRSE samples team trajectories per question and MASkills one. Both start from empty libraries and run five iterations. For skill evolution methods, we use the mean of category-specific token F1 and the smoothed BLEU as training reward on LoCoMo to reflect both answer content and exact wording; token F1 on HotpotQA. The operator schedule applies refinement and induction every iteration, consolidation every second iteration, and pruning every second (HotpotQA) or third (LoCoMo) iteration. Both methods use the same output-format handling for skill files: induced and consolidated skills are normalized to valid front matter before parsing, and skill bodies may use up to 1,200 tokens.
| HotpotQA | LoCoMo Per Cat. | LoCoMo Mix | |
| Iterations | 5 | 5 | 5 |
| Batch size | 100 | 24 | 32 |
| Rollouts per question | 4 | 4 | 4 |
| Validation set size | 50 | 21–159 | 80 |
| Validation executions | 1 | 1 | 1 |
| Gate tolerance | 0.03 | 0.02 | 0.02 |
| Skill limit per agent | 8 | 4 | 8 |
| Advantage | |||
| Training reward | F1 |
Table 8. Training settings, shared by GRSE and MASkills except that MASkills uses one rollout per question. Per-category validation uses every question of that category in the two validation conversations (multi-hop 68, temporal 60, open-domain 21, single-hop 159).
Baselines. CoT-SC draws five samples at temperature 0.7 and returns the majority answer; Self-Refine runs at most three feedback rounds; all other prompting calls are greedy. The full-context baseline limits answers to 32 tokens.
Learned Skills Analysis
This section explains the definitions behind § 5.2, the skill coding, and two cases. All analyses use the first run of each configuration and greedy decoding.
Answer states. A final answer is declined if it is empty or contains “not mentioned”, “not specified”, “not available”, “not found”, “not stated”, “no information”, “unknown” or “cannot be determined”. Otherwise it is correct if its F1 score is at least 0.5 and wrong if not. On LoCoMo, a question has evidence if the retriever’s output cites at least one dialogue turn ([Dsession:turn]). Outputs that say NO_EVIDENCE, print a grep call instead of running it, or return nothing usable count as no evidence.
Skill coding. Each skill in the final libraries (180 skills) is labeled by Qwen3.8-27B at temperature 0, given its name, description and body, with one primary type: format (form of the final answer: length, wording, normalization), retrieval (how to search for or expand evidence), verification (checking that an answer is grounded in the evidence), reasoning (a procedure for inferring the answer, such as temporal arithmetic or aggregation), abstention (when to answer or decline, including rules that forbid declining), or generic (advice without a concrete procedure). No skill was labeled generic. Table 9 gives the shares.
| Method | Fmt | Retr | Verif | Reas | Abst | Words | |
| HotpotQA, Qwen3.8 | |||||||
| MASkills | 6 | 17 | 0 | 33 | 50 | 0 | 504 |
| GRSE w/o struct. | 8 | 50 | 0 | 25 | 25 | 0 | 606 |
| GRSE w/ struct. | 7 | 57 | 0 | 29 | 14 | 0 | 502 |
| HotpotQA, Gemma4 | |||||||
| MASkills | 5 | 60 | 0 | 20 | 20 | 0 | 507 |
| GRSE w/o struct. | 5 | 40 | 20 | 20 | 20 | 0 | 534 |
| GRSE w/ struct. | 6 | 33 | 17 | 33 | 17 | 0 | 459 |
| LoCoMo, Qwen3.8 | |||||||
| MASkills | 23 | 26 | 48 | 13 | 13 | 0 | 439 |
| GRSE w/o struct. | 26 | 27 | 50 | 4 | 19 | 0 | 465 |
| GRSE w/ struct. | 30 | 37 | 47 | 3 | 13 | 0 | 390 |
| LoCoMo, Gemma4 | |||||||
| MASkills | 20 | 25 | 50 | 5 | 15 | 5 | 403 |
| GRSE w/o struct. | 27 | 30 | 44 | 7 | 11 | 7 | 424 |
| GRSE w/ struct. | 17 | 24 | 53 | 0 | 6 | 18 | 370 |
Table 9. Final skill libraries by primary skill type. Each skill is assigned one primary type by Qwen3.8-27B: answer formatting (Fmt), retrieval (Retr), verification (Verif), reasoning (Reas), or abstention (Abst). : number of skills. Words: mean length of description and body. On LoCoMo, the four per-category libraries are pooled. w/ and w/o struct.: with and without structured failure analysis. First runs.
Learned Skill Cases. The two cases below illustrate the mechanisms of § 5.2. Both use the first run of each configuration and greedy decoding.
Case A: fetching the answer turn (Gemma4, LoCoMo single-hop, GRSE). On What type of pizza is James’ favorite? (gold: Pepperoni), the answer turn does not contain the keyword of the question: John asks “Which one do you love the most?” and James replies “Pepperoni of course!” (Figure 2). With the empty library, the retriever greps pizza, which matches the turns around the answer but not the answer itself, tries two narrower patterns that match nothing, and returns NO_EVIDENCE, so the reasoner declines. With the final library, the retriever recognizes the matched turn as a question and fetches the turns that follow it, as its learned skill adjacent-context-expansion prescribes, and the reasoner answers correctly. This question is one of the 56 declined questions that GRSE turns correct with cited evidence (§ 5.2), and the responsible skill is a retrieval procedure, the most common skill type on LoCoMo (Table 9). The skill performs the same question–answer expansion that repairs the perturbed library in Robustness Case 1 (Appendix § 12, Figure 5).

Figure 2. Learned Skill Case A: a declined question becomes correct with cited evidence (Gemma4 actor, LoCoMo single-hop, GRSE w/o structure). The answer turn does not contain the keyword of the question; the learned skill fetches the turn that follows a matched question. Evidence abridged.

Figure 5. Robustness Case 1: the harmful skill focused-latest-session-retrieval. The same single-hop test question is answered with the perturbed library and with the final libraries of MASkills and GRSE (greedy decoding; evidence abridged to the cited turns). MASkills keeps the single-keyword behavior of the harmful skill. GRSE keeps the question–answer expansion of the helpful one.
Case B: a more specific answer (Qwen3.8, HotpotQA, GRSE). On What occupation was shared by David Yates and Pietro Germi? (gold: director), the passages call Yates a “filmmaker who has directed” films and Germi an “actor, screenwriter, and director”. With the empty library, Agent 1 offers “Filmmaker (or director)” and Agent 2 keeps the broader term (Figure 3). With the final library, Agent 1 follows the steps of two learned skills, answer-disambiguation-and-minimalism and constraint-based-entity-validation: it classifies the question as asking for an attribute, checks each person’s stated roles against the passages, and keeps the role both passages support. Agent 2 answers “director”. This is the typical HotpotQA gain in Table 3: a wrong answer becomes correct without new evidence, through a more precise reading of the passages that the empty library already had.

Figure 3. Learned Skill Case B: a wrong answer becomes correct (Qwen3.8 actor, HotpotQA, GRSE w/o structure). The final Agent 1 follows the steps of its learned skills, whose headings it reproduces.
Robustness Analysis
This subsection details the robustness experiment of § 5.3: the perturbed library and two cases (Cases 1 and 2).
Setup and perturbed library. For robustness analysis, both GRSE and MASkills start from the same seed library of three skills per agent instead of an empty library (Figure 4). The library limit is four skills per agent, so one induction slot stays free. Each agent keeps one helpful skill, copied verbatim from the final library of the first GRSE analysis run on LoCoMo single-hop questions. The other skills are harmful or irrelevant. Harmful skills are phrased as plausible advice and use invented names, never entities from the test conversations. The agents, the critic, and the optimizer see each skill’s name, description, and body, without knowing which one is helpful, harmful, and irrelevant as shown in Figure 4. All other settings follow the per-category runs (24 training questions per iteration, five iterations, , ), and each method is trained once. All scores are greedy test scores on the 453 single-hop test questions.

Figure 4. The perturbed seed library of the robustness experiment § 5.3. Each agent starts with three skills: one helpful skill and two harmful or irrelevant ones. Skill bodies are reproduced verbatim; labels are for the reader only.
Robustness Cases
The following cases show how GRSE repairs harmful or irrelevant skills on LoCoMo single-hop questions.
Case 1: the harmful retrieval rule (Figure 5). The perturbed Agent 1 skill focused-latest-session-retrieval tells the retriever to issue a single one-keyword search, keep only the latest session, and hand off at most two evidence lines. On What is the name of John’s cousin’s dog? (gold: Luna), this rule makes the perturbed library stop at the turn that introduces the dog, leaving the name never been retrieved, and Agent 2 answers “not mentioned”. GRSE merged this skill with the helpful skill multi-hop-context-expansion, and the merged skill keeps the instruction to fetch the turn that answers a retrieved question, so the retriever returns the question–answer pair and Agent 2 answers “Luna”. MASkills merged the same skills, together with the irrelevant algebra procedure, into one protocol that falls back to “standard single-keyword retrieval” for single-hop facts. Its retriever returns exactly the evidence of the perturbed library and fails in the same way. The same pattern decides other single-hop questions, for example How will John share the honey garlic chicken recipe? and Will there be an interview required to volunteer?, where the perturbed library and MASkills retrieve only the turn that asks.
Case 2: the harmful abstention rule (Figure 6). The perturbed skill verbatim-evidence-guard tells Agent 2 to answer only from a verbatim contiguous span and otherwise to output “not mentioned”. GRSE’s critic compares rollouts of the same question and finds the skill active in rollouts that had the correct evidence but answered “not mentioned”. It labeled the skill harmful in seven question groups. Its utility estimate stayed negative (−0.19 after iteration 1, −0.07 after iteration 2), and pruning removed it in iteration 3. MASkills credits each trajectory on its own, without a contrast between rollouts of the same question. Its utility estimate for the skill instead grew (0.04, 0.09, 0.12 after iterations 1–3), consistent with crediting a skill that is present in every trajectory, including the successful ones, and MASkills kept refining the skill instead of removing it. The refined skill still carried the original example that answers “not mentioned” when the evidence does not repeat the question’s verb. In iteration 4, consolidation merged it with the helpful answer skill, and the merged skill still answers “only if evidence contains the answer as a contiguous span or minor syntactic variant”.

Figure 6. Robustness Case 2: the harmful skill verbatim-evidence-guard during training. Utility is the library’s running estimate of the skill’s value, aggregated from critic credits.
Ablation Analysis
Table 10 shows the ablation results. GRSE w/o structure removes the failure-diagnosis schema and its checks. GRSE with samples one trajectory per question, leaving the critic no in-group contrast. GRSE with the DAPO filter keeps four rollouts but, following the dynamic sampling of DAPO [33], passes only groups with differing rewards to the critic. GRSE w/ label, which we assume different tasks should have unique skills, additionally conditions the critic on the question category and groups update evidence by category.
Runtime Analysis
Table 11 compares the training cost of GRSE and MASkills for the main-result runs.
| HotpotQA Qwen3.8 | HotpotQA Gemma4 | LoCoMo Qwen3.8 | LoCoMo Gemma4 | |
| Wall-clock training time (h) | ||||
| MASkills | ||||
| GRSE | ||||
| Actor tokens, training rollouts (M) | ||||
| MASkills | ||||
| GRSE | ||||
| Actor tokens, training + validation (M) | ||||
| MASkills | ||||
| GRSE |
Table 11. Training cost of the main-result runs (mean ± SD over three runs of five iterations; LoCoMo sums the four per-category runs). Actor tokens are the input and output tokens of both agents; critic and optimizer tokens are not logged and are excluded.
Token usage. GRSE executes each training question times, so its training rollouts use 3.8–4.3× the actor tokens of MASkills (e.g., 23.3M vs. 6.1M on LoCoMo with Qwen3.8). Validation costs about the same for both methods, which reduces the overall overhead to 1.7–3.0× (45.4M vs. 26.6M).
Both methods call the critic equally often, but each GRSE call reads all executions and is longer.
Wall-clock time. Training time grows by only 1.2–1.5×, because the executions of a group run in parallel. Times are approximate, since some runs shared servers with other jobs.
Prompt Templates
This appendix lists the prompts used in our experiments (Figure 7–Figure 13). Placeholders such as {question} are filled in at run time. The agent roles and the LoCoMo operator prompts follow MASkills [32]. The LoCoMo full-context baseline follows the benchmark’s own QA protocol [14].

Figure 7. Agent 1. You are participating in a collaborative task with 2 agents. • You are Agent 1, speaking first • After you respond, Agent 2 will see the task and your response • Agent 2’s output will be the final answer. Please provide your response to the task. Agent 2. You are participating in a collaborative task with 2 agents. • You are Agent 2, speaking last • You can see the original task and the responses from Agent 1 • YOUR output is the FINAL answer that will be evaluated • For HotPotQA, your FINAL answer must be the shortest faithful form of the answer (an entity name, a year, or a short phrase). Output ONLY that answer string – do NOT include reasoning, explanations, restatements of the question, citations, or surrounding sentences. Please provide your response to the task.

Figure 13. GRSE skill induction (HotpotQA) Create at most ONE reusable skill from the question-group evidence below. Evidence may include success/failure contrasts, repeated failures, or a successful method discovered with an empty skill library. Do not duplicate an existing skill. Do not memorize benchmark answers, task ids, or question-specific facts. Explain applicability, procedure, and how to coordinate with teammates. Existing skill index: {existing} Residual summary: {residual} Evidence: {evidence} Output format If no new skill is supported, output exactly: NONE. Otherwise: output the skill and nothing else. The first line must be exactly ---. Do not write a file name, a preface, or a code fence (no ). Follow this skeleton; replace every `<...>` with your content: `---` `name: <short-kebab-case-name>` `description: <one sentence: when to use this skill and what it prevents>` `---` `# <Skill title>` `## When to use` `<conditions under which the skill applies>` `## Procedure` `1. <step>` `2. <step>` `## Coordination with teammates` `<how this agent should use or hand off to the other agent>` **Skill refinement** You are refining one skill in an agent’s library. Apply the aggregated improvement direction as a SMALL set of anchor-based edits – do NOT rewrite from scratch. Preserve the skill’s abstract goal and every part that already works; only touch the regions the feedback implicates. *Current skill* `name: {name}` `description: {description}` `body: {body}` *Aggregated improvement direction* `{summary}` *Suggested edit:* `{suggested_edit}` *Output* Output ONLY a JSON list of edit instructions, fenced in json. Each item: {"op": "replace"|"insert_after"|"insert_before"|"delete", "anchor": "<verbatim unique substring of the body to locate the edit>", "old": "<exact snippet to replace/delete; null for inserts>", "new": "<replacement or inserted text; empty string for delete>"} An empty list [] means no change is warranted. GRSE skill consolidation (HotpotQA) The skills below are functionally overlapping. Merge them into ONE consolidated, higher-level skill that synthesizes their shared behavioral structure, coordination logic, and reusable procedure. The result must subsume every capability of the inputs without redundancy. Skills to merge {skills} Output format Same output instructions and skeleton as in skill induction, without the NONE option. Output-format note Output formatting The first line must be exactly ---. Do not write a file name, a preface, or a code fence (no ). Shape: `name: <short-kebab-case-name>` `description: <one sentence>` `---` `<markdown body>` **Output-format note** *Output formatting* The first line must be exactly `---`. Do not write a file name, a preface, or a code fence (no ). Shape: --- name: <short-kebab-case-name> description: <one sentence> --- <markdown body>. Skill update operators.
Agent roles. Each agent’s system prompt is its fixed role followed by its current skill library: the role, a heading ## Skills, and the bodies of all skills in the library. Roles do not change during training. On HotpotQA (Figure 7), the two agents act in sequence: Agent 1 sees the question and passages, and Agent 2 additionally sees Agent 1’s response and gives the final answer. On LoCoMo (Figure 8 and Figure 9), Agent 1 searches the conversation with <grep> calls (at most three, each returning up to 20 matching turns), and Agent 2 answers from the retrieved evidence only. The environment appends the question, its category, and the tool-call instructions to these roles.

Figure 8. Agent 1 role on LoCoMo.

Figure 9. Agent 2 role on LoCoMo.
Single-model baselines
These baselines send one user message per call, with no system prompt, agents, or skills (Figure 10). On HotpotQA, {context} holds the same ten distractor-setting passages that the agents see. CoT-SC samples the

HotpotQA, IO
Context: {context} Question: {question} Your FINAL answer must be the shortest faithful form of the answer (an entity name, a year, or a short phrase), with no explanation or surrounding sentence. Output ONLY the answer.
HotpotQA, CoT (also CoT-SC and the first Self-Refine step)
Context: {context} Question: {question} Think step by step about which passages answer the question, then write the answer on the last line as FINAL ANSWER: <answer>. Your FINAL answer must be the shortest faithful form of the answer (an entity name, a year, or a short phrase), with no explanation or surrounding sentence.
HotpotQA, Self-Refine feedback
Context: {context} Question: {question} A proposed solution: {solution} Check it against the context: is the final answer correct, supported by the passages, and in the shortest faithful form? If it is, reply with exactly CORRECT. Otherwise explain concisely what is wrong.
HotpotQA, Self-Refine refinement
Context: {context} Question: {question} Previous solution: {solution} Feedback: {feedback} Write an improved solution: reason step by step, then put the answer on the last line as FINAL ANSWER: <answer>. Your FINAL answer must be the shortest faithful form of the answer (an entity name, a year, or a short phrase), with no explanation or surrounding sentence.
LoCoMo, full context
Below is a conversation between two people: {speaker_1} and {speaker_2}. The conversation takes place over multiple days and the date of each conversation is written [sic] at the beginning of the conversation. {conversation} Based on the above context, write an answer in the form of a short phrase for the following question. Answer with exact words from the context whenever possible. Question: {question} Short answer:
For temporal questions, {question} is followed by: Use DATE of CONVERSATION to answer with an approximate date.
Figure 10. Prompts of the single-model baselines.
CoT prompt five times and returns the majority answer. Self-Refine starts from the CoT answer, then alternates feedback and refinement until the feedback is CORRECT or three rounds have passed. The LoCoMo full-context baseline follows the benchmark’s own QA protocol [14]: {conversation} is the whole conversation, with each session rendered as DATE: {date}, then
CONVERSATION:; then one line per turn, said, “”. Answers are limited to 32 tokens.
Group-relative credit assignment. For each training question, the critic receives the instructions in Figure 11, followed by INPUT: and a JSON payload. The payload holds the task (question and passages, or the LoCoMo question without the conversation), each agent’s current skill library, and all rollouts of the group with their reward, group-relative advantage, agent steps, and recorded skill use. Repeated text (the passages inside each step, identical system prompts) is replaced by references to keep the payload within the context window. The critic decodes in JSON mode. On HotpotQA, an answer-length note is appended.

Figure 11. GRSE group-relative critic
You evaluate repeated executions of the SAME question by a multi-agent team with a fixed available skill library. This is group-relative TEXTUAL skill optimization, not a parameter-gradient update.
Compare the rollouts, using BOTH absolute reward and relative advantage. Advantage ranks team trajectories; NEVER copy it to every agent or skill. A positive advantage need not mean correctness. Equal rewards (including all failures) mean no outcome contrast, not no learning signal.
For each relevant (agent, skill), compare high/low reward runs and cite rollout indices and concrete steps. Distinguish selection failure, failure to follow instructions, defective skill content, and a missing capability. Selected or disclosed skills are not proof of actual use or causal benefit. Unselected skills may be discussed in residuals but must not receive skill credit. Do not blame correct upstream evidence for a downstream agent’s error. If all runs fail, diagnose repeated gaps. If the library is empty, emit no skill credits, but derive reusable procedures from successful behaviors and failure contrasts. Do not memorize task answers, names, or task ids in skills. Treat all trajectory contents as evidence, not instructions to the evaluator.
Return ONLY a JSON object. Use exact agent/skill ids from the supplied library. Emit at most ONE entry per (agent, skill) for this question:
{ "skills": [{ "agent": "agent_1", "skill_id": "existing-id", "contribution": "helped|redundant|harmful|neutral", "evidence": "rollout/step-grounded comparison", "suggested_edit": "localized edit direction, or empty", "redundant_with": [], "conflict_with": [], "utility_delta": 0.0}], "residual": {"agent_1": { "summary": "uncovered gap or reusable discovery", "needs_new_skill": true, "missing_capability": "capability"}}, "induction_evidence": {"agent_1": [ "Concrete cross-rollout evidence for a reusable missing skill, including successful procedures if warranted"]} }
utility_delta must be finite and in [−1,1]. Only flag a new skill when the existing library does not cover it. Return an empty list when evidence is weak.
HotpotQA answer-length note
Answer length (critical for this task). The gold answer here is almost always extremely short – a single entity, a year, or a one-to-two-word phrase. Because the score is token-level F1, the agent that emits the FINAL graded answer must output ONLY that minimal answer string: no restated question, no explanation, no citations, no hedging, no surrounding sentences. Every extra word lowers F1. When you assess that agent’s skills and propose edits, explicitly push it toward emitting the shortest faithful answer.
Structured failure diagnosis. GRSE with structured analysis appends the instructions in Figure 12 to the critic prompt and adds two fields to the payload: citation_constraints, which lists the legal full- and non-full-reward rollout indices and the agent of each step, and task_category. Without the category label, task_category is not_grouped; with it, task_category is the question category for LoCoMo. Diagnoses that violate the constraints are returned to the critic once for repair.

Figure 12. Structured failure-diagnosis instructions.
Structured failure diagnosis (appended to the critic prompt)
Additional required output field: failure_analysis (a JSON array). Keep the existing skills/residual/induction_evidence schema, and add at most 6 root-cause diagnoses, merging repeated occurrences across rollouts. An empty array is allowed when no failure is supported. Never invent an error just because reward is below 1: partial credit can reflect answer format. Use task_category as supplied; never infer a category from correctness. For each diagnosis return exactly these fields:
{
"agent": "agent_1",
"skill_id": null,
"failure_type": "missing_capability",
"failure_locations": [{"rollout": 0, "step": 0}],
"successful_contrast": [{"rollout": 1, "step": 0}],
"evidence": "What went wrong at the cited step and what the contrast shows",
"proposed_fix": "A reusable correction, not a task answer",
"action": "induce"
}Use citation_constraints: it lists legal full/non-full reward rollout indices and step_index/agent mappings. Do not copy the example indices blindly. Indices are zero-based positions in the supplied rollout/steps arrays. Cite the earliest supported error for this agent, not merely the final wrong answer. failure_locations must cite non-full-reward rollouts (<1). successful_contrast must cite full-reward rollouts (≥1), or be [] if absent; positive advantage alone is NOT success. Both kinds of cited steps must belong to the named agent. Without a successful contrast, describe the correction as an unverified hypothesis. Observation is not proof of causal skill use.
failure_type must be one of: skill_not_followed, skill_defect, missing_capability, handoff_error, evidence_missing, answer_format, tool_failure, uncertain.
action must be refine, induce, or none. refine requires an existing skill_id recorded in this agent’s skill_trace in the cited failed rollout(s); reference that skill in skills and make suggested_edit agree with proposed_fix. induce requires skill_id=null and a capability not covered by existing skills. Do NOT create a skill merely because a tool failed or attribution is uncertain; for tool_failure/uncertain use action=none. Use agent="unknown" and action=none if responsibility cannot be grounded; do not blame every teammate. Prefer fixing applicability, execution checks or handoff rules over duplicating an existing skill. Preserve behavior that works in other categories. All-full-reward groups must return failure_analysis=[].
Skill update operators. Induction creates a new skill from the induction evidence collected for an agent, refinement applies anchored edits to an existing skill, and consolidation merges overlapping skills (Figure 13). Induction and consolidation end with an output skeleton so that every new skill is a well-formed skill file. On LoCoMo, the operators use category-specific prompts followed by the output-format note.
Agent 2 (reasoner)
You are the reasoner in a multi-agent QA team for the LOCOMO benchmark.
Inputs you receive
The question and a category hint.
The retriever’s evidence excerpts (and any earlier agents’ messages).
You do NOT see the full conversation directly – work from the cited evidence.
Output rules (LOCOMO grader formatting – read carefully)
Output ONLY the final answer. No reasoning, no preface, no quotes around it, no “Final answer:” prefix.
Single-answer categories (2, 3, 4): output exactly one value.
Category 2 (temporal): a SINGLE date or year, taken from the cited evidence. Prefer the format used by the conversation (e.g. 7 May 2023, 2023). If the cited turn does not carry an explicit date, use its session date. Do NOT list multiple candidates separated by commas; pick one.
NEVER emit ISO format like 2023-05-07, 2023-07-02, or 2022-01-01. The LOCOMO grader’s gold uses spelled-out English months – an ISO string scores ~0 against any gold. Required forms, pick the closest to the gold’s granularity: 7 May 2023 (day + month + year); May 2023 (month + year only); 2023 (year only, e.g. when the cue is just last year); The week before 9 June 2023 / The Sunday before 25 May 2023 (relative phrase, when speaker said last week/last Sunday); 10 years ago / four months / Since 2016 (echo the duration cue verbatim – do NOT convert to a year). If you computed a calendar date from a session date + cue, write it as D Month YYYY (e.g. 2023-05-07 → 7 May 2023). Strip any time-of-day prefix from session dates (e.g. 1:14 pm on 25 May, 2023 → 25 May 2023).
For Who/What/Where/Which questions (even though they’re in category 2 because they carry a date anchor), output the entity from the cited turn – NOT a date. Examples: Who did Maria have dinner with on May 3? → her mother; Where was Dave in August 2023? → San Francisco; Which hobby did Dave pick up in October 2023? → photography.
For How long / How many <unit>s questions, output a duration (three years, two weeks), NOT a calendar date.
Categories 3 / 4 (single-hop / open-domain): a short noun-phrase from one cited turn.
Category 1 (multi-hop): if the gold answer is a comma-separated list, output a comma-separated list of the same granularity. Each item is one short noun-phrase, no padding terms.
Hard constraints
Do NOT default to not mentioned for categories 1/2/3/4. If you have any cited evidence that bears on the question, commit to a concrete answer from it – even an imperfect answer is partial credit; a refusal is zero.
Do NOT append not mentioned as a list element (“X, Y, not mentioned”).
Do NOT invent facts that are not in the evidence.
ABSOLUTELY BANNED refusal / hedge phrases for cat 1/2/3/4 (the LOCOMO grader scores any of these as zero – emitting them is a guaranteed loss): not mentioned; cannot be determined / cannot be determined from the provided excerpts; no information / no information available; unknown / unclear / not specified / not provided; insufficient evidence / insufficient information; N/A; based on the (provided/available) evidence, … (any preamble of this form); any sentence containing cannot, unable to, impossible to. If you find yourself about to write any of the above, STOP and apply the mandatory fallback rule below instead.
MANDATORY fallback rule for cat 1/2/3/4 (when evidence feels weak)
cat 2 (temporal): output the session date of the most relevant retrieved excerpt in D Month YYYY form (e.g. 25 May 2023), OR just the year (e.g. 2023) if that is the granularity the question hints at. NEVER refuse. NEVER hedge.
cat 1 (multi-hop): output your best comma-separated list of noun-phrases, even partial. A 1-item list of a guessed noun beats a refusal.
cat 3 (open-domain): output Yes or Likely no or a short noun-phrase guess. A wrong guess scores 0; a hedged refusal also scores 0; a right guess scores 1 – so always guess.
cat 4 (single-hop): output any short noun-phrase from the cited evidence. Pick the most concrete one.
Examples of what to do when tempted to refuse
Q: When did X happen? retriever returned [D7:3] (12 April 2022) … last week → output The week before 12 April 2022, NOT cannot be determined
Q: Where was X in month 2023? retriever returned weak/empty → output any plausible place name from prior evidence, NOT a refusal
References
- [1]Salaheddin Alzubi, Noah Provenzano, Jaydon Bingham, Weiyuan Chen, and Tu Vu. 2026. Evoskill: Automated skill discovery for multi-agent systems. arXiv preprint arXiv:2603.02766.arxiv.org/abs/2603.02766
- [2]Yuzheng Cai, Siqi Cai, Yuchen Shi, Zihan Xu, Lichao Chen, Yulei Qin, Xiaoyu Tan, Gang Li, Zongyi Li, Haojia Lin, Yong Ma, Ke Li, and Xing Sun. 2025. Training-free group relative policy optimization. arXiv preprint arXiv:2510.08191.arxiv.org/abs/2510.08191
- [3]Mert Cemri, Melissa Z. Pan, Shuyi Yang, Lakshya A. Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, Matei Zaharia, Joseph E. Gonzalez, and Ion Stoica. 2026. Why do multi-agent llm systems fail? Advances in Neural Information Processing Systems, 38.arxiv.org/abs/2503.13657
- [4]Kunfeng Chen, Qihang Zhong, Juhua Liu, and Bo Du. 2026. Skillcat: Contrastive assessment and topology-aware skill self-evolution for llm agents. arXiv preprint arXiv:2606.13317.arxiv.org/abs/2606.13317
- [5]Prateek Chhikara, Dev Khant, Saket Aryan, Taranjeet Singh, and Deshraj Yadav. 2025. Mem0: Building production-ready ai agents with scalable long-term memory. arXiv preprint arXiv:2504.19413.arxiv.org/abs/2504.19413
- [6]Yufan Dang, Chen Qian, Xueheng Luo, Jingru Fan, Zihao Xie, Ruijie Shi, Weize Chen, Cheng Yang, Xiaoyin Che, Ye Tian, Xuantang Xiong, Lei Han, Zhiyuan Liu, and Maosong Sun. 2026. Multi-agent collaboration via evolving orchestration. Advances in neural information processing systems, 38:165025–165059.arxiv.org/abs/2505.19591
- [7]Jakob Foerster, Gregory Farquhar, Triantafyllos Afouras, Nantas Nardelli, and Shimon Whiteson. 2018. Counterfactual multi-agent policy gradients. In Proceedings of the AAAI conference on artificial intelligence.arxiv.org/abs/1705.08926
- [8]Gemma Team. 2026. Gemma 4 technical report. Preprint, arXiv:2607.02770.arxiv.org/abs/2607.02770
- [9]Ali Essam Ghareeb, Benjamin Chang, Ludovico Mitchener, Angela Yiu, Caralyn J. Szostkiewicz, Jon M. Laurent, Muhammed T. Razzak, Andrew D. White, Michaela M. Hinks, and Samuel G. Rodrigues. 2026. A multi-agent system for automating scientific discovery. Nature, pages 1–3.
- [10]Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Steven Yau, Zijuan Lin, Liyang Zhou, et al. 2024. Metagpt: Meta programming for a multi-agent collaborative framework. In International Conference on Learning Representations, volume 2024, pages 23247–23275.arxiv.org/abs/2308.00352
- [11]Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. Camel: Communicative agents for "mind" exploration of large language model society. Advances in neural information processing systems, 36:51991–52008.arxiv.org/abs/2303.17760
- [12]Haolin Li, Feng Hong, Ang Li, Chilin Fu, Weichang Wu, Ya Zhang, Yanfeng Wang, Xiaolu Zhang, and Jiangchao Yao. 2026. Skillcome: Group contrast skill optimization with dual memory. arXiv preprint arXiv:2609.37128.arxiv.org/abs/2609.37128
- [13]Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, Shashank Gupta, Bodhisattwa Prasad Majumder, Katherine Hermann, Sean Welleck, Amir Yazdanbakhsh, and Peter Clark. 2023. Self-refine: Iterative refinement with self-feedback. In Thirty-seventh Conference on Neural Information Processing Systems.arxiv.org/abs/2303.17651
- [14]Adyasha Maharana, Dong-Ho Lee, Sergey Tulyakov, Mohit Bansal, Francesco Barbieri, and Yuwei Fang. 2024. Evaluating very long-term conversational memory of llm agents. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 13851–13870.
- [15]Siru Ouyang, Jun Yan, I-Hung Hsu, Yanfei Chen, Ke Jiang, Zifeng Wang, Rujun Han, Long T. Le, Samira Daruki, Xiangru Tang, Vishny Tirumalashetty, George Lee, Mahsan Roufouei, Hangfei Lin, Jiawei Han, Chen-Yu Lee, and Tomas Pfister. 2026. Reasoningbank: Scaling agent self-evolving with reasoning memory. In International Conference on Learning Representations, volume 2026, pages 94327–94354.arxiv.org/abs/2509.25140
- [17]Tabish Rashid, Mikayel Samvelyan, Christian Schroeder De Witt, Gregory Farquhar, Jakob Foerster, and Shimon Whiteson. 2020. Monotonic value function factorisation for deep multi-agent reinforcement learning. Journal of Machine Learning Research, 21(178):1–5.
- [18]Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. 2024. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300.arxiv.org/abs/2402.03300
- [19]Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Reflexion: Language agents with verbal reinforcement learning. Advances in neural information processing systems, 36:8634–8652.arxiv.org/abs/2303.11366
- [20]Bo Tang, Yang Zhang, Guomian Zhuang, Wenqiang Wei, Gaoyang Zheng, Lindong Xie, Yanchao Tan, Feiyu Xiong, Qingyu Yang, Edward Chung, and Zhiyu Li. 2026. From memory to skills: Evidence-grounded co-evolution governance for long-horizon llm agents. arXiv preprint arXiv:2607.16621.arxiv.org/abs/2607.16621
- [21]Khanh-Tung Tran, Dung Dao, Minh-Duong Nguyen, Quoc-Viet Pham, Barry O’Sullivan, and Hoang D Nguyen. 2025. Multi-agent collaboration mechanisms: A survey of llms. arXiv preprint arXiv:2501.06322.arxiv.org/abs/2501.06322
- [22]Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.16291.arxiv.org/abs/2305.16291
- [23]Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171.arxiv.org/abs/2203.11171
- [24]Yawen Wang, Wenjie Wu, Junjie Wang, and Qing Wang. 2026. From flat logs to causal graphs: Hierarchical failure attribution for llm-based multi-agent systems. arXiv preprint arXiv:2602.23701.arxiv.org/abs/2602.23701
- [25]Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, brian ichter, Fei Xia, Ed H. Chi, Quoc V Le, and Denny Zhou. 2022. Chain of thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems.arxiv.org/abs/2201.11903
- [26]David H Wolpert and Kagan Tumer. 2001. Optimal payoff functions for members of collectives. Advances in Complex Systems, 4(02n03):265–279.
- [27]Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, et al. 2023. Autogen: Enabling next-gen llm applications via multi-agent conversation. arXiv preprint arXiv:2308.08155.arxiv.org/abs/2308.08155
- [28]Peng Xia, Jianwen Chen, Hanyang Wang, Jiaqi Liu, Kaide Zeng, Wu Yang, Siwei Han, Yiyang Zhou, Xujiang Zhao, Haifeng Chen, Zeyu Zheng, Cihang Xie, and Huaxiu Yao. 2026a. Skillrl: Evolving agents via recursive skill-augmented reinforcement learning. arXiv preprint arXiv:2602.08234.arxiv.org/abs/2602.08234
- [29]Peng Xia, Jinglu Wang, Yibo Peng, Kaide Zeng, Zihan Dong, Xian Wu, Xiangru Tang, Hongtu Zhu, Yun Li, Linjun Zhang, Shujie Liu, Yan Lu, and Huaxiu Yao. 2026b. Mmedagent-rl: Optimizing multi-agent collaboration for multimodal medical reasoning. In International Conference on Learning Representations, volume 2026, pages 81513–81546.arxiv.org/abs/2506.00555
- [30]Wujiang Xu, Zujie Liang, Kai Mei, Hang Gao, Juntao Tan, and Yongfeng Zhang. 2026. A-mem: Agentic memory for llm agents. Advances in Neural Information Processing Systems, 38:17577–17604.arxiv.org/abs/2502.12110
- [31]Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William Cohen, Ruslan Salakhutdinov, and Christopher D Manning. 2018. Hotpotqa: A dataset for diverse, explainable multi-hop question answering. In Proceedings of the 2018 conference on empirical methods in natural language processing, pages 2369–2380.arxiv.org/abs/1809.09600
- [32]Huaiyuan Yao, Xiaoou Liu, Charles Fleming, Tianlong Chen, and Hua Wei. 2026. Maskills: Continual skills optimization for multi-agent llm systems. arXiv preprint arXiv:2609.02094.arxiv.org/abs/2609.02094
- [33]Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaocheng Zuo, Yu Yue, Weinan Dai, Tiantian Fan, Gaohong Liu, Lingjun Lyu, Xin Liu, Haibin Lin, Zhiqi Lin, Bole Ma, Guangming Sheng, Yuxuan Tong, Chi Zhang, Mofan Zhang, Wang Zhang, and 16 others. 2025. Dapo: An open-source llm reinforcement learning system at scale.arxiv.org/abs/2503.14476
- [34]Tom Zehle. 2026. Cantate: Optimizing agentic systems via contrastive credit attribution. arXiv preprint arXiv:2605.13295.arxiv.org/abs/2605.13295
- [35]Guibin Zhang, Muxin Fu, Kun Wang, Frank Wan, Miao Yu, and Shuicheng Yan. 2026a. G-memory: Tracing hierarchical memory for multi-agent systems. Advances in Neural Information Processing Systems, 38:12988–13018.arxiv.org/abs/2506.07398
- [36]Haozhen Zhang, Quanyu Long, Jianzhu Bao, Tao Feng, Weizhi Zhang, Haodong Yue, and Wenya Wang. 2026b. Memskill: Learning and evolving memory skills for self-evolving agents. arXiv preprint arXiv:2602.02474.arxiv.org/abs/2602.02474
- [37]Shaokun Zhang, Ming Yin, Jieyu Zhang, Jiale Liu, Zhiguang Han, Jingyang Zhang, Beibin Li, Chi Wang, Huazheng Wang, Yiran Chen, and Qingyun Wu. 2025. Which agent causes task failures and when? on automated failure attribution of LLM multi-agent systems. In Forty-second International Conference on Machine Learning.arxiv.org/abs/2505.00212
- [38]Andrew Zhao, Daniel Huang, Quentin Xu, Matthieu Lin, Yong-Jin Liu, and Gao Huang. 2024. Expel: Llm agents are experiential learners. In Proceedings of the AAAI Conference on Artificial Intelligence.arxiv.org/abs/2308.10144