acceptodds
Under review as a conference paper at ICLR 2027

Does Execution Order Imply Causality? Federated Post-Training of Asynchronous LLM Agents over Execution Posets

Abstract

Language model agents often execute multiple tools and subtasks concurrently, while the resulting traces remain distributed across private clients. Federated adaptation allows these clients to improve a shared agent without centralizing their execution data. However, existing methods usually convert each execution into a single token sequence. In asynchronous environments, independent events may finish in different orders because of tool latency, queueing, or local scheduling. As a result, two clients can complete the same execution, observe the same tool outputs, and make the same decision, yet store the intermediate events in different orders. Sequential training treats these order differences as different positions and contexts, which produces different local gradients from the same causal execution. We call this problem interleaving heterogeneity. To address it, we propose TopoFed-Agent, which represents each execution as a partial order certified by runtime evidence. During local adaptation, each event attends only to its causal ancestors, uses a position determined by its causal rank, and receives supervision attached to the event itself. In this way, changing the legal storage order of independent events does not change the learning problem. We prove that, for a fixed certified execution, all legal serializations produce identical predictions, losses, and parameter gradients. Therefore, gradient differences caused only by client schedulers are eliminated. Experiments across four execution structures and five Transformer initializations show that sequential training yields relative full-parameter gradient deviations ranging from 0.26 to 0.46 across legal serializations, whereas TopoFed-Agent keeps the deviation below \(2.31\times10^-16\).

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Agent;Federated learning

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_xGXJOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper studies federated post-training of LLM agents that run several tools at once. Independent tool calls can finish in different orders, so clients may store the same execution in different orders. Sequential training then gives these clients different gradients for the same execution. The authors call this interleaving heterogeneity. The proposed TopoFed-Agent rebuilds each execution as an execution poset from runtime records. During training, each event attends only to its causal ancestors, positions come from causal rank, and each target is attached to its own event. The authors prove that all legal orders of a fixed poset give the same gradients. Experiments on AppWorld and Gaia2 show higher task success than the baselines.

Critical strengths

Strength 1. The paper clearly defines when two stored traces are the same execution. The fix only changes how each client encodes its own data. The server and the communication cost stay the same, and the extra training cost is small. This matters because the method would be easy to adopt if order effects prove harmful in practice.

Strength 2. If the runtime records cannot show that two events are independent, the method keeps their stored order. The paper proves that this rule never removes a true dependency when the existing records are correct. Its experiments also show that missing records hurt much less than wrong ones. This matters because real runtime records may be incomplete.

Critical weaknesses

Weakness 1. The results do not mean that removing order differences causes the gains. At β=0\beta = 0, all clients use the same uniform scheduler, so no client has its own order preference. Also TopoFed-Agent still beats Seq-FedAvg on AppWorld. Canonical-LE also removes order differences by fixing one order per execution, but it still scores lower than TopoFed-Agent. On the Qwen2.5-1.5B model, gradients from different orders point in nearly the same direction. These things suggest that most of the gain comes from another source.

Weakness 2. The novelty is limited. The invariance theorem follows from the known permutation equivariance of attention. The mechanism is close to DAG Transformers, tree attention in speculative decoding, and Parallel Context Windows, but the paper does not explain how it differs from them. A simpler fix is to give all clients one shared canonical order. The paper argues that different canonical rules give different objectives, but one shared rule causes no disagreement between clients.

Questions for authors
  1. At β=0\beta = 0, no client has its own order preference, yet TopoFed-Agent still beats Seq-FedAvg by more than 10 points on AppWorld. What causes this gain? How much of it remains when each of the three components is removed?

  2. The experiments list only dependency sources as runtime relations, and without evidence of independence the method essentially reduces to sequential training on the stored order. How is independence between events established in AppWorld and Gaia2, and what fraction of executions has more than one legal order?

2 comments

