EuroMog: AI Maintenance Agent for Rotating Machines

Inspiration

During an internship, one of us saw a large industrial group ship its motor all the way to a lab far away in Europe just to have its vibrations tested. It took weeks, cost a lot, and only worked because the company was big enough to afford it. Smaller companies simply can't: they run their machines until something breaks.

We asked: what if the vibration expert came to the machine instead? A cheap accelerometer, a microcontroller, and an AI agent that doesn't just raise an alarm, but tests the machine itself, weighs the operator's constraints ("we have an order due tonight"), decides what to do, and checks whether the repair actually worked. Diagnosis on site, in minutes, for the price of a few components.

What it does

EuroMog watches a rotating machine through an accelerometer and compares it to a healthy baseline (its vibration fingerprint when it's working well).

When an alarm fires, an agent investigates instead of just reacting:

It re-measures to rule out a transient (a knock, someone touching the machine).
It reads the operator's notes ("Order due at 20:00, we need maximum output") and the machine's history.
It runs its own experiment: it sweeps the motor through several speeds. Vibration that grows with speed points to imbalance; harmonics point to looseness.
It decides: keep running, run slower, or stop. It picks the highest speed that stays safe for the deadline, and sets its own guard (e.g. "slow down if vibration exceeds x1.5"), which the monitor enforces in code.
It opens a maintenance ticket with its evidence and recommended action.

When a technician says the repair is done, the agent re-tests the machine and checks the repair against its diagnosis. "Tightened the bolts" doesn't fix an imbalance, so the ticket stays open. A verified repair closes the ticket and records a new healthy baseline.

How we built it

Hardware: DC motor with an off-center mass on a plank, driven by a motor driver from an Arduino Uno; an MPU6050 accelerometer sampled at 1 kHz over I2C.
Signal processing (Python, NumPy): 1 s windows, Hann window, FFT; we track the shaft frequency (1×) and its 2× and 3× harmonics. Imbalance is the 1× amplitude normalized by speed², looseness is the harmonic content, and the overall vibration level is RMS. All of them are measured as ratios against the healthy baseline, floored at the measured noise level.
Agent: a Gemini tool-calling loop over plain REST. Tools: measure, speed_sweep, set_speed, get_history, get_operator_notes, finish. A safety layer clamps every speed command; an emergency stop and the agent's own guard are enforced by deterministic code, never left to the model. If the model is unreachable, a rule-based fallback takes over.
Dashboard (Streamlit): live status, the agent's plan and guard, the experiments it ran, tickets with a repair form, and a box to brief the agent.

Challenges we ran into

Motor noise crashed the I2C bus: the MPU6050 would freeze or fall asleep and return zeros. We added I2C timeouts, wake-up and re-initialization, and error reporting in the firmware.
Locking onto the wrong peak: the baseline first locked onto 160 Hz, the 3rd harmonic. We constrained the search to the motor's real range (it stalls below duty ~150 and spins at 38–60 Hz).
Ratios exploding: near-zero baseline peaks made ratios jump to x50–x100. We measured the noise floor at baseline time and floored every denominator with it.
Making the agent worth it: our first version did what a few if-statements could. We redesigned it around things only an agent can do: combine human context, choose experiments, and judge a technician's explanation.

Accomplishments that we're proud of

A real rig where an AI agent runs experiments on physical hardware and makes a decision it can explain.
It correctly called a knock a transient, set its own guard, and re-investigated when the guard tripped.
Safety is designed in: the model can suggest, but code clamps and enforces.

What we learned

Signal processing on real hardware is messy: noise floors, harmonics, sensor dropouts. And the value of an LLM agent isn't replacing the math; it's deciding which measurement to take and weighing it against human context.

What's real and what's simulated

Everything in the demo runs on the real rig with live Gemini decisions. Resonance is shown only in our simulator: our plank's natural frequency (~16 Hz) is below the motor's reachable speed range.

What's next

Scale up: wireless sensors on every machine, all watched by one agent that compares them to each other.
Smarter diagnosis: detect more faults (worn bearings, misalignment, resonance) and learn from every repair.
Real-world integration: connect to maintenance software and production schedules so the agent books technicians on its own, with safety checks enforced in code.
Accessible to all: a kit under $100 per machine for small workshops that can't ship their motors to a lab. Our next step is a pilot with a small manufacturer.