Graph-Based Adaptive Planning for Coordinated Dual-Arm Robotic Disassembly of Electronic Devices (eGRAP)

arXiv:2601.14998 · cs.RO · Submitted 2026-01-21 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: I'm Rosa, and with me are Dev and Taro, guest researcher.

Dev: Today's paper: "Graph-Based Adaptive Planning for Coordinated Dual-Arm Robotic Disassembly of Electronic Devices (eGRAP)".

Rosa: Electronic-device Graph-based Adaptive Planning (eGRAP) is a perception-driven,

Dev: First, who's behind it and why it matters.

Title and authors: Rosa: So, moving on to the core concept of this paper, "Graph-Based Adaptive Planning for Coordinated Dual-Arm Robotic Disassembly of Electronic Devices (eGRAP)," we're looking at how they structure the entire disassembly process using a graph model. They are essentially creating a directed graph where every detected electronic part is a node, and the edges represent rules about precedence or access—basically, which parts *must* be removed before others can be touched.

Dev: That sounds like they’ve taken the physical layout of the device and translated it into logical dependencies that an AI can follow, which is a really neat way to move from raw visual data to actionable instructions for a dual-arm setup. It formalizes the sequence of removal in a structured way that goes beyond simple trial and error.

Taro: What I find compelling about this graph approach is how it allows them to keep track of the current state of the device precisely; when an item is confirmed removed, they drop that node from the graph entirely, ensuring it always reflects what's actually visible. That dynamic removal capability is what makes it adaptive.

Rosa: And that dynamism means if a component gets revealed after you remove something else—say, an internal board—the system doesn't have to start over; it just instantly updates the graph to incorporate that new item and recalculates what comes next. That ability to adapt on the fly is pretty powerful for complex disassembly tasks.

Dev: From my perspective as a controls engineer, this topological ordering of the graph is what drives the scheduling; it ensures that only parts with no incoming edges—the ready set—are selected for action. It’s a very clean way to generate a sequence of operations that respects all those complex dependencies simultaneously.

Taro: And the tie-breakers they use, like class priority or short-move preference, are important because they show that even when multiple parts are ready, there's a defined heuristic guiding the system toward an efficient and logical removal order. It’s not just random selection; it’s guided decision-making.

Rosa: It sounds like they’ve essentially built a digital blueprint of the device's disassembly process, and instead of following that blueprint rigidly, the AI is allowed to navigate it dynamically based on what its eyes tell it is currently available. That level of autonomy in sequencing is what really sets this framework apart from older methods.

Dev: It moves the complexity from writing massive conditional logic into defining a compact set of class-level rules and templates for actions; that abstraction makes the system much easier to maintain and update when we introduce new product types later on. That modularity is a major win for long-term system viability.

The paper's summary: Rosa: So, to summarize the core of "Graph-Based Adaptive Planning for Coordinated Dual-Arm Robotic Disassembly of Electronic Devices (eGRAP)," the paper presents a closed-loop system that combines vision, dynamic planning, and dual-arm execution to handle disassembly. It starts by using a camera on an arm to identify and estimate the poses of all parts.

Dev: That perception output—a set of labeled part instances with three dee poses expressed in a shared world frame—is what feeds into the next stage, which is building and constantly refreshing the precedence graph based on those detections and predefined rules <ref:2601.14998#pg0>. This graph dictates the flow of work.

Taro: The core planning mechanism then uses topological ordering to select valid next steps from this graph, ensuring that only parts that have no prerequisites are scheduled for removal at any given moment. This selection is guided by heuristics like class priority to manage the sequence efficiently.

Rosa: And then, the dual-arm execution comes into play; a scheduler assigns those selected actions to two robot arms, carefully managing constraints like collision avoidance and workspace limits to ensure they work in parallel whenever possible. This coordinated action allows for simultaneous tasks that might otherwise have to be done sequentially.

Dev: The loop is truly closed-loop because when an action is executed, the state changes, the graph is updated immediately, and this new state feeds back into perception, allowing the entire sequence to adapt online as disassembly progresses. It's not a one-shot plan that gets thrown away; it evolves with the scene.

Taro: I think what makes this summary so effective is emphasizing that every part of the system—perception, graph maintenance, scheduling, and execution—is tightly coupled in a continuous cycle. That tight coupling is what enables the system to maintain consistency even as the physical environment changes around it.