We thank the reviewer for the direct questions about the source of the performance gains, the novelty relative to existing structured-attention methods, and the practical recovery of independent events. We have added component ablations, expanded the canonical-order analysis, and reported runtime evidence and graph-recovery statistics on AppWorld and Gaia2.

Q1. Why does TopoFed-Agent improve over Seq-FedAvg at β = 0, and how much of the gain remains when individual components are removed?

At β = 0, clients sample uniformly from the ready set, so there is no persistent client-specific scheduler preference. However, each execution is still realized and stored as one sampled legal sequence. Sequential training therefore remains sensitive to the order of independent events: the order changes preceding context and physical positions, and next-token supervision can associate targets with different packed rows. Table 5 reports 24.0% TGC for Seq-FedAvg and 35.8% for TopoFed-Agent at β = 0, an 11.8-point difference. Random-LE obtains 31.9% TGC with Δg = 0.38, while Canonical-LE obtains 30.5% with Δg below 10⁻⁵. The complete method obtains 35.8% with Δg below 10⁻⁵ under both β = 0 and β = 2.5. Thus, the gain is not attributed only to removing client-specific scheduler preferences; it also reflects causal-context modeling and event-local target alignment. Table 3 reports the requested mask-only control: M alone obtains 26.2% Test-N and 13.3% Test-C TGC, compared with 35.8% and 22.1% for M+R+T. R-only obtains 23.7%/11.3%, and T-only 23.1%/11.7%; M+R, M+T, and R+T obtain 29.6%/16.4%, 31.0%/17.4%, and 27.3%/14.3%, respectively. Table 5 also gives a progressive comparison from Canonical-LE: adding M raises TGC from 30.5% to 31.7%, adding R raises it to 33.2%, and adding event-local T reaches 35.8%. These results quantify the separate and joint contributions of attention scope, causal positions, and event-bound supervision.

Q2. How is independence established in AppWorld and Gaia2, and what fraction of executions has more than one legal order?

Appendix A.1–A.2 specifies the runtime evidence and conservative recovery procedure, and Table 6 reports the statistics. The constructor starts from certified dependency edges. For event pairs that remain unrelated, it removes the observed order only when independence is positively certified; otherwise, it adds the observed order, checks acyclicity, and computes transitive closure. Evidence includes program order, tool-call/result links, explicit consumption, message send/receive relations, fork/join information, and versioned read/write conflicts. Events remain unordered only when the records establish that neither consumes the other's output nor conflicts on accessed state. Textual similarity and timestamps are not independence evidence. Missing records therefore retain observed order and reduce concurrency rather than declaring events independent. Evidence-source coverage is 100.0% for program order on both benchmarks, 97.6%/98.4% for tool-call/result links on AppWorld/Gaia2, 64.3%/71.5% for explicit consumption, and 47.1%/53.6% for versioned read/write conflicts. Table 6 contains 1,200 AppWorld traces and 960 Gaia2 traces. The fraction with multiple legal extensions is 67.3% and 75.0%, with mean execution widths of 2.7 and 3.5. Under completion-order replay, graph agreement is 94.2% and 91.6% with full available provenance, and 87.9% and 84.6% at provenance completeness ρ = 0.6. These measurements quantify both the prevalence of concurrency and the effect of incomplete provenance on graph recovery.

Concern on novelty relative to DAG Transformers, tree attention, and parallel context methods.

Permutation equivariance is the tool used to prove the invariance result, not the full contribution. Existing DAG and partial-order attention methods provide structured visibility, while PCW and tree-based methods organize parallel branches or shared prefixes. TopoFed-Agent addresses a different setting: federated post-training of asynchronous agents from private runtime traces, where the system must recover dependencies from runtime evidence and preserve the same decision context, position, and target across legal serializations. The revised comparisons include PCW-adapted, Hasse-mask, and Tree Training-adapted, alongside APE and Set-Based Prompting. Table 1 shows that these baselines retain varying levels of gradient sensitivity, whereas TopoFed-Agent supports arbitrary legal extensions with logits, losses, and gradients invariant to numerical precision. The execution graph and traces remain on each client, and the server receives the ordinary federated update. This positions the contribution at the intersection of runtime-grounded dependency recovery, event-level supervision, and federated agent adaptation, with permutation equivariance providing the theoretical foundation for the invariance guarantee.

