Pith. sign in

REVIEW 5 major objections 5 minor 25 references

IACM-RL: Intent-Aware Context Management and Reinforcement Learning for Complex Tool Invocation under Dynamic Intent Fluctuations

T0 review · 5 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that decoupling state tracking from action generation, via a self-generated BeliefState Context Manager with structural stale flags and a hierarchical reward plus auxiliary losses, is what makes tool-invoking agents…

desk verdict A well-specified RL recipe for intent-fluctuation robustness that deserves referee time, though its central transfer claim is only as strong as the LLM-simulated training environment. read the letter →

arxiv 2608.02110 v1 pith:IDZ5RXBF submitted 2026-08-03 cs.CL cs.AI

Dingwei Zhu , Jiahan Li , Chengjun Pan , Yunxian Yang , Yunbin Zhao , Yunke Zhang , Zhonghang Lu , Zhuohui Sheng
show 17 more authors
Chenhao Huang Jiahang Lin Yajie Yang Junlin Shang Shichun Liu Yuhui Wang Honglin Guo Junjie Ye Xin Guo Jiazheng Zhang Ming Zhang Shihan Dou Zhiheng Xi Tao Gui Qi Zhang Xipeng Qiu Xuanjing Huang
This is my paper · ORCID
classification cs.CLcs.AI
keywords intentfluctuationtoolinvocationbeliefstatecontextmanagementreinforcementlearningstaleflagdynamicbenchmarkmulti-turnagents
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper is trying to establish that the main failure mode of long-horizon tool-calling agents under changing user intent—stale parameters, missed goal switches, and infinite API loops—comes from forcing the policy to re-derive state from a long raw history, and that this can be removed by having the agent generate its own compact belief-state block before each action. To test this, the authors build the DynamicIntent pipeline, producing thousands of trajectories across 13 intent-fluctuation scenarios, and pair it with a five-metric diagnostic suite. They then train IACM-RL with a hierarchical reward and three auxiliary losses so that the state-tracking capability is internalized in the policy weights. If the claim holds, agents can maintain accurate tool invocation even when users overwrite parameters, interrupt tasks, or insert irrelevant chit-chat, and the benefit should grow with conversation length rather than fade.

What carries the argument

The central object is the BeliefState-based Self-Generated Context Manager: a compact five-field state block $b_t = (C_{\text{slots}}, G_{\text{current}}, A_{\text{last}}, Q_{\text{pending}}, I_{\text{signal}})$ rendered as nine XML sub-blocks, drafted by the policy at each turn, injected into the system prompt, and updated at every user/tool boundary. The stale flag on $C_{\text{slots}}$ is the load-bearing detail: an overwritten value is kept but explicitly forbidden. The optimization machinery is the hierarchical reward $R_{\text{total}} = \alpha R_{\text{belief}} + \beta R_{\text{action}} + \gamma R_{\text{outcome}} + R_{\text{format}}$, which gives field-level credit assignment over the five state fields, plus three auxiliary losses—action calibration ($\mathcal{L}_{\text{cal}}$), CM extraction ($\mathcal{L}_{\text{ext}}$), and state distillation ($\mathcal{L}_{\text{dist}}$)—which shape the CM tokens and then distill the CM-conditioned distribution into a CM-free student.

What would settle it

Take the trained RL policy (not an SFT variant) and run it on the same DynamicIntent test scenarios with real tool backends instead of the LLM mock, then measure the cognitive score, stale-context residual rate, and infinite-loop rate against PPO-noCM. If the margin over raw-history RL shrinks substantially or reverses once tool returns are real, the claim that the learned stale-flag and loop-suppression behavior transfers is falsified.

Watch

Extended reading notes

Core claim

IACM-RL claims that an LLM policy can be trained to decode, at every turn, a self-generated BeliefState paragraph—tracking the current goal, confirmed slots, last executed tool, pending questions, and intent signal—and to condition its tool call on this block instead of the raw dialogue history; overwritten parameters are marked with a structural stale flag so the policy is explicitly forbidden from reverting to them. On DynamicIntent, BFCL-V3, and $\tau^2$-Bench, the resulting policy attains the highest overall average (64.0), remains within 0.2 points of its in-domain cognitive score on a fully disjoint out-of-domain tool pool, and suppresses loops and stale-value reuse. The three auxiliary losses each contribute: removing CM extraction drops out-of-domain cognitive score from 36.3 to 32.7, removing state distillation drops it to 31.4, and removing all three reduces the average to 61.5.

