AuraNode

AuraNode uses Gen AI to instantly design and simulate live IoT digital twins from a single text prompt. It features an active auto-remediation protocol which resolves critical failures in RT.

Comment

💡 Inspiration

As an Electronics and Communication Engineering (ECE) student, I spend a lot of time working with microcontrollers and sensor arrays. The hardware is fun, but setting up the monitoring dashboards, configuring sensor thresholds, and building the UI is a tedious, manual process that takes days.

When I saw the Signodes IoT community hosting this event, I asked myself: "What if we didn’t have to build these dashboards at all? What if an AI could instantly architect and simulate a live digital twin of any environment just from a text prompt?" That question sparked the creation of AuraNode.

⚙️ What it does

AuraNode is an autonomous facility manager and procedural IoT digital twin generator. Instead of typing to a chatbot, users input a physical scenario (e.g., "Simulate a server room with a broken AC"). AuraNode instantly:

  1. Architects the Network: Deduces the exact sensors needed for the context (e.g., Temperature, Airflow, Power Draw).
  2. Generates the UI: Renders a cyberpunk-themed 60FPS canvas dashboard and real-time Chart.js graphs.
  3. Simulates Physics: Plugs the AI-generated base values and volatility metrics into a custom physics engine to stream live data.
  4. Auto-Remediates: A secondary autonomous loop analyzes the live data and allows users to trigger an "Auto-Remediation" protocol, where the system takes control, mitigates the crisis, and mathematically stabilizes the environment back to safe baselines.

🛠️ How we built it

AuraNode was built to be lightning-fast and entirely local-first for the client.

  • Backend: Node.js and Express.
  • AI Core: The Google Gemini API. We bypassed standard conversational generation and heavily utilized Structured Output. By forcing Gemini into a strict JSON schema, it acts as a deterministic spatial architect rather than a chat assistant.
  • Frontend: Vanilla JavaScript, Tailwind CSS (for the glassmorphism UI), HTML5 <canvas> for the glowing sensor nodes, and Chart.js for plotting the telemetry.

The Simulation Engine (The Math)

To make the digital twin look realistic, the frontend doesn't just plot static numbers. It takes the base_value and volatility parameters generated by Gemini and feeds them into a stochastic simulation loop. The real-time sensor value \(S(t)\) at any given frame is calculated using a modified random walk with baseline reversion:

$$ S(t) = S_{base} + \alpha \cdot \sin(\omega t) + \mathcal{N}(0, \sigma^2 \cdot V) $$

Where:

  • \(S_{base}\) is the Gemini-assigned normal state.
  • \(\alpha \cdot \sin(\omega t)\) introduces natural environmental drift.
  • \(\mathcal{N}(0, \sigma^2 \cdot V)\) applies Gaussian noise scaled by the Gemini-assigned Volatility metric (\(V\)), creating the erratic spikes during a crisis simulation.

When the user clicks the Auto-Remediation button, the system dynamically applies a dampening factor to \(V\) and forces \(S(t)\) to decay back to \(S_{base}\), visually demonstrating the AI taking control of the facility.

🚧 Challenges we ran into

The biggest hurdle was prompt engineering for the physics engine. If Gemini hallucinated a string instead of a float for a sensor value, the entire Chart.js rendering loop would crash. I had to iteratively refine the API payload to enforce a rigid schema, ensuring that the generative output was mathematically safe for the frontend to digest at 60 frames per second.

🏆 Accomplishments that we're proud of

I am incredibly proud of moving beyond the standard "wrapper" phase of Generative AI. AuraNode proves that LLMs can be used as deterministic logic engines to drive complex UI states and simulate real-world physics. The addition of the Auto-Remediation feature transformed the project from a passive viewing dashboard into a proactive, intelligent control system.

📚 What we learned

I learned how to seamlessly bridge server-side API generation with high-performance client-side rendering. I also discovered the immense power of defining strict JSON schemas for LLMs—it completely changes how you can use AI in software engineering, turning it from a text generator into an active configuration state machine.

🚀 What's next for AuraNode

The next step is to connect AuraNode to actual physical hardware. By replacing the stochastic simulation engine with an MQTT broker reading live ESP32 sensor data, AuraNode could instantly generate a beautiful, AI-monitored dashboard for a real physical room the moment the hardware boots up.

Built With

  • chart.js
  • css3-glassmorphism-deployment-&-devtools-git
  • dotenv
  • express.js
  • gemini-1.5-flash
  • github
  • google-gemini-api
  • html5
  • llm-driven-physics-backend-node.js
  • localtunnel-(or-ngrok)
  • npm
  • npx
  • rest-apis-frontend-javascript-(es6+)
  • structured-json-output
  • tailwind-css
Share this project:

Updates