Rosa: It paints a picture of an autonomous agent that can look at a complex piece of e-waste, understand its structure through vision, plan a coordinated takedown using two arms based on rules, and then physically perform those actions while constantly updating its understanding of what's left behind. That’s quite a lot to handle in real time.

Dev: It really shows the shift toward systems where the planning isn't just an initial calculation but an ongoing process that is continuously informed by physical reality, which speaks directly to improving reliability over time and under variable conditions.

The paper's improvements: Rosa: Now, let's discuss what the authors suggest as improvements for this system, because it’s clear they’re not just presenting a finished product but also thinking about how to push its capabilities further. They focus on integrating more sophisticated perception and action primitives into the framework.

Dev: They suggest using YOLOv11, fine-tuned on custom datasets, specifically to provide robust three dee pose estimation for all parts across different device families <ref:2601.14998#pg0>. That would significantly strengthen the system's ability to generalize beyond just one type of device model by improving how accurately it perceives those initial nodes in the graph.

Taro: I’m also interested in their proposal for a two-stage perception pipeline, using a global RGB-D camera for coarse positioning and then a local, close-range micro-camera stream specifically for detecting screw heads with high precision. That sounds like they are tackling the challenge of small, reflective targets in a very targeted way.

Rosa: That targeted approach to screws sounds smart; it isolates the most difficult interaction—the precise seating of a fastener—to where the highest fidelity sensing is needed, rather than trying to solve everything perfectly with one sensor setup. It addresses a known pain point in manual disassembly.

Dev: They also mention developing a robust action primitive library that includes specific "fastener engagement routines" that incorporate visual alignment checks before applying torque, which means they are planning not just the removal of a screw, but ensuring it’s removed correctly and safely first. That builds safety directly into the execution logic.

Taro: Integrating these refined action primitives with their topological scheduler suggests a system that can handle more complex, multi-step tasks where an action isn't just 'remove,' but rather a sequence of 'align, engage torque, verify.' It pushes the capability toward more nuanced manipulation beyond simple pick-and-place.

Rosa: So the overall improvement direction seems to be moving from a general planner to one that incorporates highly specific sensory feedback and safety checks directly into every step of the removal process. That’s what makes it robust against unexpected mechanical issues during disassembly.

Dev: If they can do that, integrating those alignment checks before torque application means fewer failed actions and less need for complex replanning, which directly impacts the latency and overall cycle time we’re concerned about in a real-world operation.

Conclusion: Rosa: So to wrap things up on this paper, "Graph-Based Adaptive Planning for Coordinated Dual-Arm Robotic Disassembly of Electronic Devices (eGRAP)," it shows a powerful methodology for creating an autonomous system that plans and executes the disassembly of electronic devices using a dynamic graph model. It successfully demonstrates consistent full disassembly of three point five in hard drives with high success rates and efficient cycle times, showing the method's capability to adaptively coordinate dual-arm tasks in real time <ref:2601.14998#pg0,to adaptively coordinate dual-arm tasks in real time>.

Dev: We see a framework where perception feeds an online-updated precedence graph, which is then topologically sorted by a scheduler to assign coordinated actions to two arms that respect spatial constraints. This ability to manage dependencies while running parallel tasks is what makes the system quite effective for complex disassembly scenarios.

Taro: The paper really emphasizes the value of this structure in terms of generalization; by separating device content from the core reasoning, it allows the framework to be updated simply by swapping out part types and rules, which supports reuse across different product families.

Rosa: It feels like we’re looking at a very practical path toward automating a tedious and complex industrial process that currently requires significant human intervention, provided we can get it deployed robustly outside the lab environment.

Dev: My main concern remains the loop rate; for this to be truly efficient in an operational setting, that entire perception-planning-execution cycle needs to execute fast enough to handle the inherent variability of physical interaction without introducing unacceptable delays.

Taro: I just think their focus on how the system handles missing or newly revealed parts in real time is where the most significant potential lies for making it truly autonomous and resilient in a messy, real-world setting.

Rosa: It’s been fascinating seeing how they’ve tied together vision, graph theory, and dual-arm coordination so tightly to tackle this e-waste problem; I think we'll need to keep watching how they push these improvements into more complex manipulation next.

Heriot-Watt University

cs.RO

Submitted: 2026-01-21

Updated: 2026-01-21

Comments: 7 Pages, 8 Figures, 5 Tables