Load-bearing premise

The load-bearing premise is that LLM-simulated tool returns behave enough like real API responses that a policy trained against them transfers; the paper only validates the simulation on SFT models, not on the RL-trained policy, so a structural difference between mock and real returns could erase the reported gains.

Editorial extensions

If this is right

  • On DynamicIntent, IACM-RL posts the highest average (64.0), beating seven PPO-trained context-management baselines and the SFT base.
  • On an out-of-domain split with a disjoint 244-tool pool, the cognitive score stays at 36.3 versus 36.5 in-domain, while the base model drops to 33.0 and RL-STA to 33.8, indicating schema-independent state tracking.
  • Gains grow with conversation length: on $\tau^2$-Bench very-long dialogs (over 16k tokens), PPO-noCM scores 0.0 while IACM-RL reaches 34.8; on dialogs above 30k characters the no-CM pipeline collapses to 0.0 while a CM-injected base model still achieves 0.202.
  • Under adversarial interference (three fake tasks plus five chit-chat messages), IACM-RL retains 36.8% tool-call accuracy versus 25.6% for PPO-noCM, an 11.2-point margin.
  • Removing the belief reward layer causes the sharpest drop (average 64.0 to 57.4, BFCL 63.3 to 47.5), showing the cognitive layer is what preserves general calling proficiency.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The stale-flag mechanism suggests a testable diagnostic rule: in long-horizon agent failures, a large share of errors should be attributable to regression to overwritten slot values rather than to missing tool selection; this could be measured on other multi-turn agent benchmarks by tagging consumable slot values.
  • If the CM-block training transfers to real APIs, the same two-stage RL recipe could plausibly extend to multimodal tool invocation and to non-tool agent state management, since the CM operates on textual state summaries; the paper explicitly leaves that transfer open.
  • Because CM gains grow with dialogue length, the approach offers a practical alternative to ever-longer context windows: train agents to emit compact state updates into the prompt instead of relying on retrieval or compression, at least for long-horizon text-based tool tasks.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 5 minor

Summary. This paper proposes IACM-RL, a two-stage PPO framework for tool invocation under dynamic intent fluctuations. The contributions are: (i) the DynamicIntent dataset/benchmark with 13 synthetic fluctuation scenarios and human-annotated ID/OOD test sets; (ii) a five-metric diagnostic suite (JGA, SCRR, RIR, DTCR, ISSR); (iii) a self-generated BeliefState Context Manager with structural stale flags; and (iv) a hierarchical intent-driven reward with three auxiliary consistency losses. Experiments on DynamicIntent, BFCL-V3, and τ2-Bench report that IACM-RL attains the highest average score (64.0), with strongest gains on OOD Cognitive, τ2-Bench airline, and long-dialogue state tracking.

Significance. The contribution is potentially useful: the synthetic data pipeline and metric suite fill a real gap, and the ablations cover auxiliary losses, reward layers, CM update policies, backbone scale, and seed variance for the main model. The central idea of decoupling state tracking from action generation via a self-generated BeliefState is clearly presented and plausibly effective. However, three methodological gaps currently limit confidence in the headline claims: the RL reward is built from the same five metrics used for evaluation on DynamicIntent, the RL policy is trained and evaluated only against LLM-simulated tool responses, and the main tables report single runs without baseline error bars. These issues are fixable and do not, in my assessment, invalidate the core method.

