rest mesh ( Arduinouno q and open weight models)

👻 SlothMesh: The Ghost in the Network — Edge AI That Watches, Reasons, and Responds

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

What if the most dangerous problems in a network were the ones nobody noticed until it was too late?

A wireless connection can appear normal while its performance is slowly degrading. A device can behave unexpectedly before a complete failure. And by the time a human notices something wrong on a dashboard, the damage may already be done.

That is the idea behind SlothMesh, an open-source edge AI prototype built around the Arduino UNO Q.

I wanted to explore a different approach to network monitoring: instead of continuously relying on a large AI model to analyze every observation, what if a lightweight model could watch the network, recognize suspicious changes, and bring in a language model only when deeper reasoning is needed?

SlothMesh combines two AI layers:

• TinyML: A compact INT8 neural network classifies wireless link conditions as healthy, degrading, or critical.
• Local AI reasoning: A language model helps investigate network conditions and explain possible causes. The current demonstration uses Gemma 4 E4B.

A deterministic decision layer is designed to constrain AI-generated recommendations rather than giving the language model unrestricted control over system actions.

This is how I interpreted Ghost in the Machine: the hidden intelligence operating behind the scenes, watching for problems that might otherwise go unnoticed.

The goal is not to make AI mysterious. It is to make its behavior useful, inspectable, and more independent of remote infrastructure.

SlothMesh is a prototype exploring this approach, not a claim of production-ready autonomous network security.

Demo

🎥 Watch SlothMesh in action:

https://youtu.be/ZsdrWbRsLm0?si=deoVA0rklRuiukJb

Code

💻 GitHub repository:

https://github.com/yashwan7/uno-Q

The repository includes the project implementation, TinyML components, simulation workflows, an interactive dashboard, automated tests, and benchmarking scripts.

You can explore the code, inspect the implementation, and experiment with the project yourself.

How I Built It

I built SlothMesh around the Arduino UNO Q and its edge-computing capabilities.

The architecture separates routine classification from higher-level reasoning:

1. Observe: Collect wireless-link telemetry for monitoring.
2. Classify: Use a compact INT8 neural network to classify link conditions.
3. Investigate: Use a local language model when deeper diagnosis is needed.
4. Constrain: Keep recommendations subject to a deterministic decision layer.
5. Visualize and evaluate: Use the dashboard, simulations, tests, and benchmarks to inspect behavior.

The project uses Python for much of its software workflow, with a lightweight ML component for classification and a local language model for reasoning.

The current video demonstration uses Gemma 4 E4B. The repository's existing quickstart and benchmark artifacts also document an earlier Qwen-based workflow, so those benchmark results should not be interpreted as measurements of the Gemma demonstration.

The aim is to make experimentation reproducible, with code and workflows available for others to inspect and improve.

Why Does Open Innovation Matter?

A project about local intelligence should not depend entirely on intelligence hidden behind a remote API.

Open innovation makes it possible to experiment with model choices, inspect decision logic, reproduce tests, and adapt the architecture to different environments.

For SlothMesh, this matters in three ways:

• Local experimentation: Explore AI reasoning closer to where network data is generated.
• Transparency: Make the implementation and evaluation workflows available for review.
• Community-driven improvement: Allow other developers to test alternative models, improve the classifier, challenge assumptions, and build on the project.

A closed API can be useful, but an open implementation gives developers more control over how the system is assembled, evaluated, and adapted.

My goal is to make edge AI something developers can investigate and improve—not just something they call through an endpoint.

The Spirit of It

The unsettling part of a malfunctioning system is that it rarely announces itself.

Sometimes, everything looks fine until it suddenly doesn't.

I wanted to explore what happens when a small, always-present intelligence watches those quiet changes: a classifier noticing degradation, a local model investigating the possible cause, and a constrained decision layer helping turn observations into useful next steps.

There is no supernatural intelligence here. The “ghost” is the hidden layer of computation that operates behind the interface—one that we should be able to inspect, question, and improve.

The future of AI should not only be intelligent. It should also be understandable.

SlothMesh is my step toward exploring that idea.

My Agent Session

Optional — add a DevRelay agent session here if you saved one during development. Remove this section if you don't have a session to share.