AETHER-NIM

Inspiration

Network failures get diagnosed by staring at dashboards that show that something broke, and a meeting decides what to do next. We wanted the opposite: a twin that measures the blast radius spectrally, asks NVIDIA Nemotron for a diagnosis and ranked plan, executes with a deterministic optimizer, and independently verifies its own repair — rolling back anything that fails the gate. "Trust but verify" as software.

What it does

AETHER-NIM is a closed-loop digital twin for infrastructure networks:

• Measure — algebraic connectivity λ₂ (Jacobi eigensolver on the weighted Laplacian), connected components, capacity-aware min-cost-flow routing, served demand pairs, bottleneck detection.
• Detect — incident recognition from real measured deltas vs. the healthy baseline, not hints.
• Diagnose (AI) — the structured incident report goes to NVIDIA-Nemotron-3-Nano-30B-A3B on Nebius Token Factory; it returns root-cause hypotheses, ranked actions, risks and confidence as strict JSON.
• Plan — every AI proposal is re-validated against the live graph; a deterministic greedy optimizer minimizes the documented objective J (latency, unmet demand, fragmentation, λ₂ deficit, repair cost). AI seeds the plan; the engine owns the decision.
• Verify — a separate verifier module re-computes λ₂, components, routing and capacity after execution. Failure means rollback. The runtime header only turns green when verification passed.

Web-grounded diagnosis (Tavily + Nemotron)

At diagnosis time the twin also makes a functional runtime call to the Tavily Search API for live external context (recent fiber-cut/outage coverage, restoration best practice) and hands it to Nemotron next to the measured graph as web_evidence. The model may cite those source titles inside its root-cause hypotheses, but evidence can never override the engine measurements or invent actions - every proposal is still re-validated and re-measured by the deterministic verifier, and a Tavily outage degrades gracefully to measured-data-only.

How we built it

TypeScript end to end. A pure engine package (graph, metrics, recovery, AI adapter — zero IO, fully unit-tested), a Hono API shared by local runs and the serverless deployment, and a React + Cytoscape dashboard with rank overlays and plan/verify visualizations. The public deploy ships the engine inside the page bundle: each judge gets their own isolated twin, with a single stateless /api/ai proxy holding the Token Factory credential server-side. 20 vitest suites; an 18-case benchmark runner comparing self-healing vs. scripted baselines; an end-to-end real-AI integration check.

Challenges we ran into

• Making model output provably executable: the validator rejects invented ids, infeasible actions and out-of-band claims — the model ranks, it doesn't fantasize.
• "Verified" must mean something: verification thresholds are independent of plan quality, so a lucky plan can't fool the gate.
• Serverless constraints: no durable state — so we made the client own the whole engine and kept the proxy stateless.

Accomplishments that we're proud of

• Incident → verified recovery in ~6 wall-clock seconds on the live demo, with a real Token Factory call (not a mock), every action legal, and rollback armed.
• λ₂ turned out to be a sharp, cheap early-warning metric: it collapsed to 0 the instant a bridge edge failed — before any latency dashboard would flinch.

What we learned

• Spectral signals + capacity-aware flow give the model a truthful world to reason about — most of the quality comes from the measurement layer.
• Strict JSON contracts plus deterministic validation is a practical pattern for LLM-assisted operations tooling: the AI proposes, the engine disposes.

What's next for AETHER-NIM

Streaming telemetry scenarios, multi-graph federation, and a scheduler tick that runs the full detect-diagnose-verify loop continuously against injected chaos.

Built With

• cytoscape.js
• github
• hono
• nebius
• nemotron-3-30b
• node.js
• nvidia
• react
• tavily
• tokenfactory
• typescript
• vercel