major comments (5)
  1. [Section 4.3, Eq. (7) vs Section 3.3, Eqs. (1)-(5)] The hierarchical reward R_total is a weighted aggregate of JGA, SCRR, RIR, DTCR, and ISSR, and the DynamicIntent evaluation composites Cognitive, Behavioral, and Outcome are exactly these same five metrics. As a result, the reported reductions in stale-context errors and loops on DynamicIntent are partly a consequence of optimizing the evaluation objective itself. I recommend evaluating on held-out metrics not used in the reward, or adding an explicit reward-ablated control that separates optimization target from diagnostic.
  2. [Algorithm 1 and Appendix G.1] All PPO rollouts execute tool calls through the LLM MockBackend, and the DynamicMockTool fallback returns normal realistic results for missing required parameters, type mismatches, format errors, and invalid enum values; only nonexistent tools and undefined parameters produce errors. The only real-backend validation (Table 11) concerns SFT-only models, not the RL policy, and Appendix F concedes that transfer to non-simulated settings is open. The central loop/stale-error gains may therefore not transfer to real APIs; please add a real-backend evaluation of the final RL policy on at least a subset, or explicitly limit the claims to simulated environments.
  3. [Section 3.3, Eq. (3)] The RIR definition is ambiguous. If equality of a_t and a_{t−Δ} is at the level of tool name, then a correct modification that re-invokes the same tool with updated arguments (Figure 10, Turn 2) is counted as a redundant or infinite loop; if equality is at the level of the full call, then looping calls that vary arguments escape detection. A precise definition of 'repeated tool call' and a dedicated infinite-loop metric are needed, since RIR underlies the Behavioral score and the loop-reduction claim.
  4. [Tables 4-12 and Appendix B.1] Seed variance is reported only for IACM-RL, not for any baseline, and most tables show single runs. Several headline gaps are small (e.g., BFCL 63.3 vs 63.2; MEM1 Avg 62.6 vs 64.0), so single-run comparisons do not support the 'highest overall average' claim. Please provide multi-seed means with standard deviations, or paired bootstrap intervals across dialogs, for all methods.
  5. [Table 9] The 'Format penalty only' row reports a τ2-Bench Airline value of 65.0, which exceeds the full model's 38.0 and is inconsistent with the text's claim that removing all reward layers harms performance. If 65.0 is not a column misalignment (i.e., if BFCL is actually 28.1), the table layout should be corrected; either way, the reward-layer ablation conclusions need to be re-verified.
minor comments (5)
  1. [Section 3.1] The acronym UTAL is used without expansion; please define it at first use.
  2. [Section 5.2] The 'Avg' column is an unweighted mean over nine heterogeneous values (composite scores, benchmark accuracies, and τ2-Bench rewards); please justify this aggregation, since the headline 'highest overall average' depends on the chosen weighting.
  3. [Table 11] The statement that LLM simulation is a 'faithful proxy' is stronger than the reported Retail gap (18.4 vs 14.9) supports; please add a significance test or soften the wording.
  4. [Figures 6 and 12] The attention visualizations are qualitative; a quantitative measure of attention concentration on current-goal tokens would better support the attention-dilution mechanism.
  5. [Section 3.3, Eq. (5)] The evaluation threshold τ for the ISSR judge is never given a numeric value, although the reward-side threshold is stated as 0.3 in Section 4.3; please specify the evaluation threshold.

Circularity Check

2 steps flagged · score 4.0 of 10

DynamicIntent gains are partially circular: the hierarchical reward is built from the same five metrics used to report loop/stale-error reductions, and the in-house benchmark shares its golden-map target with training; independent external benchmarks keep the score at 4 rather than higher.

  1. fitted input called prediction [Section 4.3 (Eq. 7, Table 3) vs. Section 3.3 (Eqs. 1-5)]
    ""To provide dense, diagnostically meaningful reinforcement, we decompose the reward into three layers mirroring the cognitive, behavioral, and outcome aspects of tool calling: R_total = α R_belief + β R_action + γ R_outcome + R_format ... Metric definitions. The reward signals are built upon the five evaluation metrics defined in Section 3.3, together with the ACR clarification signal used by the reward.""

    JGA, SCRR, RIR, DTCR, and ISSR serve both as the DynamicIntent evaluation metrics (Section 3.3) and as the components of the training reward: JGA grants positive hits, stale reuse incurs -0.5, consecutive-identical-call loops short-circuit at -2.0, DTCR pays +4.0/+2.5/+1.0 by chain completion, and ISSR pays +2.0×score. The paper's headline result of 'reducing infinite loops and stale context errors' on the DynamicIntent Benchmark is therefore the objective being optimized, not an independent verification of the mechanism. The paper's caveat that the reward is per-turn shaping while the metric is whole-trajectory counting does not remove the dependence: both are computed from the same golden map and the same detector primitives (multi-call extractor, stale flag, loop detector).

  2. self definitional [Section 3.1 Stage 5 and Section 3.2]
    ""The pipeline also records the expected final tool dependencies and argument states as a golden map, which serves as the exact optimization and evaluation target for the rule-based reward and metrics." (Section 3.1, Stage 5) "The intent-augmentation methods introduced in the main pipeline (Section 3.1) are organized around the same five intent-fluctuation modes that the BeliefState fields and reward metrics target." (Section 3.2)"

    The in-house benchmark is not an external probe of the method: the same golden map produced by the LLM simulation pipeline is used as the exact optimization target (reward) and the exact evaluation target (metrics), and the scenarios are deliberately built around the same five modes that the BeliefState fields are designed to handle. Consequently, improvement on the DynamicIntent scenarios partially re-measures the construction itself. Human annotation fixes label quality but does not make the test target independent of the training target. This compounds the reward/metric overlap; it is not the whole story because the external benchmarks and the held-out OOD tool pool provide separate evidence.

