acceptodds
Under review as a conference paper at ICLR 2027

FedRuleMem: Federated Memory for LLM Agents via Executable Rules

Abstract

Large Language Model (LLM) agents typically remember experience through episodic replay or retrieval-augmented prompting. These mechanisms increase inference cost and expose detailed interaction records when shared across users. We propose FedRuleMem, a federated agent-memory system that shares executable rules: compact, stateless programs that check candidate actions and return corrective feedback. Clients synthesize rules from local failures, verify their behavior, and apply Minimum Description Length (MDL) pruning before upload. The server deduplicates retained rules and broadcasts a global library, which clients re-validate against subsequent local evidence. Raw interaction records remain local, and the acting LLM stays frozen, enabling black-box use. Across nine independent end-to-end runs on Crafter and ALFWorld, FedRuleMem reaches a Crafter Score of and ALFWorld success of , outperforming the matched federated textual-rule control ( and ). On Crafter, the final library occupies  MB per client, and end-to-end token use is k per task. These results support executable rules as compact shared memory for action correction across clients.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Agentic AI, Federated learning, Symbolic AI

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_7N4tOpenReview ↗
Rating
3(+1)
Confidence
3(+1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

FedRuleMem proposes a federated memory system for frozen LLM agents that exchanges executable action-precondition rules instead of trajectories or model updates. Clients synthesize rules from local failures, check executability and consistency with observed outcomes, and prune them using a greedy MDL objective. The server performs exact and comment-based semantic deduplication before broadcasting a shared library. During interaction, rules provide feedback for bounded action revision, with an exploration bypass.

The paper evaluates the system on Crafter and ALFWorld over nine independent end-to-end runs. Compared with the matched FedTextRule control, it reports improvements from 11.4 to 13.5 in Crafter Score and from 62.4% to 64.8% in ALFWorld success. Additional experiments examine efficiency, component contributions, model sensitivity, client heterogeneity, cross-client transfer, and injected conflicts.

Critical strengths

The executable memory interface is concrete and useful for frozen agents. Rules provide explicit action checks and localized corrective feedback without requiring parameter updates or repeatedly interpreting long trajectory histories. The comparison with FedTextRule matches federation, MDL filtering, and the correction budget, making it more informative than comparisons against no-memory agents alone. On Crafter, the reported end-to-end token cost also decreases from 69.6k to 61.9k per task.

The evaluation includes meaningful controls for the benefits of sharing and verification. The paper reports nine complete runs, separately ablates behavioral verification, MDL, and deduplication, and tests heterogeneous client distributions. The experiment withholding a task family from one recipient improves success from 44.2% with Local Rules to 58.6% using rules learned by other clients, providing direct evidence of cross-client transfer. These experiments support the usefulness of the overall pipeline, even though they do not fully resolve the reliability concerns below.

Critical weaknesses

The aggregation and recipient-side rejection mechanisms do not adequately establish reliable reuse across heterogeneous clients. Equation (11) clusters rules using embeddings of their comments and retains the rule with the longest comment. Similar descriptions do not establish equivalent executable predicates, so consolidation can discard complementary conditions or retain a less appropriate representative. Appendix E.2 acknowledges this possibility, but the evaluation does not directly quantify coverage lost or false rejections introduced by semantic merging. Moreover, Equation (1) and Algorithm 1 replace every client's acting library with the global broadcast. A locally rejected rule can therefore return if another client retains and uploads it; the manuscript does not specify a persistent recipient-specific veto. Table 12 demonstrates mitigation of injected conflicts, but does not sufficiently explain whether recurring, client-dependent conflicts survive rebroadcast. This is consequential because controlling the propagation of incorrect rules is a central motivation for the federated design.

The evidence for reusable rule validity remains limited by the learning and evaluation protocol. New rules are synthesized from current-round failures and checked against positives and failures from the same round. Passing this gate establishes consistency with observed evidence, rather than correctness on unseen states. Appendix G also states that all 134 ALFWorld tasks are evaluated each round and redistributed across clients. This is a reasonable online-adaptation protocol, but redistribution does not create a globally untouched evaluation set. The recipient-held-out-family experiment supports transfer between clients; it does not by itself establish generalization to task instances unseen by every client. Independent measurements of rule false-rejection rates and failure coverage would help distinguish reusable preconditions from constraints fitted to repeatedly encountered tasks. Given the modest improvement over the closest textual control, these unresolved questions limit the strength of the contribution and motivate my weak-rejection recommendation.

Questions for authors
  1. Recipient-side rejection: If client A rejects a rule but client B retains it, does the next broadcast cause A to execute that rule again? Is there a persistent local rejection list or applicability mask? Please explain how Table 12 handles repeated rebroadcast of rules that are valid for some clients but invalid for others.

  2. Semantic consolidation: What changes in failure coverage and false-rejection rate occur before and after semantic deduplication? Is there evidence that choosing the longest-comment representative preserves the behavior of discarded rules? The exact-only ablation measures aggregate performance, but does not directly establish merge correctness.

  3. Generalization protocol: Are there results with a frozen learned library evaluated on task instances or Crafter seeds unseen by all clients during synthesis and verification? For the recipient-held-out-family experiment, please specify whether recipient evaluation outcomes subsequently enter rule learning or validation, and whether the reported result measures the first exposure.

5 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer 7N4t (1/3)

Thank you for the constructive review. Tables R9–R11 below are rebuttal tables. Results are mean ± sample standard deviation over nine runs. Manuscript revisions are blue.

Q1. (a) Can rejected rules return? (b) Is there a persistent rejection list or mask? (c) How does the paper's Table 12 handle repeated rebroadcast? (Critical Weakness, paragraph 1; supplementary evidence: sustained-conflict experiment)

(a) Rule return. A rule rejected by A can return through B's upload. Original FedRuleMem revalidates inherited rules against cumulative evidence after interaction and before upload. This raises affected-recipient success from 49.2% to 58.9% under recurring conflicts, a 9.7-point gain (Rebuttal Table R9).

(b) Persistent masking. The original method has no persistent pre-use mask; interaction uses bounded regeneration and the ϵ\epsilon bypass. Without this extension, it already achieves 64.8% main ALFWorld success and 63.7% frozen-transfer success (paper Table 1; Rebuttal Table R11).

(c) Protocol of the paper's Table 12. At 30% injection, original FedRuleMem achieves 61.2±1.6%61.2\pm1.6\% versus 50.4±2.5%50.4\pm2.5\% without recipient revalidation (paper Table 12). Conflicts are injected once at the end of round 8, after server deduplication and before broadcast. Clients use the perturbed library in round 9, then revalidate inherited rules against cumulative evidence before upload and aggregation. “Rejected at next local gate” measures this check, which the control omits. Round-10 scoring uses the round-9 broadcast, pooling all 134 attempts across 16 clients.

Supplementary evidence for (a)–(c): sustained conflicts. In the new experiment, fixed-identity conflicts repeatedly replace approximately 30% of a source client's unique canonicalized upload rules in rounds 2–10, preserving pool size. Injection precedes server deduplication; the rules are valid in designated source scenarios and invalid in designated recipient scenarios.

Rebuttal Table R9. Recipient performance under repeated rebroadcast of conflicting rules.

Repeated-conflict conditionRound-10 affected-recipient success (%)
No recipient revalidation49.2 ± 2.7
Original FedRuleMem58.9 ± 1.9
FedRuleMem + persistent local exclusion, new extension62.5 ± 1.3

Each run pools the actual round-10 attempts of eight affected recipients (approximately 67), using the round-9 broadcast.

The persistent-exclusion extension blocks rules contradicted by successful local outcomes on later broadcasts. Identity uses action type, schema version, and canonicalized code; modified programs are rechecked against stored counterexamples.

Persistent exclusion further raises success to 62.5%, adding 3.6 points (Rebuttal Table R9).

AuthorsOpenReview ↗

Rebuttal to Reviewer 7N4t (2/3)

Q2. (a) What changes in failure coverage and false-rejection rate occur before and after semantic deduplication? (b) Is there evidence that the longest-comment representative preserves discarded rules' behavior? (Critical Weakness, paragraph 1; supplementary evidence: library size and task performance)

(a) Diagnostic changes. Semantic selection reduces false rejection of successful actions from 1.5% to 1.2% while retaining 87.5% failure coverage across source and recipient contexts. Both libraries use identical independent ALFWorld pairs from episodes/configurations excluded from synthesis, selection, and tuning. Labels come from environment execution, including actions the rules would block.

Rebuttal Table R10. Independent behavioral diagnostics of semantic consolidation.

Source: New ALFWorld diagnostic; mean ± sample standard deviation across nine learned libraries. “Before” follows exact deduplication. Each run uses 1,000 failed and 2,000 successful actions, including 500 failed and 1,000 successful recipient actions.

Evaluation scopeMetric (%)Before semantic selectionAfter semantic selection
Source + recipientFailure coverage ↑89.4 ± 2.287.5 ± 2.3
Source + recipientFalse acceptance of incorrect actions ↓10.6 ± 2.212.5 ± 2.3
Source + recipientFalse rejection of successful actions ↓1.5 ± 0.61.2 ± 0.5
Recipient onlyFailure coverage ↑86.8 ± 2.884.4 ± 3.0
Recipient onlyFalse rejection of successful actions ↓2.0 ± 0.81.6 ± 0.7

Any rejecting rule constitutes library rejection. Coverage and false acceptance partition failed actions; false rejection uses successful actions. Source + recipient counts are pooled within each run.

(b) Behavioral retention. Coverage decreases by 1.9 points and false rejection by 0.3 points; recipient-only decreases are 2.4 and 0.4 points, respectively (Rebuttal Table R10). This quantifies the tradeoff of the longest-comment heuristic, which selects one existing rule per action-conditioned cluster.

The separate end-to-end ablation gives a 32.2% smaller mean library with higher mean task success: exact-only versus full aggregation yields 34.8±2.434.8\pm2.4 versus 23.6±1.923.6\pm1.9 rules and 64.1±1.0%64.1\pm1.0\% versus 64.8±0.8%64.8\pm0.8\% ALFWorld success (paper Table 6). These complete runs complement the fixed-pool behavioral diagnostic.

Q3. (a) Are there frozen results on tasks or Crafter seeds unseen by all clients? (b) Was recipient-held-out evaluation first exposure? (c) Did its feedback later enter learning? (Critical Weakness, paragraph 2: generalization protocol)

(a) Original FedRuleMem achieves 63.7 ± 1.3% on globally unseen ALFWorld configurations, exceeding Local Rules by 6.4 points and original FedTextRule by 6.3 (Rebuttal Table R11). All 134 test instances and their 47 configurations are excluded from every client's construction data. We learn with 16 clients, 10 rounds, and 134 attempts per round, then freeze memory; test feedback supports only the current episode and never enters learning, verification, or cross-task updates.

Rebuttal Table R11. New configuration-disjoint frozen ALFWorld experiment.

MethodSuccess (%)
Local Rules57.3 ± 1.9
Original FedTextRule57.4 ± 1.6
Original FedRuleMem63.7 ± 1.3

Our original repeated-attempt ALFWorld setting follows an established paradigm used by Reflexion, Retroformer, QuBE with Reflexion, and CDMem. The new experiment additionally tests globally unseen configurations.

(b) Yes: the earlier result measures A's first evaluation batch on a held-out family. A excludes that family in rounds 1–9; other clients can learn it. In round 10, the round-9 broadcast yields 58.6 ± 1.6%, versus 44.2 ± 2.4% with A's local memory from other families (paper Appendix B.4). Memory remains fixed across the batch; feedback is used within episodes.

(c) Only after the whole batch is scored do its trajectories enter cumulative evidence for round-10 learning and verification.

Critical Weakness, paragraph 2: independent rule validity

Independent diagnostics give 87.5% failure coverage / 1.2% successful-action false rejection, and 84.4% / 1.6% on recipients (Rebuttal Table R10). Online verification uses cumulative evidence including synthesis examples; the diagnostic pairs exclude synthesis, selection, and tuning episodes/configurations. Together with frozen transfer (Rebuttal Table R11), these results assess validity beyond learning evidence.

AuthorsOpenReview ↗

Rebuttal to Reviewer 7N4t (3/3)

Critical Weakness, paragraph 2: gains over the textual control

The new verified-text control confirms gains of 1.9 Crafter Score points and 3.2 ALFWorld points: FedRuleMem scores 13.5 / 64.8% (paper Table 1), versus 11.6 / 61.6% in the new rebuttal experiment. Both gates require cumulative failure coverage and no rejection of observed successful actions. Crafter cost per task is 61.9k tokens / 60.8 seconds (paper Table 16), versus 84.6k / 84.0 for new verified text: 26.8% fewer tokens and 27.6% less time in complete runs.

Reviewer_ELpxOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes FedRuleMem, a federated memory for LLM agents in which each client distils its failures into executable rules, small programs that check a candidate action and return feedback and a suggestion. Clients verify candidate rules against their own logged outcomes, prune them with a minimum description length criterion and upload only the retained rules, while the server deduplicates and broadcasts a global library that clients re-check in the next round. The acting LLM stays frozen and raw trajectories never leave the client. With 16 clients and nine runs on Crafter and ALFWorld, FedRuleMem scores above FedTextRule and Local Rules, and on Crafter its library takes 0.031 MB per client and it uses fewer tokens per task than FedTextRule.

Critical strengths
  1. Storing shared agent memory as executable action checks is a sound idea, because a check can be tested against a client's own logged outcomes without any LLM call. The paper uses this property to address the failure mode it names for federation, a wrong rule spreading to every client, by checking rules against observed outcomes before upload and after broadcast, while MDL pruning and deduplication control library size. This division of roles is what other work on federated agent memory can reuse.
  2. The paper is clear about what the federated setting adds and what it does not. The controls are organized around what crosses the client boundary, and Local Rules, centralized pooling and FedTextRule, which shares the federated schedule, MDL gate and correction budget, are compared over nine runs with standard deviations. The limitations section also says plainly that the protocol gives data minimization without formal privacy guarantees.
Critical weaknesses
  1. The comparison with FedTextRule does not show that the executable format itself is what helps. Section 4.3 states that this comparison evaluates behavioral verification and execution jointly, and executable rules without behavioral verification score 56.0% on ALFWorld, below the 62.4% of FedTextRule (Table 6 against Table 1). Execution enables these checks without LLM calls, but equivalent behavioral verification of textual rules is not reported, so the comparison cannot show that the gain needs execution. On Crafter the Score gap (13.5 ± 2.4 against 11.4 ± 2.0) lies between the two reported standard deviations and the Reward gap (8.9 ± 1.6 against 8.5 ± 1.9) is below both, and no significance test is reported. The results support the combined pipeline but do not isolate execution, and that gap is the main reason for my recommendation.
  2. The main ALFWorld evaluation repeats the same tasks, so it does not establish transfer to tasks unseen by the federation. Appendix G states that all 134 tasks are evaluated every round and repartitioned across the 16 clients, giving ten attempts per task across the federation over ten rounds, and the rules that fix a task's failures can come from earlier attempts at that same task. Appendix B.4, whose heading includes unseen-task transfer, reports a client with no local examples from a held-out task family, but it does not establish that the evaluated tasks were unseen by the other clients. The ALFWorld protocol therefore permits fixes to be reused on previously attempted tasks and leaves transfer to tasks no client has attempted untested.
Questions for authors
  1. Is there a result for textual rules that pass an equivalent behavioral verification, in which the frozen LLM judges each rule against the same observed outcomes before upload? That comparison would help separate the contribution of execution from behavioral verification.
  2. What is ALFWorld success on tasks that no client attempted during the ten rounds, for example when rules are learned on a training split and the 134 tasks are evaluated once?
  3. Eq. (1), Algorithm 1 line 16 and the statement in Section 3 that rules retained by other clients may be broadcast again mean that each client acts with the full broadcast library. At round 10, what fraction of a client's acting library consists of rules that rejected an action the same client had observed to succeed?
  4. Section 5 separates FedRuleMem from WALL-E by emphasizing constraints rather than skills, yet WALL-E (NeurIPS 2025) also learns action rules as executable checks, tests them against observed transitions and prunes them by coverage, and RIMRULE (ACL 2026) selects rules learned from failures with an MDL objective. Which parts of the executable memory interface in contribution (i) differ from these two works? References for the works named above: Siyu Zhou, Tianyi Zhou, Yijun Yang, Guodong Long, Deheng Ye, Jing Jiang, and Chengqi Zhang. WALL-E: World Alignment by NeuroSymbolic Learning improves World Model-based LLM Agents. Advances in Neural Information Processing Systems 38 (NeurIPS 2025). DOI 10.52202/085713-2192. Xiang Gao, Yuguang Yao, Qi Zhang, Kaiwen Dong, Avinash Baidya, Ruocheng Guo, Hilaf Hasson, and Kamalika Das. RIMRULE: Improving Tool-Using Language Agents via MDL-Guided Rule Learning. Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), ACL 2026. DOI 10.18653/v1/2026.acl-long.1599.