Thank you for the detailed response. But the new ablations show that the gain over Canonical-LE comes from the modeling choices, not from removing interleaving heterogeneity, so I will maintain my score.

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

The paper studies a meaningful source of heterogeneity in federated agent training and presents a coherent design with a reasonably strong invariance argument. I also appreciate the compatibility with standard federated pipelines and the combination of controlled and interactive evaluations. My main concerns are about the scope of the claims and several missing technical details. The guarantee assumes a fixed recovered graph, but incomplete provenance can make graph construction itself depend on event order. The benefit over a shared deterministic canonical ordering also needs to be established more clearly. In addition, the paper does not sufficiently specify online inference or show that its invariant surrogate yields a valid policy update. Finally, the convergence analysis appears to omit client-sampling variance, potentially affecting the stated bound. These are substantive issues that require more than presentation changes. Overall, my recommendation is Weak Reject.

Critical strengths
  1. This paper addresses a practical problem in asynchronous agent training. Distinguishing execution semantics from incidental recording order is useful and can help explain a source of client disagreement beyond conventional task and data heterogeneity.

  2. The main idea is intuitive, and the three components have clear roles. Ancestor attention controls the visible context, causal ranks control positional information, and event-local supervision prevents target assignment from changing with the physical packing order.

  3. The central invariance result has a relatively solid theoretical foundation. The argument based on mask conjugacy and Transformer permutation equivariance is clear, and the discussion of RoPE, dropout, floating-point computation, and truncation helps establish the scope of the guarantee.

  4. The method is compatible with existing federated training pipelines and does not require clients to upload execution graphs or traces. The combination of controlled execution structures and interactive agent benchmarks is also appropriate for studying both the mechanism and its practical relevance.

Critical weaknesses
  1. The paper should distinguish invariance conditional on a fixed recovered graph from invariance of the complete trace-processing pipeline. Under the conservative construction, missing independence certificates can cause different observed orders of the same execution to produce different recovered graphs. Retaining all true dependencies does not establish that these recovered graphs are identical. The relationship between runtime dependencies and the information actually available to the agent also needs clarification. The distinction between a partial causal order and a consistent total order in [1] would be useful here.

  2. The contribution beyond deterministic canonicalization and existing DAG representations needs clearer positioning. A fixed canonical ordering that depends only on the execution graph already removes dependence on the original recording order. Different canonicalizers may induce different objectives, but this does not invalidate the scheduler invariance provided by a shared rule. It would be better to explain the additional learning value of arbitrary legal packings and provide a more direct technical comparison with [2] and [3], which are already cited in the paper.

  3. More details are needed to establish training-inference consistency and compatibility with policy optimization. Ancestor attention, causal ranks, and event anchors change how the policy conditions on its history, but the online construction and cache-update procedures are not sufficiently specified. Attaching an advantage to an event establishes invariance of a fixed surrogate; it does not, by itself, establish that the update is a valid policy gradient for the deployed agent. The behavior-policy probabilities, importance ratios, and KL terms should be defined explicitly, following the distinction between data collection and surrogate optimization in [4].

  4. The federated analysis should separate agreement of expected gradients from agreement of independently sampled client gradients. Appendix C.8 should also distinguish within-client gradient noise from variance introduced by client sampling. If the noise term includes only within-client sampling, the stated second-order dependence on the step size appears insufficient to capture partial-participation effects. The treatment of heterogeneity, local drift, and participation in [5] provides a useful reference. Please see the corresponding question below.

