Compute Regeneration through Re-Productization: Reorganizing Retired Edge AI Silicon into a Delivered Multilingual Service Robot

Hongyu Luo, Sun Tie, John Wang

TL;DR

This paper introduces "compute regeneration" through re-productization: a systems-design approach to rescue powerful but "retired" edge AI hardware from the landfill. By redesigning the system architecture—specifically offloading deterministic tasks to microcontrollers and isolating non-deterministic AI workloads—the authors successfully transformed a retired NVIDIA Jetson AGX Xavier into the core of a fully functional, multilingual service robot called GEdgeBot.

What Problem Does This Paper Address?

We are facing a massive e-waste crisis, with 62 million tonnes generated in 2022 alone. A significant contributor is the "software ceiling": edge AI modules often retain substantial compute power but lose official support as newer operating systems and AI frameworks move beyond their last supported board-support packages (BSPs).

The authors argue that we shouldn't view these modules as "old" but as "residual compute assets." The challenge is that simply running a new benchmark on an old board isn't enough to make it useful. To truly reuse this hardware, one must solve the systems-level problems of timing interference (AI loads messing up motor control), peripheral integration, and software dependency hell.

Methods

The authors propose a re-productization ladder to distinguish their approach from simple refurbishment or repurposing.

Fig. 1. The proposed value-capture ladder is a systems-design distinction, not a measured ranking of economic or environmental benefit. Re-productization preserves the compute module while redesigning the product organization around it; in this case an AI box becomes the compute core of a delivered service robot.

Key architectural strategies used in the GEdgeBot include:

  • Workload Decomposition: Rapidly evolving, non-deterministic AI models (YOLO, Whisper, NLLB) run on the "retired" Xavier, while stable, timing-critical motor-pulse generation is moved to a dedicated STM32F407 microcontroller.
  • Deterministic Control Boundary: Communication between the Xavier and the MCU is restricted to a narrow, 7-byte semantic UART interface. This isolates the robot's physical movement from the jitter caused by heavy AI processing on the main CPU.
  • Software Isolation: To bypass the "software ceiling," the authors built an isolated inference stack (using local versions of CUDA/PyTorch) that doesn't rely on system-wide library updates.
  • Source-Grounded Auditing: The paper uses rigorous AST (Abstract Syntax Tree) audits of the robot's source code to verify the existence of control mechanisms and state machines, rather than relying solely on potentially unreproducible physical demonstrations.
Fig. 2. Source-grounded GEdgeBot architecture. The Astra/OpenNI path is used by the captured person-following runtime; the FPD-Link path is a separately documented V4L2 integration and is not assumed to be the camera used in every demonstration. Online connectors are shown explicitly because the current voice assistant is not invariably offline.

Datasets

The paper evaluates the system using several standard AI models rather than a specific new dataset:

  • YOLOv8n: For real-time person detection and following.
  • Whisper-small: For on-device automatic speech recognition (ASR).
  • NLLB-200: For multilingual machine translation (MT).
  • ChatTTS: For text-to-speech (TTS) synthesis.

Performance was measured through historical logs and a new "November campaign" designed to independently validate the AI workloads and control timing.

Key Insights and Ideas

  • System Organization > Raw Throughput: The value of "retired" silicon isn't just its peak FPS; it's how you organize the system around its constraints. Re-productization creates value at the interface between the old compute core and the new product design.
  • The Jitter Problem: Running heavy AI models on a general-purpose OS (like Linux on the Xavier) creates massive timing interference. Historical data showed motor-control jitter (p99 deviation) jumping from 0.24 ms to nearly 50 ms under AI load—a 208x increase that could make a robot's movement erratic or dangerous.
  • Orchestration Hides Latency: By "prewarming" AI models in the background during idle states, the system can move multi-second cold starts off the critical "trigger-to-follow" path.
  • Kinematic Cancellation: To keep the camera fixed on a speaker while the robot's body turns, the system uses a "counter-turning" head coordination strategy.
The intended kinematic cancellation for sound-source orientation.

Key Results

  • Memory Residency: The authors proved that YOLO, Whisper, and NLLB can coexist in 1,782 MB of GPU memory, making the Xavier (with 32 GB) more than capable of handling the load.
  • End-to-End Success: In physical demonstrations, the robot successfully completed "trigger-to-follow" sequences (detecting a sound, turning to face the speaker, and following them) with a mean latency of 4.35 seconds.
  • Protocol Validation: A software-in-the-loop replay of 14 scenarios across all six operating modes achieved a 100% success rate in executing the audited control logic without needing physical hardware.

Limitations and Future Work

  • Single Prototype: The results are based on one robot; fleet-level reliability and universal operation are not yet claimed.
  • Safety Gaps: While the finite-pulse offload removes "runaway" motor states, the safety bounds are currently enforced by the host software, not the MCU firmware. Future work should move these clamps into the firmware and add hardware watchdogs.
  • Missing Historical Data: The authors noted that some original logs from early experiments were lost, highlighting the need for better data provenance in long-term hardware reuse projects.
  • Environmental Impact: While the paper motivates reuse to reduce e-waste, it does not yet provide a full lifecycle assessment (LCA) to quantify the carbon or economic benefits.

Summary updated

Abstract

Useful edge hardware can lose product support while retaining substantial computation. We treat this as systems design: compute regeneration here means re-productization, retaining the compute module while redesigning the surrounding product organization. Our case is GEdgeBot, a multilingual service robot built around a retired 32 GB Jetson AGX Xavier. A source-grounded inventory shows the box alone supplies inference, while the combined system exposes five on-device AI services, a seven-language speech chain, three sensing domains, and one deterministic seven-byte control boundary. AI and orchestration stay on the Xavier; finite motor-pulse generation on an STM32F407. Audits cover the six-mode control state machine, readiness barriers and sound orientation. Historical single-prototype measurements report 1,782 MB GPU memory with YOLO, Whisper-small, and NLLB-200 resident, a direct-control p99 deviation rising from 0.24 to 49.93 ms under concurrent AI load, and six of six trigger-to-follow demonstrations at 4.35 s mean latency, with conversational voice unavailable. A November campaign restores an isolated inference stack, re-measures AI workloads, and repeats control-frame runs. Driving two execution organisations with the same 6,000 measured 50 ms frame intervals shows the finite-pulse boundary removes host jitter from the pulse train but not the command start phase; its stopping bound is host-enforced, while the MCU 16-bit pulse field is unclamped. A six-check static audit exposes a host--MCU queue mismatch, and a 14-scenario replay executes the audited main() dispatcher across six modes with zero physical device opens and 54 contract-checked frames. Results support an existence claim and a reproducible architectural hypothesis, not fleet-level reliability. The 208 direct-control ratio remains unreplicated; MCU waveform capture and on-site fault injection remain open.
BibTeX
@misc{luo2026compute,
  author = {Hongyu Luo and Sun Tie and John Wang},
  title = {{Compute Regeneration through Re-Productization: Reorganizing Retired Edge AI Silicon into a Delivered Multilingual Service Robot}},
  year = {2026},
  eprint = {2611.11698},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.11698},
}
Figure