full rationale

The strongest evidence of circularity is textual and direct: Section 4.3 states that the reward signals are built upon the five evaluation metrics of Section 3.3, and Section 3.1 states that the same golden map is the exact optimization and evaluation target. Thus the reported reductions in infinite-loop rate and stale-context errors on the DynamicIntent Benchmark are training-objective outcomes rather than independent confirmations; the score is 4 rather than lower because the paper also reports on BFCL-V3 and τ2-Bench, which are external and not defined by the five custom metrics, and because the OOD split uses a disjoint held-out tool pool. The paper also discloses relevant limitations: Appendix F says 'All experiments use text-based API tools simulated by LLM; whether the observed gains transfer to multimodal or non-tool agentic settings remains an open question,' and the real-vs-simulated validation in Table 11 is conducted on SFT-only models, not the RL policy; these are external-validity gaps rather than additional circular steps. No load-bearing self-citation chain was found: the self-citations (Pan et al. 2026; Xi et al. 2026; Zhu et al. 2026a,b,c) are background references for LLM capability, and no uniqueness theorem or ansatz is imported from the authors' prior work to force the BeliefState choice. The ablation and external-benchmark content give the framework independent testable substance, so the overall circularity is partial, not total.

Assumptions & free parameters 4 free parameters · 5 assumptions · 2 invented entities

The central claim rests on several hand-chosen reward and loss coefficients, on the assumption that LLM-simulated tool returns behave like real backends during RL, on the completeness of the five-field BeliefState representation, and on the hypothesized attention-dilution causal mechanism. The invented BeliefState and stale-flag constructs have no independent falsifiable handle outside the paper's own benchmarks.

free parameters (4)
  • Reward layer weights (alpha, beta, gamma) = 1.0, 1.0, 0.5
    Hand-chosen coefficients in Eq. 7 that balance cognitive, behavioral, and outcome reward layers; no fitting procedure or grid search is shown.
  • Auxiliary loss weights (w_cal, w_ext, w_dist) = 0.02, 0.01, 0.01
    Set by hand before training; Table 15 shows a sensitivity sweep over these weights but the default was chosen a priori.
  • Reward shaping magnitudes = JGA cap 5.0; stale -0.5; hallucination -0.8; loop -2.0; invalid -1.0; progress +0.3 (cap 0.9); DTCR +4.0/+2.5/+1.0…
    The central RL signal values are author-chosen in Section 4.3 and Table 3; changing them would change which behaviors are reinforced.
  • ISSR LLM-judge threshold tau = 0.3
    Gates whether a pivot to an interruption goal counts as success in Eq. 5 and in the reward; arbitrary threshold.