[1] Lamport, L. (2019). Time, clocks, and the ordering of events in a distributed system. In Concurrency: the Works of Leslie Lamport (pp. 179-196).

[2] Dong, Z., Zhang, M., Li, F., & Chen, Y. (2022, June). Pace: A parallelizable computation encoder for directed acyclic graphs. In International conference on machine learning (pp. 5360-5377). PMLR.

[3] Li, C., & Guo, H. (2026). Hasse Diagrams for Attention: A Partial Order Framework for Designing Transformer Masks. arXiv preprint arXiv:2606.09951.

[4] Schulman, J., Wolski, F., Dhariwal, P., Radford, A., & Klimov, O. (2017). Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347.

[5] Karimireddy, S. P., Kale, S., Mohri, M., Reddi, S., Stich, S., & Suresh, A. T. (2020, November). Scaffold: Stochastic controlled averaging for federated learning. In International conference on machine learning (pp. 5132-5143). PMLR.

Questions for authors

Please see weakness section.

1 comment

We thank the reviewer for these technical questions.

Concern 1. Invariance conditional on a fixed recovered graph versus invariance of the complete trace-processing pipeline.

Appendix A.1–A.2 and Sections 5.8 and D.2–D.4 distinguish these levels. Theorem 1 is conditional on a fixed recovered graph; it does not claim that incomplete provenance always yields the same graph across completion orders. An observed ordering relation is removed only with positive evidence from program order, message/tool links, consumption, fork/join records, or versioned read/write conflicts; similarity and timestamps are insufficient. Unresolved pairs retain observed order, so missing certificates may reduce legal extensions or produce different conservative graphs. Among 1,200 AppWorld and 960 Gaia2 traces, 67.3% and 75.0% have multiple legal extensions. Graph agreement is 94.2% and 91.6% with full provenance, and 87.9% and 84.6% at ρ = 0.6. Appendix D.4 tests missing and false independence certificates at four error rates; false certificates can remove ancestors. The partial order encodes causal constraints, whereas an observed trace is one linear extension. A total order alone does not establish causality for every pair. Each decision uses ancestors available at its decision cut.

Concern 2. Contribution beyond deterministic canonicalization and existing DAG representations.

Sections 5.2, 5.7, C.9, and D.1 compare Canonical-LE with structural methods. A shared canonicalizer does remove dependence on recording order, and we use it as a scheduler-invariant baseline. It selects one extension and trains on its induced contexts and positions; different canonicalizers can define different objectives for the same poset. Figure 6 tests three event-ID tie-breaking rules. Table 5 reports 30.5% Test-N TGC for Canonical-LE, 31.7% for +M, 33.2% for +M+R, and 35.8% for +M+R+T; TopoFed-Agent obtains 35.8% under fixed and arbitrary packings. We also compare PCW-adapted, Hasse-mask, and Tree Training-adapted. PCW uses parallel context windows, Hasse-mask dependency-aware visibility, and tree packing shared-prefix reuse. PACE targets parallelizable DAG computation; our setting is federated adaptation with private traces and event-specific targets. Our contribution combines runtime dependency recovery, ancestor visibility, causal ranks, and event-bound targets.

Concern 3. Online inference, training–inference consistency, and policy optimization.

Appendix A.6–A.7 specifies online execution; Section 5.8 evaluates consistency. Each tool call, result, or decision receives a persistent event identifier; the runtime appends certified dependencies, retains observed order for unresolved pairs, and updates causal ranks. A decision attends only to currently available ancestors. The cache is keyed by event identity and ancestor context; newly discovered dependencies invalidate affected descendant entries before the next decision, while committed decisions are not revised. For policy optimization, the action, behavior-policy probability, and advantage are attached to the decision event. Given ancestor context C_v, r_v(θ) = π_θ(a_v | C_v) / π_beh(a_v | C_v), and the clipped surrogate and policy KL use the same context. The behavior policy must have collected the action using that causal information. Event binding alone does not make a trace collected under a different sequential context an unbiased policy-gradient sample; such traces use the specified supervised or verifier-weighted objective. Table 7 shows that poset-aware inference improves AppWorld TGC from 33.1% to 35.8% and Gaia2 Pass@1 from 19.7% to 21.9%, with 8% additional latency.