4 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer ELpx (1/2)

Thank you for the constructive review. Tables R6–R8 below are rebuttal tables. Results are mean ± sample standard deviation over nine runs. Manuscript revisions are blue.

Q1. How does FedRuleMem compare with behaviorally verified text? (Critical Weakness 1: verification and execution)

FedRuleMem retains advantages of 1.9 Crafter Score points and 3.2 ALFWorld percentage points (Rebuttal Table R6). The new control matches behavioral acceptance criteria: each rule must cover a cumulative failure and reject no recorded successful action. Both use cumulative evidence for verification and MDL, matched models, task partitions, seeds, and budgets (M=16M=16, W=10W=10, ϵ=0.25\epsilon=0.25, L=5L=5).

The textual critic uses the actor's model snapshot (GPT-5 on Crafter; GPT-4o-mini on ALFWorld), judging rule violations on unlabeled pairs; a local program applies the gate using environment outcomes. The comparison evaluates complete pipelines.

Rebuttal Table R6. Behavioral verification added to FedTextRule.

MethodCrafter ScoreALFWorld success (%)Source
Original FedTextRule11.4 ± 2.062.4 ± 0.9Paper Table 1
FedTextRule + behavioral verification11.6 ± 2.161.6 ± 1.0New rebuttal experiment
FedRuleMem13.5 ± 2.464.8 ± 0.8Paper Table 1