Journal ref: 2026 IEEE/ASME International Conference on Advanced Intelligent Mechatronics (AIM), 2026, pp. 1-8

DOI: 10.1109/AIM65483.2026.11658063

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 86/100

The gist: Electronic-device Graph-based Adaptive Planning (eGRAP) is a perception-driven, graph-based planning framework that enables coordinated dual-arm robotic disassembly of electronic devices by

Key concepts

Part Graph: This is a directed map where every detected electronic component is a node. Arrows (edges) between nodes represent rules like 'this must come before that' based on physical constraints or access requirements. Removing a node updates the graph, ensuring it always reflects the current state of the device.
Topological Scheduler: This mechanism processes the part graph to find actions that are ready to be performed. It looks for nodes with no incoming edges (ready set) and uses priority rules, such as fastener removal first, to decide which action should happen next in the disassembly sequence.
Dual-Arm Calibration: Before working, two robotic arms must be precisely aligned using a vision system involving an ArUco marker. This ensures both arms share a common coordinate frame and understand each other's workspace. This is crucial for safely coordinating actions that require both arms to work together or operate near each other.
Closed-Loop System: The framework operates continuously in a loop: perception detects parts, the graph is updated, the scheduler plans actions, and execution performs them. This constant feedback allows the system to handle uncertainties and adapt its plan immediately when new visual information changes during disassembly.

Terminology

Alignment — 15× in this paper · explained in 1 episode
Adaptive Planning — 9× in this paper · explained in 1 episode
Core — 9× in this paper · explained in 2 episodes
Calibration — 6× in this paper · explained in 7 episodes
Adaptation — 5× in this paper · explained in 1 episode
Action Primitives — 4× in this paper · explained in 1 episode
Accuracy — 3× in this paper · explained in 1 episode
Closed-Loop System — 3× in this paper · explained in 4 episodes
Benchmark — 2× in this paper · explained in 2 episodes
Generalization — 2× in this paper · explained in 13 episodes
Robustness — 2× in this paper · explained in 5 episodes
Abstraction — 1× in this paper · explained in 1 episode
Consistency — 1× in this paper · explained in 3 episodes
Fidelity — 1× in this paper · explained in 2 episodes
Graph Construction — 1× in this paper · explained in 3 episodes
Modularity — 1× in this paper · explained in 9 episodes
Standardized Benchmarks — 1× in this paper · explained in 2 episodes
Task Planning — 1× in this paper · explained in 2 episodes

Summary

Electronic-device Graph-based Adaptive Planning (eGRAP) is a perception-driven, graph-based planning framework that enables coordinated dual-arm robotic disassembly of electronic devices by converting live detections into a precedence graph and applying simple rules to coordinate dual-arm actions. This method is significant because it generalizes across different products and robot setups by separating device content from the core reasoning, allowing for adaptation to missing or newly revealed parts in real time.

The gist: The method builds a directed part graph from live RGB-D detections, encodes precedence and access rules, and uses a topological scheduler to select the next valid actions. A coordination scheme assigns actions to two arms under collision and workspace limits while exposing safe parallel steps when dependencies allow it.

How it works

The eGRAP framework is a closed-loop system combining perception (to detect and identify parts), graph-based reasoning (to decide a removal order), and dual-arm execution. It operates in a fixed-rate loop: perception updates detections; the graph is refreshed from class rules; a topological pass exposes the next ready actions; actions are instantiated from templates and scheduled; execution feeds back state. This design allows for online maintenance of the precedence graph, enabling adaptation to scene changes.

The perception pipeline involves two stages. First, an eye-in-hand RGB-D camera provides a global view of the device to detect and classify parts into classes like screw/fastener, lid, PCB, providing 3D poses in a shared world coordinate frame. The second stage is a local, close-range refinement used only for screws, employing a micro-camera to achieve close view to detect screw-heads precisely and apply small in-plane correction before seating the driver. This two-stage approach addresses the challenges of small, reflective targets.

Graph Construction and Sequencing

The Part Graph represents the current device state where each detected item is a node. A directed edge between nodes encodes rules such as precedence or access, which are automatically added by a compact set of class-level rules. When a node is confirmed removed, it is dropped from the graph, ensuring the graph always reflects the visible, current device. The sequence generator then builds an order by collecting the ready set of nodes: these are parts that are still present and have no incoming edges, using tie-breakers like class priority (fasteners before lid) and a short-move preference. These ordered nodes are mapped to action primitives such as unscrew, lift, remove, and drop.