Concern 4. Expected-gradient heterogeneity, local stochastic noise, client sampling, and local drift.

Appendix C.7 separates the expected sequential gradient into a common-reference term and a scheduler-induced shift. Its variance includes an interaction term of either sign; thus, removing scheduler dependence need not reduce every sequential objective's variance. For a fixed graph, Theorem 1 removes dependence on client-specific serialization distributions. Corollary 1 gives zero scheduler-only expected-gradient heterogeneity when clients share the semantic distribution and recovered graph; task/data heterogeneity remains. Appendix C.8 adds variance from sampling M of K clients uniformly without replacement. Its coefficient is (K−M)/(M(K−1)) times the population variance of client expected gradients, and remains with noise-free local gradients. The local-SGD bound also includes within-client noise and local drift of order η²L²H²(σ² + ζ_rem²). For K = 20 and M = 5, the coefficient is 15/95. Nonuniform participation requires unbiased weighting and is outside this expression. The analysis separates scheduler variation, local noise, sampling variance, and local drift.

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

This paper proposes TopoFed-Agent, which uses execution dependencies to make federated LLM agent training consistent across different orderings of independent events.

Critical strengths
  • The paper studies a clear and relevant problem: different orders of independent events can lead to different training updates.
  • The method is well structured and addresses order dependence in attention, position encoding, and training labels together.
  • The theoretical analysis explains why legal reorderings preserve predictions, losses, and gradients under the stated assumptions.
  • The experiments combine controlled tests with agent benchmarks, and include ablations, robustness checks, and training cost measurements.
Critical weaknesses
  1. Limited comparison with closely related methods. The paper does not compare against an adapted structural order-invariant method such as Set-Based Prompting (Order-Independence Without Fine Tuning, NeurIPS 2024). A comparison on shared fork–join structures would help clarify the contribution beyond existing attention-mask and positional-index designs. Although Random-LE is included, evaluating multi-order training under a matched compute budget would also strengthen the comparison.

  2. Limited evaluation across model scales. The controlled experiments use a tiny, untrained Transformer, while the agent experiments rely on a single Qwen2.5-1.5B backbone with LoRA. These results provide useful initial evidence, but do not establish whether order sensitivity and downstream gains persist in larger models. The theoretical invariance guarantee alone does not imply consistent performance improvements across scales. Evaluation on at least one larger backbone would strengthen the practical claims.

Questions for authors

See the weeknesses.

2 comments

We thank the reviewer for the positive assessment of the problem formulation and the three-part design. We have expanded the comparison with training-free order handling and multi-order optimization, and added end-to-end evaluation with Qwen2.5-7B-Instruct.

Concern 1. Comparison with Set-Based Prompting and multi-order training under a matched compute budget.