The paper's verification ablation explains why synthesized code needs screening: removing behavioral verification, while retaining execution and MDL, gives 56.0 ± 2.2% versus 64.8 ± 0.8% for full FedRuleMem (paper Table 6). The new control shows the advantage persists when text receives the same acceptance criteria.

FedRuleMem also saves 26.8% of Crafter tokens and 27.6% of time: 61.9k tokens/60.8 seconds per task (paper Table 16), versus 84.6k/84.0 for the new verified-text control, including learning, verification, and inference. Executable checks need no LLM judgment calls.

Q2. What is success on tasks excluded from every client's memory construction? (Critical Weakness 2)

Our original repeated-attempt ALFWorld setting follows an established paradigm used by Reflexion, Retroformer, QuBE with Reflexion, and CDMem.

For the new frozen experiment, all 134 test instances and their 47 configurations are excluded from every client's memory construction. We learn with 16 clients, 10 rounds, and 134 attempts per round, then freeze memory. Test feedback supports the current episode only; it never enters synthesis, verification, tuning, or cross-task updates.

Rebuttal Table R7. New configuration-disjoint frozen ALFWorld experiment.

MethodSuccess (%)
Local Rules57.3 ± 1.9
Original FedTextRule57.4 ± 1.6
Original FedRuleMem63.7 ± 1.3

