AeroSage

Evidence-first AI that turns drone and machine telemetry into traceable incident investigations, powered by NVIDIA Nemotron on Nebius and grounded with Tavily.

Comment

AeroSage in 30 seconds

AI proposes. Telemetry decides.

AeroSage is an evidence-first AI incident investigator for drone and machine telemetry.

Instead of asking an LLM to guess what happened, AeroSage separates the workflow into three layers:

  1. Telemetry decides the facts — deterministic preprocessing identifies anomalies, incident rows and safety events.
  2. NVIDIA Nemotron proposes competing hypotheses through Nebius Token Factory.
  3. Evidence guardrails post-validate the AI output and reject or confidence-cap explanations that contradict the measured telemetry.

Tavily adds technical grounding from relevant external documentation.

The result is a traceable incident report where generative AI can reason — but cannot override the evidence.

Live demo: https://aerosage-ai.netlify.app
GitHub: https://github.com/jeelminproduction-netizen/aerosage-ai
60-second judge guide: https://github.com/jeelminproduction-netizen/aerosage-ai/blob/main/JUDGE_GUIDE.md

Inspiration

Machine failures leave evidence in telemetry, but turning raw logs into a defensible explanation is slow.

AeroSage was built to shorten that gap while keeping AI accountable to the underlying measurements.

The core question behind the project was simple:

Can generative AI help investigate an incident without being allowed to overrule the actual telemetry?

That question led to AeroSage's central principle:

AI proposes. Telemetry decides.

What it does

AeroSage ingests telemetry CSV files, profiles signals, detects statistical anomalies and safety events, reconstructs the incident sequence, and builds an evidence-first deterministic baseline.

NVIDIA Nemotron 3 Super then analyzes that structured evidence through Nebius Token Factory and ranks competing hypotheses.

Tavily provides technical grounding from relevant external documentation.

The key differentiator is AeroSage's evidence-guardrail layer.

LLM hypotheses are post-validated against the telemetry from the target incident before they can be promoted in the final report.

Unsupported explanations can be:

  • rejected entirely;
  • confidence-capped;
  • prevented from replacing stronger deterministic evidence.

The user can see these decisions directly in the interface.

How we built it

We built AeroSage with a lightweight static frontend using HTML, JavaScript and CSS, plus a Netlify Function backend for telemetry preprocessing and secure API calls.

The pipeline works in several stages.

1. Deterministic telemetry preprocessing

The backend parses the uploaded CSV, discovers numeric signals and profiles them without requiring a single fixed vendor schema.

AeroSage uses robust statistics such as median and MAD to identify numeric outliers.

Domain-specific rules then detect safety-relevant events including motor cut-outs, emergency states, battery conditions, radio conditions, GPS state, attitude events and magnetic events.

2. Evidence packet generation

Before any external AI call is made, AeroSage creates a compact structured evidence packet containing:

  • telemetry metrics;
  • anomalous signals;
  • incident rows;
  • safety-event evidence;
  • target-event measurements;
  • deterministic evidence guardrails.

This means the AI receives evidence that has already been organized around the incident.

3. NVIDIA Nemotron reasoning

The evidence packet is sent to NVIDIA Nemotron 3 Super 120B A12B through Nebius Token Factory.

Nemotron is used to:

  • propose competing failure hypotheses;
  • rank possible causes;
  • summarize the incident;
  • construct an incident timeline;
  • recommend next investigation steps.

4. Tavily technical grounding

Tavily is queried at runtime to retrieve relevant technical documentation related to the detected incident.

This gives the investigation an external technical grounding layer rather than relying only on model knowledge.

5. Evidence guardrails

Nemotron does not get the final word.

AeroSage compares the generated hypotheses against the actual target-event telemetry.

For example:

  • if magneto_episodes = 0, a magnetic disturbance cannot become the primary cause;
  • if angle_episodes = 0, an attitude explanation is rejected;
  • battery depletion confidence is capped when there is no low or critical battery event;
  • radio-link loss confidence is capped when signal strength does not cross the incident threshold;
  • GPS-loss confidence is capped when satellite counts remain healthy;
  • explicit motor cut-out evidence preserves propulsion-related severity.