We have added Set-Based Prompting to the controlled and end-to-end comparisons in Tables 1 and 2. In Table 1, it obtains small output/loss deviations on designated independent subsets: for fork-join, Δz = 8.70×10⁻⁴ and ΔL = 1.20×10⁻³; for two chains, 6.10×10⁻⁴ and 9.40×10⁻⁴; for layered, 4.80×10⁻⁴ and 7.20×10⁻⁴; and for unequal chains, 7.90×10⁻⁴ and 1.10×10⁻³. APE has larger but still reduced deviations, ranging from 7.60×10⁻³ to 1.42×10⁻² for Δz and 1.21×10⁻² to 2.17×10⁻² for ΔL. These results make clear that Set-Based Prompting is effective on the designated independent subsets, but does not cover arbitrary legal extensions of the complete execution poset. In the downstream evaluation, Seq-FedAvg + APE obtains 22.6% Test-N TGC, 10.8% Test-C TGC, and 11.8% Gaia2 Pass@1; Seq-FedAvg + Set-Based Prompting obtains 23.3%, 11.2%, and 12.1%, while TopoFed-Agent obtains 35.8%, 22.1%, and 21.8%. The controlled comparison also reports the four-structure deviations for each method, so the comparison covers both event-aligned output/loss sensitivity and downstream task utility. We also add Order Averaging in Appendix C.10 and D.6. It evaluates B ∈ {1, 2, 4, 8, 16, 24} legal serializations from one parameter snapshot and averages their gradients before the optimizer step. At a fixed snapshot, the expected gradient-estimation error decreases proportionally to 1/B; this does not imply a proportional gain in final task performance. Figure 12 compares gradient error, local compute, and AppWorld Test-N TGC under the same cumulative GPU-time budget. As B grows, gradient error decreases, but each serialization adds a forward/backward pass and leaves fewer optimizer updates under the fixed budget. Table 4 gives the per-update cost: Order Averaging with B = 2 and B = 4 requires 36.82 s and 72.96 s, compared with 19.21 s for TopoFed-Agent. Thus, the matched-budget study evaluates gradient approximation together with downstream utility, while Table 4 quantifies the additional local computation.

Concern 2. Evaluation across model scales.

We have added Qwen2.5-7B-Instruct as a second end-to-end backbone in Table 2, using rank-16 LoRA with scaling factor 32, zero dropout, bfloat16, and four A100 80GB GPUs. The 1.5B model remains the main backbone, while 7B provides model-scale validation under the same federated evaluation protocol. For the 1.5B model, TopoFed-Agent reaches 35.8% Test-N TGC, 24.6% Test-N SGC, 22.1% Test-C TGC, 12.5% Test-C SGC, and 21.8% Gaia2 Pass@1. It improves over Random-LE by 4.4, 3.4, and 3.1 percentage points on Test-N TGC, Test-C TGC, and Gaia2 Pass@1, respectively. On Qwen2.5-7B, TopoFed-Agent achieves 43.3 ± 0.9% AppWorld Test-N TGC, 31.1 ± 0.9% Test-N SGC, 29.0 ± 0.8% Test-C TGC, 18.6 ± 0.4% Test-C SGC, and 30.8 ± 1.3% Gaia2 Pass@1. Compared with Random-LE, the gains are 5.7, 4.1, 3.5, 4.1, and 4.4 percentage points; compared with Canonical-LE, they are 6.0, 5.1, 5.6, 4.5, and 5.3 points. Compared with Seq-FedAvg, the gains are 16.1, 14.4, 13.8, 11.1, and 15.1 points. TopoFed-Agent reaches the validation-loss threshold in 19 communication rounds, compared with 24 for Random-LE and 43 for Seq-FedAvg, and obtains final loss 0.44, compared with 0.49 and 0.70. The verifier score also rises to 0.67, compared with 0.61 for Random-LE and 0.43 for Seq-FedAvg. Appendix D.5 also repeats the packing comparison on both Qwen2.5-1.5B and 7B at the same parameter snapshot with dropout disabled, measuring event-aligned loss difference, relative LoRA-gradient error, and gradient cosine similarity. Figure 11 shows the remaining numerical differences under RoPE and bfloat16 kernels. These additions extend the evidence beyond the small untrained Transformer and the original 1.5B end-to-end setting. The end-to-end results are reported as mean ± standard deviation over five seeds {42, 43, 44, 45, 46}. The 7B table includes sequential training, Canonical-LE, Random-LE, and TopoFed-Agent, allowing the scale comparison to test both sequential and fixed/random legal-order controls. The theoretical result establishes invariance under its assumptions; the 7B experiments separately test downstream performance at a larger scale.