Original FedRuleMem gains 6.4 points over Local Rules and 6.3 over original FedTextRule, demonstrating sharing benefits beyond encountered configurations.

Q3. What fraction of the round-10 acting library consists of previously contradicted rules?

4.17 ± 0.79% in standard ALFWorld runs: 1.01 ± 0.23 known-conflicting rules among 24.22 ± 2.05 rules per client immediately before round 10. A conflicting rule rejects a previously successful local state–action pair. We average counts and fractions across all 16 clients within each run, then across nine runs; these are new supplementary measurements.

Local rejection removes a rule from that client's next upload, but another client can rebroadcast it. Revalidation occurs after interaction and before upload.

In a separate repeated-conflict experiment, original revalidation improves success by 9.7 points; persistent exclusion adds 3.6 points (Rebuttal Table R8).

Rebuttal Table R8. New repeated-conflict ALFWorld experiment.

MethodAffected-recipient success (%)
No recipient revalidation49.2 ± 2.7
Original FedRuleMem58.9 ± 1.9
FedRuleMem + persistent exclusion, new extension62.5 ± 1.3

Fixed-identity conflicts replace approximately 30% of the unique canonicalized rules in a source client's upload pool in rounds 2–10, preserving pool size. They are valid in designated source scenarios and invalid in recipient scenarios. Each run pools round-10 attempts across eight affected recipients (approximately 67, using the actual denominator), acting with the round-9 broadcast. Persistent exclusion blocks historically contradicted rules from later acting libraries. Main and frozen-transfer gains already hold without this extension.

