Signal Extraction From Implicit User Feedback in Agent Sessions
How to mine agent traces for the failures users never rate.

Signal extraction from implicit user feedback turns production agent traces into a compounding improvement loop. Teams close that loop by joining behavioral signals to trace context, attributing recurring failures to the responsible layer, and validating changes against production journeys and historical tests before release. Explicit ratings are too sparse to sustain this process alone, so structured trace analysis must be a repeating engineering practice.
Why explicit feedback alone cannot sustain a production improvement loop
Chang et al. cite Wang et al., 2025, for the finding that only 1–3% of users provide explicit feedback such as thumbs-up or thumbs-down. That leaves most interaction quality without a direct label. The same paper says that asking for feedback often makes users less satisfied, which limits how much teams can raise participation by asking more often. Solicitation therefore has a cost as well as a limit.
This is a structural constraint. Changing how feedback is collected does not remove the dependence on voluntary participation. Liu, Zhang, and Choi’s EMNLP 2025 study finds that feedback-bearing turns make up more than half of user utterances at later turns in long sessions. Those turns are already in the interaction record, even though users did not offer them as evaluations. The behavioral record left in every session is therefore the only high-volume improvement signal available, and ignoring it means improving agents on a tiny, unrepresentative sample.
What implicit behavioral signals in agent sessions actually look like
Liu and colleagues apply the negative-feedback taxonomy developed by Don-Yehiya et al., 2024, which distinguishes rephrasing, identifying an error without correcting it, identifying an error with a correction, and requesting clarification. These actions expose what a response failed to resolve. In an agent session, their position gives them diagnostic meaning. A rephrase after a tool invocation can indicate a tool failure, while a correction after a multi-step plan can indicate a workflow failure. Abandonment after a long-context response can point to a context or relevance problem.
Tool re-invocations, retry patterns, and trajectory reversals appear in execution history but may not appear in a message log. A feedback system attached only to the final response cannot show the path that preceded it.
Chang and colleagues also show that mouse trajectories and eye gazing contain preference information. Their finding shows that behavior can reveal preferences without an explicit rating. It does not make mouse or eye tracking a prerequisite for production agent engineering. The actionable signals are already present in session behavior and execution traces. Recognizing those signals is the easy part, while extracting them reliably from noisy, multi-turn trajectories requires engineering.
Why implicit feedback is noisy and what that means for how it is used
A rephrased request is not a ground-truth failure label. The agent may have misunderstood the task, or the user may have changed their mind. Liu and colleagues report mixed results from using implicit feedback content to improve responses, with benefits on shorter, well-structured tasks but not on longer, more complex ones. Their study also finds that prompts eliciting positive implicit feedback are sometimes lower quality or more toxic than randomly sampled prompts. Positive behavior alone is therefore not a sound basis for promoting a response.
The useful unit of analysis is a contextual pattern. A rise in the rephrase rate for a given prompt version is stronger evidence than a single rephrase. Likewise, more tool re-invocations on a given workflow path can reveal a failure pattern even when it is unclear what caused a single retry. Volume helps distinguish recurrence from an isolated event, while attribution identifies where the pattern concentrates. Neither makes every instance unambiguous.
This changes what extraction must produce. A behavioral event needs its prompt version, route, tool sequence, and session turn before it becomes interpretable. A rephrase attributed to a specific workflow step is a hypothesis that engineering can investigate. Noise is therefore a reason to structure analysis.
The three failure categories where trace-embedded signals are most diagnostic
Tool schema drift can make an agent degrade without raising an error. A backend field rename may leave an agent sounding confident while completing fewer tasks, retrying more often, and producing stranger outputs. The trace shows a rise in tool re-invocations, more fallback-path triggers, and corrections in later user turns. The relevant evidence points to a specific tool call. Happy-path evaluations cannot detect the rename unless they exercise the live schema.
Rephrases, clarification requests, and mid-session corrections cluster around a prompt version and particular workflow branches or task types. Ambiguity can propagate across thousands of agent steps. A system prompt that works well is therefore more like a software specification than a persona, because unconstrained instructions can help cause state corruption, execution loops, and broken tool calls.
Workflow loops and context exhaustion occur across longer trajectories. Intermediate tool outputs can pollute conversation history, allowing small errors to compound into semantic drift. After context exhaustion and truncation, an agent may produce plausible but disconnected output, leaving abandonment or correction as the only indication that the answer was wrong. Gates between steps can catch drift, while checkpointing and summarization mitigate context blow-out. These failures are semantic rather than technical, so standard APM cannot expose them without agent-aware instrumentation that makes intermediate state visible.
What trace structure is required before implicit signals become extractable
When each behavioral event is captured, it must be joined to its prompt version, tool call identity, workflow step, and session turn. That join preserves the context needed for attribution, which is the problem Moda, a production-trace-to-fix system for AI agents that diagnoses which harness layer caused a failure and validates the resulting change by replaying historical traces, was built to solve. Traditional logs cannot reproduce non-deterministic LLM failures, so the trace structure must support span-based trace replay. Final outputs alone are insufficient. Instrumentation must expose conditions in span data, including trajectory loops, cost thresholds, and security-sensitive tool calls, even when no bad status code appears.
Harness AgentTrace, open-sourced July 2026, demonstrates a continuous pipeline that collects, filters, evaluates, and acts on span data. It can detect loops, cost violations, and sensitive tool calls, then block, redirect, warn, or adapt without waiting for a user label. Its one-click export of a failing span into a regression test also connects production evidence to validation. The architectural significance is that detection and testing share the same failure record.
Reliable observability combines unit evaluations of discrete steps, LLM-as-judge regression suites for subjective quality, and continuous production trace sampling. Implicit feedback comes from production sampling and is used in regression evaluation. A production scoring drop without a corresponding golden-set drop indicates input distribution change. TelemetrySuffBench, introduced in 2026, shows that current agent telemetry is often insufficient for failure-origin diagnosis. Instrumentation presence is therefore not enough, because the trace must preserve the evidence needed to explain the failure.
Why root cause attribution must happen at the layer level, not the run level
A failed run identifies an outcome. Root cause attribution assigns responsibility to the model, harness, environment, or grader so that engineering changes reach the component that needs them. Model failures can inform post-training objectives, while prompt, tool, workflow, and memory failures require harness iteration. Environment or grader problems instead require benchmark repair. Conflating these categories wastes effort and can degrade a component that was functioning correctly.
The visible failure may be far from its cause. Formal root cause attribution research from 2026 finds that evidence is often sparse and distributed across distant actions in a trajectory. A one-shot LLM judge reading a long trace can settle on a plausible early diagnosis while leaving decisive evidence unexamined. Investigation must cover the full trajectory, including the step where failure becomes visible.
AgentDebugX, presented at EMNLP 2026, operationalizes attribution through a closed debugging loop. Its DeepDebug component achieves higher exact agent-and-step accuracy on the Who&When benchmark than single-pass baselines. Yawen Wang et al.’s 2026 framework approaches attribution through causal graphs that expose cross-component dependencies obscured by flat logs. Both approaches address the gap between locating a symptom and assigning responsibility. Because most production reliability failures appear in prompts, tools, workflows, and memory rather than model weights, harness-layer attribution is the highest-leverage diagnostic focus.
How do teams turn production agent traces into validated improvements?
The trace that exposed a failure becomes the test case that gates its fix. Production-derived regression tests replay actual user journeys, allowing them to catch tool-call sequencing breaks, latency regressions, and cascading multi-turn context drift that golden-answer suites miss. A self-growing harness ingests new traces as production agents run, reducing the manual curation bottleneck.
Teams can change the harness faster than they can revise the model. They can update a prompt, tool schema, workflow, or memory structure without changing model weights. That shorter cycle is useful only if replay shows that the change resolves the attributed failure without breaking other paths. The validation set must therefore cover both the journeys that have just started failing and the historical baseline.
Harness Continual Learning, introduced in 2026, formalizes this problem as sequentially updating harness state around a frozen foundation model to acquire and retain capabilities. It defines the loss of earlier behavior as harness-level forgetting. Replay provides a way to test that retention requirement while evaluating the new fix. The engineering sequence is to observe the implicit signal, attribute it, generate a change, replay the relevant journeys, and gate the release on the result.
Treating implicit signal extraction as a repeating engineering practice, not a one-time analysis
Agent harnesses degrade as usage patterns shift, tool schemas evolve, and new failure modes emerge. Trace review therefore needs a regular cadence with the same standing as code review. Recurring behavioral patterns are central inputs to that review. They can reveal either a drifting harness component or a new user behavior that the current harness does not handle.
Xu et al.’s 2026 personalization research frames a related requirement at the user level. Over extended interaction horizons, agent effectiveness depends on adapting behavior from accumulated signals, making feedback persistent. At the engineering level, persistence means retaining the connection between observed behavior, attributed cause, proposed change, and validation evidence across successive releases.
The organizational commitment is to review patterns, assign them to the responsible layers, and require replay validation before release. Teams that look at traces only after incidents wait for faults to surface, while teams that analyze traces continuously have a chance to fix repeated faults before they spread to more user journeys. This practice is accessible to any team willing to instrument traces correctly and commit to the loop. The discipline that compounds is to observe, attribute, fix, validate, and repeat.
Sources
- Your Mouse and Eyes Secretly Leak Your Preference: LLM Alignment using Implicit Feedback from Users
- Toward Personalized LLM-Powered Agents: Foundations, Evaluation, and Future Directions
- Aclanthology
- User Feedback in Human-LLM Dialogues:A Lens to Understand Users But Noisy as a Learning Signal
- User Feedback in Human-LLM Dialogues
- AgentDebugX: An Open-Source Toolkit for Failure Observability, Attribution, and Recovery in LLM Agents
- Root-Cause Attribution Is a Search Problem: Continual Search for Long-Horizon Agent Failures