Dual-Arm Calibration and Scheduling

Before execution, both arms are brought into a common frame using a vision-based calibration involving an ArUco marker. The eGRAP scheduler assigns actions based on capability and workspace constraints. It selects actions that can run in parallel without spatial interference or synchronizes dependent actions to realize safe hold-operate behaviours. For instance, the tooling arm performs an unscrew action, while the manipulation arm issues a corresponding lift or remove action only when dependencies allow it, minimizing idle time.

Execution and Performance

The execution loop involves issuing actions based on the topological sort. For example, in Layer 1 (L1), a screw becomes ready, triggering an unscrew action on the tooling arm. Once successful, the node is removed from the graph; when all incident screws are gone, a guarded lift action is dispatched to the manipulation arm to remove the lid. The system handles uncertainty by re-queuing failed actions with pose adjustments while other ready actions proceed. Experiments on three 3.5 in hard drives show consistent full disassembly of each HDD, with high success rates and efficient cycle times, completing full teardowns within an average of 22 minutes per unit across all tested models. The system's performance is robust, showing a full teardown completion success rate of 90.0% for Samsung and Seagate models.

Scalability and Generalization

The framework is designed to be device-agnostic, allowing transfer to new product families by simply updating the set of part types, a compact set of precedence/access rules, and a library of action templates. The core pipeline—converting live detections to a precedence graph and executing it with coordinated dual-arm control—remains unchanged. This structure supports reuse across products and robot platforms while maintaining the ability to handle missing or newly revealed parts through its instance-based reasoning. Future work aims to expand this by including flexible elements like cables and gaskets.

References

[1] ewastemonitor, “The Global E-waste Monitor 2024,” Mar. 2024.

[2] H. Poschmann, H. Brüggemann, and D. Goldmann, “Disassembly 4.0: A Review on Using Robotics in Disassembly Tasks as a Way of Automation,” Chemie Ingenieur Technik, vol.

Improvements for AI systems

Here are specific improvements for AI systems based on the eGRAP framework, and what those improved systems can achieve:

The core improvement is shifting from fixed program or device-specific robots to a unified, perception-driven disassembly pipeline capable of handling product variation.
The improved AI system will be able to perform autonomous, coordinated disassembly of diverse electronic devices (like HDDs) without requiring manual reprogramming for every new model.

Specific Improvements:

Implement a closed-loop system that tightly couples live visual perception to an online-updated part graph and a dual-arm scheduler.
Develop a vision module utilizing YOLOv11, fine-tuned on custom datasets, to provide robust 3D pose estimation for all detected parts across different device families (e.g., Samsung vs. Seagate HDDs).
Integrate a two-stage perception pipeline: use global RGB-D for coarse positioning and a localized micro-camera stream for high-precision, contact-validated alignment during critical tasks like screw engagement (e.g., Torx T8 screws).
Establish a dynamic precedence graph where nodes are live detections, automatically updated upon part removal or revelation, allowing the system to adapt to missing or newly exposed components in real-time.
Develop a topological scheduler that selects valid next steps based on the current graph state, assigning tasks to two arms while respecting complex constraints (collision avoidance and workspace limits).
Implement a robust action primitive library that includes hold-operate behaviors for coordination and specific fastener engagement routines incorporating visual alignment checks before applying torque, with automatic re-queuing/re-planning upon failure.

What the Improved AI System Can Do:

Perform autonomous disassembly of any supported electronic device family (e.g., HDDs) with consistent, high success rates and efficient cycle times (averaging under 22 minutes per unit).
Maintain a unified reasoning loop across different products simply by updating part labels, class rules, and detection models rather than rewriting the entire planning logic.
Handle uncertainty in mechanical tasks (like screw removal) by dynamically adjusting the plan—pausing on faults, re-scanning affected nodes, and immediately generating a corrected sequence without requiring human intervention or pre-programmed error scripts.
Execute complex multi-stage disassembly sequences (L1: lid/screws; L2: internals; L3: case) in parallel across two robot arms, ensuring that dependent steps are synchronized while independent tasks run concurrently to maximize throughput and minimize idle time.
Adapt instantly to scene changes (e.g., a screw being missing or a component being unexpectedly revealed), allowing the system to seamlessly integrate new parts into the planning graph and generate an optimized path forward without needing a full re-planning cycle from scratch.