assumptions (5)
  • domain assumption Synthetic trajectories generated by LLM back-and-forth translation and mock tool returns faithfully represent real-world multi-turn tool invocation with intent fluctuations.
    The whole DynamicIntent benchmark and RL training rely on this; Table 11 validates it only for SFT models, not for RL, and Appendix F concedes transfer is open.
  • domain assumption The Tool Dependency Graph, built by LLM voting, correctly captures which tools can feed parameters to which other tools.
    Stage 2 of the pipeline (Section 3.1); the graph determines which trajectories are syntactically valid, so mis-edges would propagate into training data.
  • ad hoc to paper The five BeliefState fields (C_slots, G_current, A_last, Q_pending, I_signal) are a sufficient state representation for dynamic intent tracking.
    Eq. 6 defines the state the model must learn to maintain; there is no proof or measurement that these fields exhaust the relevant intent state.
  • ad hoc to paper Attention dilution in raw-history policies is the causal mechanism behind catastrophic intent deviation and infinite API loops.
    Motivates the entire CM design (Section 4.1, Figure 6) but is supported only by qualitative attention plots, not by controlled quantitative measurement.
  • domain assumption LLM judges (GPT-5.4) produce reliable scores for clarification quality (ACR) and intent-switch success (ISSR).
    Required in the reward and in Eq. 5; no human agreement or calibration against the authors' own rubric is reported.
invented entities (2)
  • BeliefState (five components, nine XML sub-blocks)
    purpose: An explicit, self-generated context block that tracks current goal, confirmed slots, stale-flagged overwritten parameters, last action, pending questions, and intent signal, used to condition every tool call.
    The entire method rests on this internal state representation. It is evaluated only inside the paper's own benchmarks; the only external evidence is the small BFCL/tau2 gains for the full system, which do not isolate the BeliefState's contribution.
  • Structural stale flag
    purpose: Marks overwritten parameter values so the policy is explicitly forbidden from regressing to them.
    A core mechanism claimed to reduce stale-context errors; no independent evaluation outside the paper's ablation is reported.

how reviews work

0 comments
Cite this review

Pith. "Pith review of IACM-RL: Intent-Aware Context Management and Reinforcement Learning for Complex Tool Invocation under Dynamic Intent Fluctuations." pith.science (2026). https://pith.science/paper/IDZ5RXBF

@misc{pith2026260802110,
  author       = {Pith},
  title        = {Pith review of: IACM-RL: Intent-Aware Context Management and Reinforcement Learning for Complex Tool Invocation under Dynamic Intent Fluctuations},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IDZ5RXBF}},
  note         = {Machine review of arXiv:2608.02110}
}
abstract

Executing long-horizon tool invocations in real-world environments is severely challenged by dynamic user intent noise. Existing methods attempt robustness via implicit history scanning or text compression, yet predominantly assume perfect instructions in simplistic scenarios. Inevitably, under fluctuating contexts, obsolete constraints dilute model attention, triggering catastrophic intent deviation and infinite API loops. To resolve this, we propose IACM-RL, a comprehensive framework for robust tool invocation. First, we introduce the DynamicIntent pipeline, synthesizing trajectories across 13 fine-grained fluctuation scenarios, paired with a five-dimensional diagnostic metric suite. Second, IACM-RL deploys a BeliefState-based Self-Generated Context Manager that proactively tracks shifting goals and isolates overwritten parameters using structural stale flags. To autonomously internalize this state-tracking capability, we optimize the policy using a hierarchical intent-driven reward alongside three auxiliary losses (action calibration, CM extraction, and state distillation). Experiments on DynamicIntent, BFCL-V3, and $\mathrm{\tau}^2$-Bench demonstrate that IACM-RL significantly outperforms baselines, reducing infinite loops and stale context errors while enhancing out-of-domain generalization.

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

