🛡️ SupplyChain Guard AI: From Disruption to Decision in Under a Minute

Elevator Pitch: An autonomous enterprise cascade-loss simulator, 3D geographic threat radar, and costed rerouting engine built on NVIDIA Nemotron, hosted on Nebius Token Factory, and grounded by real-time web search.


💡 What Inspired Us

When a critical supply chain chokepoint breaks—whether it is a semiconductor foundry in Hsinchu or a maritime bottleneck in the Bab-el-Mandeb Strait—chief procurement officers and CFOs face a high-stakes race against time. They need immediate, actionable answers to two questions:

  1. What is our dollar-quantified financial exposure for every day of delay?
  2. What is the optimal mitigation route right now?

Traditional enterprise risk platforms rely on static databases and delayed reporting, leaving teams scrambling through spreadsheets while line-stoppage penalties accumulate. We built SupplyChain Guard AI to solve this exact problem: an autonomous, agentic system that continuously monitors live web intelligence, maps multi-tier supplier dependencies, and computes deterministic dollar trade-offs between waiting, sea rerouting, and air freight.


🏗️ How We Built It

We designed a dual-tier AI agent system that cleanly separates autonomous research, multi-tier cascade reasoning, and deterministic financial math.

                           [ Live Web Search (Tavily API) ]
                                          ▲
                                          │ (Iterative Queries)
[ Disruption Target ] ──► [ Nemotron-3 Nano Planner ] ──► [ Evidence Digest ]
                                                                  │
                                                                  ▼
[ Executive Deliverables ] ◄── [ Deterministic Python Engine ] ◄── [ Nemotron-3 Ultra Reasoner ]
  • 3D Pydeck Map                 (Financial Trade-Offs)           (Tier 1-3 Cascade Analysis)
  • C-Suite Brief (.txt)
  • JSON Risk Audit

1. Dual-Tier Inference on Nebius Token Factory

  • The Research Planner (nvidia/Nemotron-3-Nano-30B-A3B): Acts as an autonomous analyst. It formulates multi-query web searches, executes tool calls via the Tavily API, reviews incoming intelligence, and identifies information gaps to search again until it has sufficient evidence.
  • The Heavy Reasoner (nvidia/nemotron-3-ultra-550b-a55b): Takes the grounded web evidence and performs deep structural reasoning across Tier-1, Tier-2, and Tier-3 supplier networks, extracting risk levels, affected product lines, and alternative supplier candidates.

2. Deterministic Financial Engine (No LLM Hallucinations in Math)

Language models excel at unstructured reasoning, but struggle with consistent arithmetic. To eliminate hallucinated financial figures, the LLM only outputs structured node parameters, while a pure Python engine computes all cost trade-offs deterministically.

For a disruption duration of $d$ days with daily facility revenue at risk $R_{\text{daily}}$ and contractual SLA penalty $P_{\text{daily}}$:

$$\text{Daily Loss Rate } (\mathcal{L}{\text{daily}}) = R{\text{daily}} + P_{\text{daily}}$$

The total financial outcomes for each operational path are evaluated as:

$$\begin{aligned} \text{Do Nothing Loss } (\mathcal{C}{\text{wait}}) &= d \times \mathcal{L}{\text{daily}} \ \text{Sea Reroute Cost } (\mathcal{C}{\text{sea}}) &= F{\text{sea}} + \min(d, \tau_{\text{sea}}) \times \mathcal{L}{\text{daily}} \ \text{Air Reroute Cost } (\mathcal{C}{\text{air}}) &= F_{\text{air}} + \min(d, \tau_{\text{air}}) \times \mathcal{L}_{\text{daily}} \end{aligned}$$

Where $F_{\text{sea}}$ and $F_{\text{air}}$ represent freight costs, and $\tau_{\text{sea}}$ and $\tau_{\text{air}}$ represent the lead times (in days) to restore supply under each transport mode. The engine automatically selects the optimal strategy:

$$\text{Optimal Strategy} = \arg\min \left( \mathcal{C}{\text{wait}}, \mathcal{C}{\text{sea}}, \mathcal{C}_{\text{air}} \right)$$

3. Interactive Visualization & Delivery

  • 3D Pydeck Globe: Renders real-time arc overlays connecting bottleneck coordinates to alternative supplier locations.
  • Interactive Scenario Simulator: Allows users to slide disruption duration ($d$) and observe live financial exposure updates.
  • C-Suite Exporter: Generates structured .json audit logs and downloadable .txt executive briefings.

🛑 Challenges We Faced

  1. Preventing LLM Hallucinations in Financial Risk: Early prototypes relied on the LLM to calculate dollar losses directly, leading to variable arithmetic. Moving all financial computations to a deterministic Python layer ensured 100% mathematical precision while retaining the model's intelligence for evidence extraction.
  2. Schema Reliability Across Complex Tier Cascades: Multi-tier supply chains involve nested data structures. We implemented strict JSON schemas and retry validation to ensure that vendor comparison matrices and geographical coordinates remain well-formed under varying inputs.
  3. Optimizing Search Latency: Unstructured web searches can be slow. Implementing an agentic search pattern—where the Nano planner formulates targeted queries—drastically reduced overall run time while improving grounding accuracy.

📚 What We Learned

  • Right Model for the Right Task: Utilizing a fast model (Nemotron-3-Nano) for iterative tool calling alongside a heavy reasoner (Nemotron-3-Ultra) delivers optimal performance, balancing low latency with deep structural analysis.
  • Separation of Reasoning and Arithmetic: Combining non-deterministic generative models with deterministic execution engines is essential for decision-support applications in finance and logistics.
  • Grounding Builds Trust: Providing inline citations for every risk factor gives enterprise decision-makers confidence in AI-driven recommendations.

🛠️ Tech Stack Summary

  • AI & Inference: NVIDIA Nemotron-3 Ultra (550B) & Nemotron-3 Nano (30B) via Nebius Token Factory
  • Grounding & Web Search: Tavily Search API
  • Frontend & Visualization: Python, Streamlit, Pydeck 3D Maps, Pandas
  • Environment: Python 3.14 on Windows
  • License: Open Source under the MIT License

Built With

Share this project:

Updates

Submission history