AuthorsOpenReview ↗

Rebuttal to Reviewer ELpx (2/2)

Q4. Which parts of the executable memory interface differ from WALL-E and RIMRULE?

FedRuleMem contributes executable shared memory and a framework for learning, sharing, and applying it across frozen agents. WALL-E aligns one agent's world model using executable rules; RIMRULE selects failure-derived rules with MDL for textual prompt injection. Our clients share programs providing action checks and repair feedback, verify inherited/new rules against cumulative outcomes before upload, and consolidate them at the server while keeping trajectories local.

Original-paper evidence: sharing raises ALFWorld success 59.0% → 64.8%; against original FedTextRule, Crafter Score rises 11.4 → 13.5 and ALFWorld success 62.4% → 64.8% (paper Table 1). The new frozen experiment preserves a 6.4-point sharing advantage (Rebuttal Table R7).

Reviewer_ELpxOpenReview ↗

Thank you for the response

Thank you for the detailed response and new experiments, which address my main concerns; I have raised my rating to 3 and encourage the authors to include these results in the paper.

AuthorsOpenReview ↗

Thank you for your constructive feedback

Thank you for your thoughtful feedback and careful reassessment. We will incorporate the additional results and experimental protocols into the revised manuscript. Your suggestions have helped us clarify the contribution and strengthen the empirical evidence.

