Hyper-K

Hyper-K turns Jira into a Digital Pit Wall. Rovo acts as a Race Engineer monitoring 3D Komatsu Twins, utilizing F1 telemetry strategies to predict thermal runaway and trigger Pit Stops.

Comment

Inspiration

I was fascinated by the technical partnership between Williams Racing and Komatsu. On the surface, a Formula 1 car and a 36-ton Hybrid Excavator seem worlds apart. But digging into the engineering, I realized they share a critical DNA: Energy Recovery Systems (ERS).

In F1, managing the thermal stress of the battery during regeneration (braking) is the difference between a podium and a DNF (Did Not Finish). In mining, the Komatsu HB365LC-3 uses an Ultra-Capacitor to capture swing energy. If that capacitor overheats—a phenomenon known as "Thermal Runaway"—it costs $15,000 to replace and kills 3-5 days of productivity.

I asked myself: What if I could treat a mining excavator exactly like the FW46 race car?

This inspired Hyper-K: A "Digital Pit Wall" that turns Jira Service Management into a race strategy center, using an AI Agent as the Race Engineer to predict failure before the smoke clears.

What it does

Hyper-K is a telemetry twin application built on Atlassian Forge. It transforms a standard Jira Issue into a live 3D command center.

3D Digital Twin: It renders a high-fidelity model of the excavator directly in Jira. I built a custom Heatmap Shader that visualizes "invisible" heat data. As the simulated capacitor temperature rises, the specific component on the 3D model glows from Green to Red.

The Rovo Race Engineer: I didn't just want a chatbot; I wanted a strategist. The Rovo Agent monitors the live data stream. Instead of waiting for a hard failure, it calculates the Rate of Rise ($RoR$).

Automated Pit Stops: If the Agent detects a thermal anomaly ($RoR > 2.0^\circ C/min$), it autonomously negotiates a "Pit Stop" by creating a High-Priority Incident ticket in Jira Service Management, complete with diagnostic snapshots.

Chaos Monkey Simulation: For the demo, I built a physics engine that allows me to inject a cooling pump failure, forcing a real-time thermal runaway event to demonstrate the system's reaction speed.

How we built it

I architected a Decoupled Hybrid Cloud solution to overcome the constraints of running high-frequency physics on a FaaS platform.

The Frontend (The Pit Wall): I used Atlassian Forge Custom UI with React 19 and Tailwind CSS v4 to build a "Glassmorphism" interface inspired by F1 telemetry screens.

The Visualization: I used React Three Fiber (R3F) to handle the WebGL rendering. The core logic relies on a linear interpolation shader to map temperature to color:

$$C_{final} = \text{lerp}(C_{safe}, C_{critical}, \frac{T_{current} - 20}{80})$$

The Brain (AI): I configured an Atlassian Rovo Agent with a "Chain of Thought" system prompt, grounding it in a mock "Komatsu Technical Manual" via the Knowledge Base (RAG).

The Simulator (Backend): I wrote a Python FastAPI service (deployed on Render) to mimic the physics of the Komatsu Hybrid System, simulating voltage drops during "Assist" cycles and heat generation during "Regen" cycles.

The "GCS Bypass": To work around the Forge 10MB bundle limit, I streamed the detailed .glb assets from a public Google Cloud Storage bucket directly into the React canvas.

Challenges we ran into

The biggest technical hurdle was Asset Management within Forge. High-fidelity industrial CAD models are heavy. Attempting to bundle the GLTF file inside the Forge app caused deployment timeouts and exceeded the 10MB limit.

I solved this by implementing a cloud-streaming pattern. I hosted the model on GCS and configured strict CORS policies to allow the Forge Custom UI iframe to fetch the binary data directly, bypassing the Atlassian infrastructure for the heavy lifting while keeping the secure logic inside the Resolver.

Another challenge was Rovo's Decision Logic. Initially, the Agent was too "chatty." I had to refine the system prompt to force it into a "Formula 1 Race Engineer" persona—concise, data-driven, and prioritizing the Rate of Rise over absolute values.

Accomplishments that we're proud of

Running React 19 & Tailwind v4 on Forge: Getting the very latest frontend stack to play nicely with the Forge bridge and bundling process was a significant config victory.

The "Red Glow" Effect: Seeing the 3D model actually react to the Python backend's "Chaos Monkey" signal in real-time was a visceral "It works!" moment.

Agent Autonomy: The first time I told Rovo to "Create a ticket" and it successfully parsed the telemetry context and populated the JSM fields correctly, I felt like I had a real co-pilot.

What we learned

I learned that Atlassian Rovo is much more than a text summarizer; it is a powerful orchestration layer for APIs. By binding Rovo Actions to my Python backend, I turned a static LLM into a monitoring tool that can "see" physics.

I also gained a deeper appreciation for the Williams Racing x Komatsu partnership. The engineering parallels between kinetic energy recovery on the track and in the dirt are genuine, and software is the bridge that connects them.

What's next for Hyper-K

AR Integration: Extending the React Three Fiber view to WebXR so field technicians can overlay the heatmap onto the physical machine using a tablet.

Fleet Aggregation: Moving from a single-unit view to a global fleet dashboard using Jira Assets.

Real IoT Ingestion: Replacing the Python simulator with a live MQTT stream from AWS IoT Core.

Built With

Share this project:

Updates