Reviewer_imL8OpenReview ↗

Thank you for your response.

Thank you for your reply! I have no other questions. Good luck.

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

This paper points out that for the post-training of asynchronous LLM agents in federated scenarios, the training trajectory data will have independent events recorded in different orders due to network latency, queuing, and other reasons. When using these data for training, the same task will therefore get different gradients due to different orders of intermediate processes, which the authors call "interleaving heterogeneity". The paper's approach is to obtain a dependency graph by recording runtime dependencies, and only assign order to events that conform to the dependency relations. During training, each event only depends on its upstream events, so that for tasks with the same content but different orders of independent events, the gradients output by the model are completely identical. The paper proves that under the premise that the dependency graph is correct, training based on all serialized training data obtains completely identical predictions, losses, and gradients (with randomness controlled). Experimentally, it verifies the gradient changes on a small 2-layer Transformer, and trains Qwen2.5-1.5B with LoRA on AppWorld and Gaia2, comparing it with other training methods.

Critical strengths

The problem definition and theoretical derivation are relatively clear, and the ablation experiments directly verify the necessity of each of the three components.

Critical weaknesses
  1. Limited novelty. Processing trajectory data by making independent segments mutually invisible and sharing position indices has already been studied in existing papers (such as Parallel Context Windows, Block-Attention, APE, etc.), and there is also a large body of work in parallel reasoning and tree-structured trajectory packing training. The paper does not cite the first three, and for the cited work on tree-structured trajectories and partial-order masks, it neither discusses the differences nor compares with them.
  2. The significance of taking gradient consistency as the goal is questionable. The main evidence for gradient variance comes from an untrained small 2-layer model. In addition, training only attends to causal ancestors and uses causal depth as the position, whereas in actual deployment, agents often face linear conversation history. The paper does not explain how the inference stage is handled, and there may be an inconsistency between training and inference.
  3. The experimental results contradict the paper's own mechanism. Using fixed ordering alone is about 10 points higher than serialized training, and according to Table 1 and Figure 3(a), fixed ordering has already reduced the gradient variance caused by ordering to zero; therefore, the additional gain of about 5 points from this paper's method cannot be explained by "eliminating interleaving heterogeneity". Moreover, random sampling, which has larger gradient variance, outperforms fixed ordering instead.
  4. Insufficient statistical reliability. The end-to-end experiments only have 3 seeds, with no significance tests or confidence intervals, nor is it explained whether ± represents standard deviation or standard error; the standard deviations are unusually small and uniform. Most experiments in Appendix D only have figures without textual analysis.
Questions for authors
  1. Please compare the similarities and differences between this paper's method and PCW, Block-Attention, APE, as well as parallel reasoning and tree-structured packing training methods, and preferably provide experimental comparisons.
  2. Are ancestor attention and causal depth positions also used during deployment inference? If not, how is the inconsistency between training and inference handled?
  3. Fixed ordering already eliminates the gradient variance caused by ordering; where does the improvement of this paper's method over it come from? Could you separately compare with control groups such as "only restricting the attention scope"?
  4. Could you increase the number of seeds, and report the results for each seed, confidence intervals, and significance tests?
2 comments

We thank the reviewer for the detailed assessment. We have expanded the structural baselines, clarified deployment inference, added component-level comparisons, and extended the end-to-end evaluation to five seeds.

Q1. Comparison with PCW, Block-Attention, APE, parallel reasoning, and tree-structured trajectory packing.