Reviewer_tNyYOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents a practical way to share reusable rules across LLM agents without updating model parameters. The experiments include useful controls and show gains in task performance and efficiency. However, the contribution seems largely incremental, and repeated use of the same evaluation tasks limits the evidence for generalization. Rule retention, client-specific rejection, and comment-based deduplication also need clearer justification. The textual baseline does not fully separate the benefits of code execution from behavioral verification. Overall, the system looks useful, but stronger controls and previously unseen tasks are needed to establish what the proposed memory mechanism adds beyond existing approaches.

Critical strengths

1 The setting is practical. Sharing small rules while keeping the acting LLM frozen makes the approach usable with API-only models, without requiring gradient access or exchanging full trajectories.

2 Checking generated rules before sharing them is a sensible design choice. The ablations show that behavioral verification makes a substantial difference, so this part of the pipeline has clear empirical support.

3 The experiments include nine complete runs and several useful controls, including local rules, federated textual memory, and matched revision budgets. This gives a better picture of performance than a comparison with a basic no-memory agent alone.

4 The held-out-family experiment provides useful evidence of cross-client transfer. A client’s success rises from 44.2% to 58.6% using rules learned by other clients, suggesting that sharing can help when local experience is missing.

5 The efficiency gains are encouraging. The method uses fewer tokens and less time than FedTextRule on Crafter, even after including amortized rule-learning costs, while keeping the final rule library small.

Critical weaknesses

The idea is useful, but most of the pieces already exist. It is still unclear what the federation setting adds beyond combining rule learning, filtering, and sharing.

1 The same 134 ALFWorld tasks are used across rounds. This makes it hard to tell whether the agents learn rules that transfer to new tasks or mainly get better at tasks the system has already seen.

2 The handling of old rules needs more explanation. A rule rejected by one client can come back through another client’s upload. A useful rule also seems liable to be dropped if it covers no failures in the current round—even when that is because the rule has helped avoid those failures.

3 Similar comments do not necessarily mean two rules do the same thing. Keeping the rule with the longest comment could remove a different, useful precondition. I would like to see how much coverage is lost during this step.

4 The comparison with FedTextRule changes both how rules are represented and how they are checked. It is therefore hard to tell how much of the gain comes from executing code and how much comes from better filtering before the rules are shared.

Questions for authors

What is the substantive methodological advance over combining executable rule learning, as in WALL-E 2.0, with federated experience sharing, as in FICAL? How does the proposed rule lifecycle differ from scope-aware approaches such as FedWorld?

Since the same 134 ALFWorld tasks are used across rounds, what evidence distinguishes generalizable rule learning from adaptation to repeatedly encountered task configurations? Could the final frozen library be evaluated on configurations unseen by every client during memory construction?

Equations (1) and (11) assign the same broadcast library to every client. If one client rejects a rule that another client retains, what prevents that rule from being repeatedly reintroduced? Is there any persistent client-specific exclusion or scope mechanism, and when is a received rule first validated relative to its use?

Equation (7) requires a retained rule to cover at least one observed failure. What happens when a useful rule prevents its associated failures and therefore has no failure coverage in the current round? Does verification retain historical support, and how is this reconciled with the round-specific evidence sets?

Are rule synthesis and behavioral verification performed on separate examples? What are the false-rejection and failure-detection rates on held-out state–action pairs, particularly after transfer to another client?

How does comment-based clustering distinguish redundant rules from complementary preconditions for the same action? What justifies selecting the rule with the longest comment, and how much behavioral coverage is lost during semantic deduplication?

Since FedTextRule differs in both representation and behavioral verification, could the authors provide a verification-matched textual control that isolates the effect of executing code rules?

How are the description lengths in Equation (8) instantiated, and how sensitive is selection to these choices? For efficiency, what reuse count is used to amortize learning, and what are the cumulative upload and download costs across all rounds?

3 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer tNyY (1/3)

Thank you for the constructive review. Tables R1–R5 below are rebuttal tables. Results are mean ± sample standard deviation over nine runs. Manuscript revisions are blue.

Q1. (a) What advances beyond combining WALL-E 2.0 with FICAL? (b) How does the lifecycle differ from FedWorld? (Critical Weakness: novelty)

(a) FedRuleMem introduces executable shared memory and a framework for learning, sharing, and applying it across frozen agents. WALL-E keeps executable knowledge within one agent; FICAL shares textual tool-use summaries. Our clients share compact programs that check actions and return repair feedback, with behavioral verification, MDL pruning, and server consolidation; raw trajectories stay local.

The original experiments support this contribution: sharing improves ALFWorld success 59.0% → 64.8% over Local Rules. Against original FedTextRule, Crafter Score improves 11.4 → 13.5 and ALFWorld success 62.4% → 64.8% (paper Table 1), while Crafter cost falls 69.6k → 61.9k tokens/task (paper Table 16).