25 extracted references · 24 canonical work pages

  1. [1]

    Judge if the target api is related to the source API

    work page

  2. [2]

    Judge which input parameters of the target API is dependent on the output of source api. 35 IACM-RL: Intent-Aware Context Management and Reinforcement Learning for Complex Tool Invocation under Dynamic Intent Fluctuations We say one function is related to the source API if:

    work page

  3. [3]

    Other.” The “Other

    injects single-turn anchor demonstrations during multi-turn RL to stabilize credit assignment and break contextual inertia. The Intent Benchmark evaluates each of the 13 scenarios on approximately 100 dialogs for ID, using a disjoint tool pool for OOD. ForBFCL-V3, we evaluate on the single-turn and multi-turn categories. Thefinalscoreistheunweightedmeanof...

    work page

  4. [4]

    The target API function is related to the source API function, but this does not mean that the target API function necessarily has parameters that is dependent on the source API function

    work page

  5. [5]

    error":

    In <think> and </think>, give a brief explanation on how you think and make judge. In <judge> and </ judge>, if the target api is related to the source API, output yes, otherwise output no, Use lower case. In < parameters> and </parameters>, give a list of parameter names of the target API which are dependent on the source API if any, like [’param1’, ’par...

    work page

  6. [6]

    For example, the output of fileexists(’file

    the output of the source API is the premise of executing the function. For example, the output of fileexists(’file. txt’) API determines whether we can call downloadfile(’file.txt’)

    work page

  7. [7]

    For example, when calculating the area of a circle, the function getradius(obj) is the source node and calculate(radius) is the target node

    the output of the source API is exactly the input parameters of the function. For example, when calculating the area of a circle, the function getradius(obj) is the source node and calculate(radius) is the target node

    work page

  8. [8]

    For example, when posting something to social media, one might first get the content

    the output of the source API is partial input parameters of the function. For example, when posting something to social media, one might first get the content. In this case, the content = getcontent(’file.txt’) is the source node and posting(content, id, tags) is the target node. We say one parameter is dependent on the source API if:

    work page

Show all 25 references
  1. [9]

    the output of the source API is exactly the input parameters of the function

  2. [10]

    Notice that the relation might cross the boundary of domains

    the output of the source API is partial input parameters of the function. Notice that the relation might cross the boundary of domains. For example, when the given APIs are in the domain of weather and travel, it is possible that a weather API could be dependent on a travel AP...

  3. [11]

    You need to first analyze what the source API function’s output is

  4. [12]

    When evaluating the output of the source API function, first refer to the output examples; the description of source API function are only secondary references

  5. [13]

    In case of any conflict or invalid output examples, rely on the output examples

  6. [16]

    final_user must be a natural modification utterance reflecting the user changing their mind / supplementing / overwriting

  7. [17]

    The post−modification tool call must be a modify/delete/cancel tool already defined in the tools list, with arguments taking the new post−modification values

  8. [18]

    Old−value parameters must be findable in the historical tool_call; new values must appear literally in final_user

  9. [19]

    change to / adjust / switch to / forgot to mention / supplement / cancel / don’t want

    final_user must also convey a modification signal, such as "change to / adjust / switch to / forgot to mention / supplement / cancel / don’t want"

  10. [20]

    Do not rewrite, expand, normalize, or complete any characters not present in final_user

  11. [21]

    change it to 8 o’clock

    Prefer the three modification types: parameter overwrite, parameter supplementation, and cancel/switch−to− another. G.2. Self-Generated Context Manager Prompts CM generation prompt.During rollout, the policy drafts a Context Manager block as the condition- ing signal for the s...

  12. [22]

    Abandonment of Old Task — Did the agent STOP executing Task A?

  13. [23]

    Execution of New Task — Did the agent correctly execute Task B?

  14. [24]

    Transition Quality — Did the agent acknowledge the switch gracefully?

  15. [25]

    score": <float>,

    Completeness — For Task B, did the agent do everything required? ## Scoring Rubric (score in [−1.0, 1.0]) ### 1.0 — Perfect Switch: completely stopped A, fully executed B. ### 0.7~0.9 — Good Switch, Minor Residue: switched to B, minor A reference. ### 0.4~0.6 — Partial Switch:...

  16. [2025]

    learning to call tools correctly

    URLhttps://openreview.net/forum?id=2GmDdhBdDk. Magnus Saebo, Spencer Gibson, Tyler Crosse, Achyutha Menon, Eyon Jang, and Diogo Cruz. Asym- metric goal drift in coding agents under value conflict, 2026. URLhttps://arxiv.org/abs/ 2603.03456. Freda Shi, Xinyun Chen, Kanishka Mis...

    2026 arXiv

  17. [2026]

    Philippe Laban, Hiroaki Hayashi, Yingbo Zhou, and Jennifer Neville

    URLhttps://arxiv.org/abs/2510.00615. Philippe Laban, Hiroaki Hayashi, Yingbo Zhou, and Jennifer Neville. Llms get lost in multi-turn conversation, 2025. URLhttps://arxiv.org/abs/2505.06120. Dongjun Lee, Juyong Lee, Kyuyoung Kim, Jihoon Tack, Jinwoo Shin, Yee Whye Teh, and Kimi...

    2025 arXiv

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.