Sections 5.2 and 5.4 and Appendix B.4 now include PCW-adapted, Hasse-mask, Tree Training-adapted, APE, and Set-Based Prompting, covering parallel context windows, dependency-aware masks, tree packing, parallel context encoding, and training-free order handling. Table 1 evaluates them on four structures with 24, 6, 4, and 10 legal serializations. PCW-adapted retains relative gradient deviations of 0.128–0.235, Hasse-mask 0.151–0.322, and Tree Training-adapted 0.16–0.31, while TopoFed-Agent reduces them to numerical precision under arbitrary legal extensions. APE reduces output and loss deviations; Set-Based Prompting obtains low deviations on designated independent subsets but does not cover arbitrary extensions of the complete poset. In Table 2, on Qwen2.5-1.5B, TopoFed-Agent obtains 35.8% Test-N TGC, 22.1% Test-C TGC, and 21.8% Gaia2 Pass@1, compared with 30.7%, 17.6%, and 18.1% for PCW-adapted. Block-Attention is related at the mask level, but block isolation alone does not specify runtime-certified dependencies, ancestor visibility across arbitrary event blocks, causal-rank positions, or event-bound targets. TopoFed-Agent jointly models these elements under a recovered execution poset rather than introducing only a mask or packing change.

Q2. Whether ancestor attention and causal-depth positions are also used during deployment inference.

Yes. Appendix A.7 specifies online execution, and Section 5.8 evaluates training–inference consistency. Each tool call, result, or decision receives a persistent event identifier. The runtime appends certified dependencies, retains observed order for unresolved pairs, and computes causal ranks. Each decision attends only to currently available ancestors and uses the training-time position definition. The inference cache is keyed by event identity and ancestor context. Cached values are reused when context and positions are unchanged; a newly discovered dependency invalidates affected descendant entries before the next decision. Previously committed decisions are not revised. Table 7 shows that poset-aware inference improves AppWorld Test-N TGC from 33.1% to 35.8% and Gaia2 Pass@1 from 19.7% to 21.9%, with 8% additional latency. Deployment thus preserves the causal-context and positional semantics used during adaptation.

Q3. Why TopoFed-Agent improves over fixed ordering, and the contribution of restricting attention alone.

A fixed canonical order removes variation across legal orders, but still trains on the context induced by one selected extension. The gain at β = 0 is therefore not explained only by removing client-specific scheduler preferences. Ready events are sampled uniformly at β = 0, but each execution is still packed as one sequence, so its context, position, and target alignment remain order-dependent. Table 5 shows that Canonical-LE has Δg below 10⁻⁵ and obtains 30.5% Test-N TGC, whereas TopoFed-Agent obtains 35.8% under both fixed and arbitrary legal packings. Adding Ancestor Mask to Canonical-LE raises TGC to 31.7%; adding Causal Rank raises it to 33.2%; M+R+T reaches 35.8%. Table 3 includes the requested mask-only control: M alone obtains 26.2% Test-N and 13.3% Test-C TGC, versus 35.8% and 22.1% for the full method. Rank-only and target-only obtain 23.7%/11.3% and 23.1%/11.7%; all two-component combinations also remain below the full configuration. The added gain therefore comes from causal-context modeling and event-local target alignment beyond selecting one shared order.

Q4. Number of seeds, per-seed reporting, confidence intervals, and significance tests.

We extended end-to-end experiments from three to five seeds, {42, 43, 44, 45, 46}; controlled Transformer tests use {0, 1, 2, 3, 4}. Table 2 reports mean ± standard deviation over five seeds. Methods use matched client-selection schedules and paired task identifiers. Appendix B.5 and Table 10 specify the run-level records, including each seed's metric and denominator, paired differences, and confidence intervals. Section 5.1 states that confidence intervals and paired significance tests are used for the main comparisons. The tables retain the five-seed mean ± standard deviation format, while individual seed records and paired statistics are kept in the run-level experiment records.

We thank the authors for the additional experiments; however, the rebuttal confirms that the gain over Canonical-LE comes from structural inductive bias rather than from removing interleaving heterogeneity, per-seed results, confidence intervals, and significance tests are still not reported, and the evaluation does not demonstrate effectiveness on long-horizon or natively asynchronous trajectories. I maintain my original score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.