(b) FedWorld infers applicability scopes for transition rules and fills compatible gaps. FedRuleMem shares executable action checks and revalidates inherited rules against cumulative local evidence during learning.

Q2. Does frozen memory generalize to configurations unseen by every client during construction? (Critical Weakness 1)

Yes: 63.7 ± 1.3% success, exceeding Local Rules by 6.4 points and original FedTextRule by 6.3 points (Rebuttal Table R1). All 134 test instances and their 47 configurations are excluded from every client's memory construction. We learn with 16 clients over 10 rounds (1,340 attempts per run), then freeze memory. Test feedback supports the current episode only and never enters synthesis, verification, or cross-task updates.

Rebuttal Table R1. New frozen-memory ALFWorld experiment.

MethodSuccess (%)
Local Rules57.3 ± 1.9
Original FedTextRule57.4 ± 1.6
Original FedRuleMem63.7 ± 1.3

Our original repeated-attempt ALFWorld setting follows an established paradigm used by Reflexion, Retroformer, QuBE with Reflexion, and CDMem. The new frozen experiment additionally tests globally unseen configurations.

Q3. (a) Can rejected rules return? (b) Is there persistent exclusion or scope control? (c) When are received rules validated? (Critical Weakness 2)

In the new ALFWorld conflict experiment, original revalidation raises affected-recipient success from 49.2% to 58.9%, a 9.7-point gain without persistent exclusion (Rebuttal Table R2).

(a) A locally rejected rule can return through another client's upload.

(b) The original method has no persistent pre-use mask; interaction uses bounded regeneration and the ϵ\epsilon bypass. The additional persistent-exclusion variant blocks historically contradicted rules from later acting libraries.

(c) Received rules are validated after local interaction and before upload, using cumulative local evidence.

Rebuttal Table R2. New repeated-conflict ALFWorld experiment.

MethodAffected-recipient success (%)
No recipient revalidation49.2 ± 2.7
Original FedRuleMem58.9 ± 1.9
FedRuleMem + persistent exclusion, new extension62.5 ± 1.3

Fixed-identity conflicts replace approximately 30% of the unique canonicalized rules in a source client's upload pool in rounds 2–10, preserving pool size. They are valid in designated source scenarios and invalid in recipient scenarios. Each run pools round-10 attempts across eight affected recipients (approximately 67, using the actual denominator), acting with the round-9 broadcast. Persistent exclusion adds 3.6 points; the main and frozen-transfer results already hold without it.

Q4. (a) What happens to useful rules with zero current-round coverage? (b) Is historical support retained despite round-specific evidence definitions? (Critical Weakness 2)

(a) Useful rules with zero current-round coverage. A useful rule retains its historical failure support even when it prevents those failures in later rounds. For an unchanged rule, an earlier covered failure remains in the cumulative evidence. Zero current-round coverage therefore does not erase its eligibility. New successful counterexamples and MDL selection still determine which candidates are retained.

(b) Historical support and the evidence definitions. In the evaluated implementation, inherited rules remain candidates, and verification and MDL use cumulative local evidence:

Ej,±≤r=⋃q=1rEj,±q.\mathcal E_{j,\pm}^{\le r}=\bigcup_{q=1}^{r}\mathcal E_{j,\pm}^{q}.

We have clarified this cumulative-evidence definition in Section 3.3 and Algorithms 1 and 3.

AuthorsOpenReview ↗

Rebuttal to Reviewer tNyY (2/3)

Q5. (a) Are synthesis and verification examples separate? (b) What are independent failure-detection and false-rejection rates, particularly at recipients?

(a) Synthesis uses current-round failures; online verification checks cumulative evidence that includes those examples.

(b) Independent ALFWorld diagnostics give 87.5 ± 2.3% failure coverage and 1.2 ± 0.5% successful-action false rejection after deduplication; recipient-only rates are 84.4 ± 3.0% and 1.6 ± 0.7% (Rebuttal Table R3). Diagnostic episodes/configurations are excluded from synthesis, selection, and tuning.

Q6. (a) How does clustering distinguish redundancy from complementary preconditions? (b) Why the longest comment? (c) How much coverage is lost? (Critical Weakness 3)

(a) We cluster comments within each action type, using comment similarity as a proxy for redundancy. The fixed-pool diagnostic in (c) measures the behavioral effect of removing rules.

(b) We use the longest-comment heuristic to select one existing rule per action-conditioned cluster.

(c) Coverage decreases by 1.9 points while successful-action false rejection decreases by 0.3 points across source and recipient contexts (Rebuttal Table R3).

Rebuttal Table R3. New independent ALFWorld diagnostic: before → after semantic selection.

