Interaction Bugs (iBugs): A Cross-Domain Overview
- Interaction bugs (iBugs) are defects arising from failures at the boundaries where components interact, impacting overall system behavior.
- They are observed across diverse domains such as ROS-based robotics, Android apps, 3D games, DL compilers, quantum software, and LLM agent frameworks.
- Research highlights methods like GUI trace analysis, execution graph debugging, and constraint-based assertions to address these cross-domain interaction failures.
to=arxiv_search.search 高频彩大发快三json code {"query":"interaction bugs iBugs software arXiv", "max_results": 10} to=arxiv_search.search 天天彩票与你同行json code {"query":"interaction bugs arXiv mobile apps ROS game perceptual bugs", "max_results": 10} Interaction bugs (iBugs) are defects whose essential fault lies at an interaction boundary rather than in isolated local computation. In ROS-based robotics, the term is used explicitly for bugs that “reside in the interactions of multiple separate components,” including interactions among software nodes, between software and hardware, and between the robot and its environment. Related literatures study closely analogous failures in Android apps, 3D games, DL compilers, quantum software, and LLM agent frameworks, where the triggering condition is a GUI event sequence, a player’s embodied interaction, a violated compiler–platform assumption, a mismatch across algorithmic and transpilation layers, or a failure of agent-to-agent coordination. This suggests that iBugs are best understood as a cross-domain class of defects in which components that appear locally plausible fail when composed (Chen et al., 14 Jul 2025, Mahmud et al., 7 Aug 2025, Wilkins et al., 2022, Qiu et al., 16 Jun 2026, Quetschlich et al., 3 Sep 2025, Zhu et al., 25 Feb 2026).
1. Definition, scope, and cross-domain character
The most explicit empirical treatment of iBugs appears in ROS-based software. There, iBugs are bugs that “arise from the interplay between components” and are categorized as intra-system iBugs, hardware iBugs, and environmental iBugs. In the analyzed sample of 121 iBugs from ten ROS projects, 83 were intra-system iBugs, 18 were hardware iBugs, and 20 were environmental iBugs (Chen et al., 14 Jul 2025).
Across other domains, the terminology is less uniform, but the underlying defect model is similar. In Android apps, LadyBug targets bugs whose manifestation is driven by GUI interactions, where failure is triggered by a sequence of user actions on widgets and transitions between screens. In 3D games, the perceptual-bug literature distinguishes failures detectable only from the rendered observation, and several of those failures are interaction-dependent, such as geometry clipping, boundary holes, and camera clipping. In DL compilers, the targeted faults are compiler–platform interaction bugs caused by violated assumptions across compilation passes and hardware platforms. In quantum software, most bugs in the reported dataset “emerged due to unique interactions between multiple aspects of an algorithm or workflow.” In LLM agent frameworks, the lifecycle taxonomy includes a dedicated Mutual Interaction stage and root causes such as Knowledge Transmission Issue and Concurrency Behavior Confusion (Mahmud et al., 7 Aug 2025, Wilkins et al., 2022, Qiu et al., 16 Jun 2026, Quetschlich et al., 3 Sep 2025, Zhu et al., 25 Feb 2026).
| Domain | Interaction boundary | Representative evidence |
|---|---|---|
| ROS-based robotics | software nodes, hardware, environment | 121 iBugs across ten projects |
| Android apps | screens, widgets, GUI event sequences | 80 fully localized, reproducible bug reports in RedWing |
| 3D games | player movement/collision and rendered observation | WOB with 10 injected bug types |
| DL compilers | compilation passes and hardware platforms | 2,034 bug-revealing cases |
| Quantum software | INIT, ALG, MEAS, TRNS, PLUMB, GEN intersections | 14 quantum bugs |
| LLM agent frameworks | agent lifecycle and coordination | 998 bug reports from CrewAI and LangChain |
A common misconception is to equate iBugs with only UI defects. The surveyed work does not support that restriction. GUI interaction is central in Android and some game bugs, but other studies show interaction bugs at topic, action, and executor boundaries in ROS, at message and memory boundaries in agent frameworks, and at cross-layer compiler and quantum-workflow boundaries (Chen et al., 14 Jul 2025).
2. Mobile-app iBugs: reporting, reproduction, and localization
In Android apps, iBugs are predominantly UI-driven defects whose manifestation depends on concrete interaction sequences. LadyBug addresses the file-level IR-based bug localization problem for Android apps by combining bug-report text with UI interaction data from a reproduction trace. The trace is captured through MetaMorph: a recorder uses getevent and screencap, and a replayer uses UIAutomator to inspect the GUI after each user action, extracting resource-id, widget class, text labels, content descriptions, and screen context such as Activity or Fragment names. LadyBug then extracts Screen Component terms and GUI Screen terms, uses Screen Component terms for query reformulation and filtering, and boosts files containing GUI Screen terms. On the RedWing benchmark of 80 fully localized, reproducible bug reports from 39 Android apps, UniXCoder-GUI achieved H@10 = 0.81, MAP = 0.39, MRR = 0.44, and Effectiveness = 13.81, compared with H@10 = 0.68, MAP = 0.31, MRR = 0.36, and Effectiveness = 16.41 for UniXCoder-No GUI; the reported relative improvement in Hits@10 is 16.2% (Mahmud et al., 7 Aug 2025).
The reporting side of Android iBugs is addressed by BURT, a web-based chatbot for interactive bug reporting. BURT is tailored to bugs manifesting in the app’s UI and guides end-users through observed behavior (OB), expected behavior (EB), and steps to reproduce (S2Rs). Its back end combines a Natural Language Parser based on Stanford CoreNLP, a Dialogue Manager, and a Report Processing Engine built around an App Execution Model, a directed graph of screens and GUI interactions. Quality is operationalized structurally: an OB or EB description is high-quality if it can be matched to a screen in the execution model, and an S2R is high-quality if it can be matched to an interaction edge. The S2R predictor uses shortest-path logic over weighted execution graphs to suggest likely next steps (Song et al., 2023, Song et al., 2022).
The empirical results show that interactive, execution-model-aware reporting improves the quality of interaction traces supplied by end-users. In the BURT evaluation, 54 BURT reports were compared with 54 template-based reports. The incorrect S2R rate was 8.3% for BURT versus 20.4% for the template-based system, and the missing S2R rate was 19.4% versus 32%. The same study also shows that BURT correctly matched users’ OB descriptions in 32 of 54 conversations and matched the correct screen in 157 of 205 written S2Rs (Song et al., 2023).
Taken together, these studies separate two coupled problems in mobile iBugs. BURT improves the fidelity of the interaction narrative, while LadyBug consumes an interaction trace and converts it into localization priors. A plausible implication is that, for UI-driven iBugs, reporting and localization benefit from sharing the same semantic unit: the screen/widget-level interaction path (Mahmud et al., 7 Aug 2025, Song et al., 2023).
3. Perceptual and interaction-triggered bugs in games
The 3D game literature distinguishes perceptual bugs from defects that can be detected from internal state or logs. Perceptual bugs are failures that manifest directly in what the player sees on screen. The studied bug set includes camera clipping, geometry clipping, boundary hole or player-out-of-bounds, z-clipping, z-fighting, texture missing, texture corruption, geometry corruption, black screen, and screen tear. Several of these are interaction-dependent: geometry clipping manifests when the agent moves into an object whose collisions are broken; boundary hole manifests when the agent walks over terrain with disabled collision; camera clipping is triggered when the player moves close to geometry (Wilkins et al., 2022).
Detection is framed as visual anomaly detection from the first-person RGB observation alone. The method uses a convolutional autoencoder trained on 300k normal frames from 60 episodes with no bugs. Each input frame has shape , and the model is trained with a loss that combines SSIM and MSE: At test time, the anomaly score is the squared reconstruction error: This is a frame-wise method; there is no explicit temporal model (Wilkins et al., 2022).
The World of Bugs (WOB) platform provides the experimental environment. It is Unity-based, implemented with ML-Agents, and supplies not only the main camera observation but also a bug-mask camera with pixel-level ground truth. The reported results are strongly bug-dependent. Representative values at include Black Screen with PR AUC ≈ 0.99 and ROC AUC ≈ 0.993, Boundary Hole with PR AUC ≈ 0.939 and ROC AUC ≈ 0.981, Camera Clipping with PR AUC ≈ 0.748 and ROC AUC ≈ 0.853, and Geometry Clipping with PR AUC ≈ 0.156 and ROC AUC ≈ 0.742 (Wilkins et al., 2022).
This literature is important for iBugs because it isolates a subclass in which the interaction is only indirectly visible. The fault may be in collision, geometry, or rendering logic, but the robust symptom is the rendered frame. At the same time, the study makes clear that not all perceptual bugs are interaction bugs: black screen, screen tear, and texture missing are not inherently tied to a specific interaction sequence (Wilkins et al., 2022).
4. Distributed-system iBugs: robotics and agent frameworks
In ROS-based systems, interaction boundaries are first-class architectural constructs: nodes communicate through topics, services, actions, and parameters, while callbacks are scheduled by executors. The empirical study of 121 iBugs found that Interaction Topology Errors account for 19.01% (23/121) of all iBugs, Executor Misuse for 9.10% (11/121), and Interface Misuse for 14.05% (17/121). Within hardware iBugs, Improper Resource Management accounts for 50% (9/18), and within environmental iBugs, Improper Collision Detection accounts for 45% (9/20) (Chen et al., 14 Jul 2025).
The taxonomy is granular. Interaction topology errors include Namespace mishandling, Naming mismatch, and Incorrect establishment. Execution-management failures include Action goal state mishandling, Custom state mishandling, Improper synchronization, and Executor misuse; the latter covers both improper node registration and improper callback-scheduling settings. Interface misuse includes Definition violation and Wrong assumption. The recorded impacts span task reception, perception, planning, and execution. For 86 of the 121 iBugs with known impact, execution-stage effects dominate, and Software crashes account for 27 iBugs, or 31.40% of those 86 cases (Chen et al., 14 Jul 2025).
The study also extracts 22 fix patterns. These include adding namespace passing, fixing interface names, adding or removing publishers, adding proper use of declared parameters, adding explicit synchronization mechanisms, using a separate thread for node registration and executor spinning, using a multi-threaded executor and distinct callback groups, fixing interface configurations to match documentation, and adding boundary-condition handling. The recurrence of these patterns indicates that many robotic iBugs are neither arbitrary nor purely algorithmic; they cluster around interaction contracts (Chen et al., 14 Jul 2025).
A related distributed setting appears in LLM agent frameworks. An empirical study of 998 bug reports from CrewAI and LangChain organizes framework-level defects across five lifecycle stages: Agent Initialization, Perception, Self-Action, Mutual Interaction, and Evolution. It identifies 15 root causes and 7 observable symptoms. The dominant root causes are API Misuse with 329/998 bug reports and API Incompatibility with 223/998. Interaction-focused categories include Knowledge Transmission Issue, Streaming Instability, Serialization Error, Memory Persistence Bug, and Concurrency Behavior Confusion. The dominant symptom is Functional Error with 781/998 cases, and the Mutual Interaction stage contains 53 bugs, with 49 of them exhibiting Functional Error (Zhu et al., 25 Feb 2026).
The robotics and agent-framework studies converge on a specific point: interaction bugs often arise when the coordination substrate itself is the locus of failure. In ROS that substrate is topics, actions, parameters, and executors; in LLM agent frameworks it is message passing, shared memory, workflow graphs, and evolving APIs. The defect is therefore not confined to a single component implementation, but to a protocol, scheduling discipline, or shared-state assumption (Chen et al., 14 Jul 2025, Zhu et al., 25 Feb 2026).
5. Cross-layer iBugs: compilers and quantum workflows
DL compiler testing provides a cross-layer formulation of iBugs. The targeted faults are compiler–platform interaction bugs, defined by violated assumptions that span model properties, compiler transformations, and hardware constraints. XCheck extracts full-stack constraints from documentation, compiler implementations, and hardware specifications, then uses them both to guide ONNX model generation and to insert assertions that monitor compilation behavior. The framework was evaluated on three DL compilers and found 2,034 bug-revealing cases, including memory overflows, integer overflows, and silent unexpected compilations rooted in compiler–platform interactions (Qiu et al., 16 Jun 2026).
The method is explicitly constraint-centric. Examples include resource constraints such as
and alignment constraints such as
XCheck prioritizes constraints that expose interaction-sensitive behaviors and uses assertion outcomes for behavior equivalence partitioning. The reported bug classes include 691 memory-overflow interaction bugs in GeneSys, 331 integer/dtype misuse interaction bugs in GeneSys, and 1,012 silent unexpected-compilation interaction bugs in ONNX-MLIR and TVM (Qiu et al., 16 Jun 2026).
Quantum software exhibits an analogous cross-layer pattern. The empirical study reports 14 quantum bugs and classifies them along six dimensions: INIT, ALG, MEAS, TRNS, PLUMB, and GEN. Its central result is that most quantum bugs “emerged due to unique interactions between multiple aspects of an algorithm or workflow,” and that there is no clear relationship between debugging strategies and bug classes. Representative cases include GPHASE, where a gate that is correct up to global phase becomes wrong when controlled; RESET, where missing reset after mid-circuit measurement breaks later algorithmic steps; MAPINFO and PERM, where layout and permutation information is lost or misinterpreted across framework boundaries; and QORDER, where qubit-ordering conventions interact with algorithmic and measurement semantics (Quetschlich et al., 3 Sep 2025).
These studies show that iBugs need not be tied to runtime interaction among concurrent components. They can also be cross-layer semantic bugs. In DL compilers, the interaction is between generated models, optimization passes, and hardware resource assumptions. In quantum software, it is between initialization, algorithmic structure, measurement basis, transpilation, and framework plumbing. This suggests a broader interpretation of iBugs as defects in composed semantics, not only in composed processes (Qiu et al., 16 Jun 2026, Quetschlich et al., 3 Sep 2025).
6. Detection, debugging, and open problems
Across the cited studies, iBug handling repeatedly depends on making interactions explicit. In Android reporting, BURT operationalizes quality as matchability of OB, EB, and S2Rs to an app execution model and uses graphical suggestions to reduce incorrect and missing reproduction steps. In Android localization, LadyBug transforms execution.json traces into lexical anchors—resource IDs and screen names—for query reformulation, filtering, and boosting. In 3D games, WOB uses rendered observations and pixel-level bug masks to turn interaction-triggered perceptual failures into anomaly-detection instances. In DL compilers, XCheck turns implicit assumptions into full-stack constraints and executable assertions. In quantum software, debugging strategies include equivalence checking, assertions, visualization, and formal verification, but the study reports no clear relation between those strategies and bug classes. In ROS, the proposed detection directions span static analysis, fuzzing, richer oracles, and simulator- or robot-level testing; in agent frameworks, the implications point toward lifecycle-aware testing, schema enforcement, and better state tracing (Song et al., 2023, Mahmud et al., 7 Aug 2025, Wilkins et al., 2022, Qiu et al., 16 Jun 2026, Quetschlich et al., 3 Sep 2025, Chen et al., 14 Jul 2025, Zhu et al., 25 Feb 2026).
The limitations are equally consistent. LadyBug requires a successful GUI reproduction trace and currently indexes only .java files. The WOB detector is frame-wise and visual-only, so geometry clipping in fully enclosed states can be hard to detect. XCheck does not guarantee coverage of all relevant constraints and models hardware mainly through scalar parameters. The ROS study notes that many environmental iBugs require system-level testing under varied conditions, and the agent-framework study notes that lifecycle-stage boundaries are conceptual and overlapping. The quantum study emphasizes that compound bugs often require more than one debugging approach (Mahmud et al., 7 Aug 2025, Wilkins et al., 2022, Qiu et al., 16 Jun 2026, Chen et al., 14 Jul 2025, Zhu et al., 25 Feb 2026, Quetschlich et al., 3 Sep 2025).
A plausible implication is that mature iBug research will require interaction-native representations: execution graphs for GUI workflows, explicit node/interface models for distributed robotics and agents, cross-layer constraints for compilers, and semantics-preserving metadata for quantum and other multi-representation toolchains. The surveyed work collectively indicates that local correctness is frequently insufficient; the decisive question is whether the assumptions carried by one component are preserved when that component is embedded in a larger interaction structure (Chen et al., 14 Jul 2025, Qiu et al., 16 Jun 2026).