The final ranked report is therefore a combination of generative reasoning and deterministic evidence validation.

Challenges we ran into

The biggest challenge was making generative reasoning reliable in a forensic workflow.

During development, Nemotron could sometimes produce a technically plausible explanation that conflicted with the telemetry.

One important example was a high-confidence magnetic-disturbance hypothesis despite the target incident rows showing:

magneto_episodes = 0

Instead of trying to solve this only through prompting, we changed the architecture.

The deterministic evidence packet is created first.

The AI then proposes hypotheses.

Finally, the guardrail layer decides what can actually be promoted.

This changed AeroSage from a system that simply generates explanations into a system that actively verifies them.

We also had to make external enrichment robust.

API responses can be slow, partial or unavailable, so AeroSage was designed so the deterministic baseline remains usable even if Nebius or Tavily enrichment fails during a request.

External AI improves the report, but it does not control whether the report exists.

Accomplishments that we're proud of

  • Integrated real NVIDIA Nemotron 3 Super inference through Nebius Token Factory end-to-end.
  • Integrated real Tavily runtime grounding end-to-end.
  • Built evidence guardrails that can visibly reject or confidence-cap unsupported AI hypotheses.
  • Added 17 reproducible automated tests against the same guardrail implementation used by the production backend.
  • Deployed a public working application.
  • Demonstrated the workflow using real sanitized drone telemetry rather than fabricated demo rows.
  • Designed the system so a valid deterministic incident report remains available even if external AI or web enrichment is temporarily unavailable.
  • Built the project around a clear separation of responsibilities between measurements, AI reasoning and evidence validation.

Evidence guardrail validation

The core AeroSage trust layer is backed by 17 automated tests that directly exercise the guardrail functions used by the production backend.

Current validation result:

17 tests
17 passed
0 failed

A representative adversarial case:

AI hypothesis: Magnetic disturbance — 88%
Telemetry: magneto_episodes = 0
AeroSage verdict: REJECTED

The validation suite also verifies that:

  • unsupported attitude hypotheses are rejected;
  • unsupported battery-depletion claims are capped;
  • unsupported radio-link-loss claims are capped;
  • unsupported GPS-loss claims are capped;
  • explicit propulsion evidence is restored if AI output contains only unsupported explanations;
  • AI output cannot downgrade a deterministic critical-risk classification;
  • valid magnetic, battery, radio or GPS evidence is not incorrectly blocked when telemetry actually supports it.

Full validation matrix:

https://github.com/jeelminproduction-netizen/aerosage-ai/blob/main/GUARDRAIL_VALIDATION.md

Why the architecture matters

Many AI investigation tools stop after generating a plausible explanation.

AeroSage deliberately separates three responsibilities:

Measurements  -> deterministic evidence
Nemotron      -> competing hypotheses
Guardrails    -> evidence-based accept / reject / cap

That separation is the core product idea.

Generative reasoning is useful, but measured telemetry remains authoritative.

What we learned

We learned that for safety-adjacent AI, better prompting is not enough.

A reliable system also needs:

  • deterministic preprocessing;
  • explicit uncertainty;
  • post-validation;
  • evidence-based confidence limits;
  • graceful fallback behavior.

We also learned that grounding and model reasoning are most useful when they augment structured evidence rather than replace it.

The most important lesson from AeroSage is that AI reliability can be improved at the application-architecture level, not only at the model or prompt level.

What's next for AeroSage

The next step is to expand AeroSage beyond the current drone-focused demo.

Planned directions include:

  • configurable telemetry adapters for PX4;
  • ArduPilot support;
  • ROS / ROS2 telemetry ingestion;
  • industrial machine telemetry;
  • time-series visualizations;
  • synchronized incident playback;
  • manufacturer-specific evidence rule packs;
  • multi-agent review for independent hypothesis generation and adjudication;
  • exportable forensic PDF reports;
  • broader benchmark datasets covering multiple incident classes.

The long-term goal is to make AeroSage a general evidence-first investigation layer for autonomous systems, robotics, vehicles and industrial machines.

Built With

Share this project:

Updates

Submission history