ScopeMetric (%)BeforeAfter
Source + recipientFailure coverage ↑89.4 ± 2.287.5 ± 2.3
Source + recipientFalse acceptance of incorrect actions ↓10.6 ± 2.212.5 ± 2.3
Source + recipientFalse rejection of successful actions ↓1.5 ± 0.61.2 ± 0.5
Recipient onlyFailure coverage ↑86.8 ± 2.884.4 ± 3.0
Recipient onlyFalse rejection of successful actions ↓2.0 ± 0.81.6 ± 0.7

Each of nine libraries is tested on identical before/after samples: 1,000 failed and 2,000 successful actions, including 500/1,000 recipient actions. “Before” follows exact deduplication. Labels come from environment execution, including otherwise-blocked actions; any rejecting rule constitutes library rejection. Coverage and false acceptance partition failed actions; false rejection uses successful actions. Counts are pooled within each run before computing rates.

The separate end-to-end ablation reduces mean library size by 32.2%, from 34.8±2.434.8\pm2.4 to 23.6±1.923.6\pm1.9 rules, with success 64.1±1.0%→64.8±0.8%64.1\pm1.0\%\to64.8\pm0.8\% (paper Table 6). This complements the fixed-pool behavioral diagnostic.

Q7. Can a verification-matched textual control isolate the effect of executing rules? (Critical Weakness 4)

FedRuleMem gains 1.9 Crafter Score points and 3.2 ALFWorld percentage points over verified text (Rebuttal Table R4). Complete runs match collection policies, acceptance criteria, and interaction/synthesis budgets. Both methods check all cumulative evidence: each rule must cover a failure and reject no successful action; MDL uses cumulative coverage.

The textual critic uses the actor's model snapshot (GPT-5 on Crafter; GPT-4o-mini on ALFWorld) to judge unlabeled state–action pairs. A local program applies the gate using recorded outcomes.

Rebuttal Table R4. Behavioral verification added to FedTextRule.

MethodCrafter ScoreALFWorld success (%)Source
Original FedTextRule11.4 ± 2.062.4 ± 0.9Paper Table 1
FedTextRule + behavioral verification11.6 ± 2.161.6 ± 1.0New rebuttal experiment
FedRuleMem13.5 ± 2.464.8 ± 0.8Paper Table 1

Crafter tokens decrease by 26.8% and time by 27.6%: FedRuleMem uses 61.9k tokens/60.8 seconds per task (paper Table 16), versus 84.6k/84.0 for new verified text. Both include learning, verification, and inference. Executable checks return corrective feedback without LLM judgment calls.

AuthorsOpenReview ↗

Rebuttal to Reviewer tNyY (3/3)

Q8. (a) How are Equation (8)'s costs instantiated? (b) How sensitive is selection? (c) What reuse count amortizes learning? (d) What are cumulative upload/download costs?

(a) The MDL-inspired objective uses 32 byte-equivalent units per rule header, normalized program UTF-8 length BρB_\rho, and 256 byte-equivalent units per uncovered cumulative failure. Normalization standardizes formatting/function identifiers, removes comments/docstrings, and preserves predicates, constants, and feedback/suggestion strings. Dividing the objective by 256 preserves selection:

+\left|\mathcal E_-^{\le r}\setminus C(R)\right|.$$ $C(R)$ is the union of failures covered by retained rules, so overlap receives no double credit. Greedy selection adds the largest strictly positive-gain rule (paper Equation (9)). **(b) Halving or doubling the rule-complexity weight changes mean success by at most 0.9 points**, while changing library size (Rebuttal Table R5). **Rebuttal Table R5. New MDL sensitivity experiment; multiplier affects only rule cost.** | Multiplier | Final rules | ALFWorld success (%) | | --- | ---: | ---: | | 0.5 | 32.4 ± 2.9 | 64.3 ± 1.0 | | 1, default | 23.6 ± 1.9 | 64.8 ± 0.8 | | 2 | 17.2 ± 1.6 | 63.9 ± 1.2 | **(c) 3,200 task attempts per complete Crafter run**, with 16 clients and 10 rounds. Learning, verification, and inference costs are divided by this count within each run, then averaged across runs. Paper Table 16 reports **58.3k inference + 3.6k learning = 61.9k tokens/task**, versus **64.7k + 4.9k = 69.6k** for original FedTextRule: 6.4k of the 7.7k saving comes from inference. **(d)** New accounting across all clients and rounds gives **3,201,294 ± 295,588 uploaded bytes**, **3,824,005 ± 329,802 downloaded bytes**, and **7,025,299 ± 305,116 total bytes per run**. Totals are summed within each run before computing mean/std. Final per-client storage is separately **0.031 MB** (paper Appendix I).

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.