trace analysis

This work addresses the challenge of fault diagnosis and root cause analysis in complex multi-agent systems, where execution traces are often lengthy and structurally intricate, leading existing methods to either overlook critical behavioral details or focus solely on final outcomes. To overcome these limitations, the authors propose TraceSIR, a novel multi-agent framework that introduces TraceFormat—a structured abstraction for system trajectories—and integrates three specialized agents: StructureAgent for trajectory compression, InsightAgent for fine-grained root cause diagnosis, and ReportAgent for generating cross-task actionable reports. Experimental evaluation on the newly curated TraceBench benchmark demonstrates that TraceSIR significantly outperforms existing approaches in report coherence, informativeness, and actionability, thereby fulfilling the diagnostic requirements of real-world scenarios.

Existing automated program repair techniques struggle to address complex logical errors and silent failures due to their inability to accurately model runtime dynamic behaviors and data dependencies. This work proposes TraceRepair, a novel framework that, for the first time, incorporates runtime execution traces as shared constraints within a multi-agent collaboration mechanism. In this approach, a probe agent captures snapshots of critical variables, while multiple specialized agents—powered by large language models—perform cross-validation and iterative refinement to enable precise, dynamic-reasoning-driven repairs. Evaluated on Defects4J, TraceRepair successfully fixes 392 bugs, substantially outperforming current LLM-based methods, and demonstrates strong generalization capabilities on a newly curated dataset of recent vulnerabilities.

This work addresses the challenges of model uncertainty and unpredictability in partially observable or black-box systems during runtime by proposing a unified theoretical framework that integrates epistemic logic with temporal logic. Leveraging automata theory, it systematically formalizes core concepts—including specification, diagnosis, opacity, and monitorability—and synthesizes lightweight online monitors through offline analysis. The approach is extended to real-time systems, resolving key issues related to their temporal semantics and algorithmic complexity. Furthermore, the study precisely characterizes the fundamental limits of runtime verification, thereby establishing a constructive and implementable foundation for practical deployment of monitoring mechanisms.

Existing runtime monitors support only Boolean specification verification, making it infeasible to progressively approximate quantitative properties—such as average response time—over infinite traces. Method: This paper establishes the first unified formal framework for quantitative approximate monitoring, introducing quantitative monitors whose estimates monotonically improve as observation prefixes grow, and rigorously modeling the trade-off between estimation accuracy and resource consumption (specifically, register count). Contribution/Results: We prove that register count strictly determines the theoretical upper bound on achievable accuracy; moreover, each additional register strictly increases the attainable precision—demonstrating an irreducible, non-compensatory relationship between resources and accuracy. Our framework conservatively extends classical Boolean monitoring theory while ensuring soundness. The proposed approach provides provably optimal, resource-bounded approximate monitoring for critical performance metrics, enabling verifiable, deployment-aware runtime assurance.

To address the challenge of root-cause localization for iCFTL state specification violations, this paper proposes a static-dynamic collaborative diagnosis method based on backward data-flow analysis. First, backward data-flow analysis statically identifies potential violation-inducing statements; then, program instrumentation and runtime validation generate enriched execution traces to enable precise attribution. This work is the first to apply backward data-flow analysis to iCFTL specification violation diagnosis, significantly improving both diagnostic accuracy and interpretability. Experimental evaluation across 10 real-world projects and 112 specifications demonstrates that the approach precisely localizes violating statements in 90% of cases, reduces manual code review effort by over 90%, achieves an average diagnosis time of ≤7 minutes, incurs memory overhead <25 MB, and imposes runtime performance overhead <30%.

This work addresses the inefficiency of traditional fuzzing in black-box or obfuscated binary programs where static instrumentation is infeasible and control-flow feedback is unavailable. The authors propose a dynamic feedback mechanism based on Execution Divergence Graphs (EDGs), which constructs control-flow-like structures at runtime by analyzing execution traces to precisely identify path divergences and avoid redundant exploration of loops. Requiring no static program information, the approach integrates divergence detection with an EDG-guided input mutation strategy. Evaluated on multiple obfuscated targets, it substantially outperforms blind fuzzers, demonstrating its effectiveness in non-instrumented settings. Furthermore, the framework is extensible to multidimensional feedback channels, such as power consumption, broadening its applicability in side-channel-aware fuzzing scenarios.

Current approaches to software evolution analysis and continuous integration rely heavily on test pass/fail outcomes, often overlooking fine-grained runtime behavior, which limits their ability to detect partial oracles, flaky failures, and silent performance or output drifts. This work proposes a novel paradigm—behavioral co-versioning—that jointly manages Git code history with queryable archives of runtime behavior. During test execution, method-level inputs, outputs, and performance signals are captured and stored append-only, indexed by commit and test context. By treating runtime behavior as a first-class artifact, the approach enables semantic-level differencing, behavior-aware regression localization, and historical auditing. A Python-based prototype demonstrates feasibility, successfully uncovering behavioral evolutions invisible to conventional textual diffing techniques.

Existing debugging methods for code agents struggle to trace state transitions and error propagation in complex tasks and lack scalability. This work proposes a traceable architecture that employs an evolutionary extractor to parse heterogeneous runtime logs, constructs a hierarchical trajectory tree integrated with persistent memory, and introduces a fault-origin localization algorithm. For the first time, this approach enables automatic reconstruction of the complete state transition history and precise error tracing for agents executing multi-stage, parallel tool invocations. Evaluated on the CodeTraceBench benchmark, the method significantly outperforms existing baselines and supports accurate replay of original failing execution paths through diagnostic signal regeneration.

This work addresses the limitation of existing large language model–based automated program repair approaches, which rely on end-to-end test feedback and struggle to precisely identify internal logical deviations. To overcome this, the authors propose SpecTune, a framework that inserts checkpoints along execution paths to generate localized postconditions and evaluates intermediate program behaviors against dynamic execution results, thereby providing fine-grained debugging signals. SpecTune introduces an intermediate behavior reasoning mechanism and designs two key signals—a specification validation signal (α) and a discriminative signal (β)—to substantially enhance the reliability of automatically generated specifications and the precision of repairs. Experimental results demonstrate that SpecTune significantly outperforms current baseline methods in both fault localization accuracy and repair success rate.

Shared state profoundly influences the performance and fault tolerance of stream processing, service-oriented, and continual learning systems, yet existing approaches often treat access control, hardware-aware execution, memory management, and long-term evolution in isolation. This work reframes state management as a runtime control problem and introduces a contract-driven blueprint centered on state objects, control planes, coupling paths, evaluation boundaries, and pending contracts. Building upon this foundation, we develop a unified analytical framework encompassing state-access scheduling, state-aware execution, and state evolution reuse. Through systematic scheduling, runtime control, and cross-layer coupling analysis, our approach identifies critical anti-patterns and advances a perturbation-aware evaluation paradigm, thereby establishing both theoretical foundations and practical design guidelines for state control in distributed systems.