Nexus Grid

Here is the updated Devpost Project Story, entirely rewritten to match the latest Series-A level README.md in your repository. It specifically highlights the Multi-Agent Transformer (MAT), QMIX, PyTorch, and the Live Render Deployment.

Copy and paste this directly into Devpost:

## Inspiration
Modern energy grids are decaying under the weight of their own complexity. As we transition to Distributed Energy Resources (DERs) like solar and EVs, our energy supply has become volatile, decentralized, and entirely unpredictable. 

Through our research, we realized that current industry tools fail catastrophically because they rely on **human-authored static heuristics** ("if-this-then-that") or **pre-trained machine learning models**. The moment an unexpected weather anomaly hits, pre-trained models suffer catastrophic data drift and fail. The grid is no longer a predictable top-down utility; it is an infinitely complex, non-stationary mathematical graph. We were inspired to build the dynamic intelligence needed to autonomously orchestrate it using state-of-the-art transformer architectures.

## What it does
**NEXUS GRID** is a groundbreaking, mathematically advanced digital twin and autonomous control operating system. It is fully live and deployed on Render.

Instead of building just another dashboard, we built an autonomous mathematical brain. You provide the coordinates, and Nexus Grid instantly translates any district (like Ghaziabad, New York, or Boston) into an executable digital twin. It injects live macro-grid telemetry (carbon intensity, market pricing, solar forecasts) and unleashes a swarm of **Multi-Agent Transformers (MAT)** with **QMIX** value decomposition to balance the grid in real-time. 

Through our **Intelligence Terminal**, operators can watch agents perform **Live Peer-to-Peer (P2P) energy settlements**, shifting power between commercial and residential nodes to negate carbon. Operators can even use our **Chaos Engineering** module to inject simulated feeder faults, watching the AI self-heal the district in milliseconds with zero downtime.

## How we built it
We architected Nexus Grid as a high-performance decoupled monolith:
*   **The Physics & Topology Engine:** Built on **FastAPI and NetworkX**, this engine maps physical constraints, ampacity limits, and live data via WebSockets.
*   **The Command Layer:** A Series-A grade **Next.js 14** spatial interface utilizing **Framer Motion** and **TailwindCSS** for real-time observability.
*   **The Autonomy Engine:** This is our core DeepTech differentiator. We model the district as a **Decentralized Partially Observable MDP (Dec-POMDP)** over a dynamic graph $G_t(V, E)$. 

Using **PyTorch**, we built a policy architecture relying on **Multi-Agent Transformers (MAT)** where each DER node acts as a token. Self-attention learns inter-agent dependencies, while **QMIX** ensures decentralized execution with global optimality guarantees. Most importantly, it is **completely zero-shot (NOT pre-trained).** 

Mathematically, the control objective is a constrained cooperative optimization:
$$ \pi(\mathbf{a} | \mathbf{o}, G_t) = \arg\max_{\pi} \; \mathbb{E}\left[\sum_t R_t\right] $$

Our non-linear reward formulation enforces strict grid physics:
$$ R_t = \alpha \cdot \Delta E_{green} - \beta \cdot \mathcal{L}(C_{grid}^{(t)}) - \lambda \cdot \sum \max\left(0, \frac{|I_e|}{I_{max}} - 1\right)^2 $$
This asymptotic penalty ensures agents structurally cannot violate physical grid constraints, forcing them to find mathematically optimal dispatch strategies.

## Challenges we ran into
Abstracting extreme mathematics into a real-time web application is incredibly difficult. 
1.  **Bridging the Physics-UI Gap:** We had to ensure that the heavy PyTorch matrix operations calculating load-flow in the backend synced perfectly via WebSockets to the React frontend without frame dropping.
2.  **Adaptive Multi-Agent Control:** Implementing MAT sequence coordination alongside QMIX monotonic value block on a dynamic graph meant ensuring our local agent utilities successfully composed into a globally aligned dispatch objective without breaking local autonomy. 
3.  **Live Deployment on Render:** Scaling the WebSocket infrastructure and containerizing the PyTorch backend to run efficiently in the cloud.

## Accomplishments that we're proud of
1.  **Zero-Shot Generalization:** Attaining true zero-shot generalization to unseen grid configurations. Seeing our untrained MAT agents successfully adapt to a manually injected "Emergency Feeder Fault" to reroute power and stabilize the district in real-time.
2.  **The Premium Command Center:** We built an unapologetically premium Command Center that spatializes the math perfectly, including a live "AI Rationale Feed" for deep explainability.
3.  **Full Cloud Deployment:** Reaching a 100% production-ready deployment with our frontend and backend actively humming on Render.

## What we learned
We learned that attempting to apply standard generative AI or pre-trained ML to physical infrastructure is disastrous. Physical systems are governed by strict thermodynamic laws. Autonomous infrastructure requires continuous, zero-shot reinforcement learning wrapped in transformer architectures that respects boundary physics over historical datasets.

## What's next for NEXUS GRID
NEXUS GRID was explicitly architected to dominate AlgoFest 2026, but the protocol has limitless scaling potential. Our next immediate steps are:
*   Integrating blockchain execution for live financial settlement of the P2P energy trades.
*   Scaling the topological generator from city districts to inter-state grid transmission lines.
*   Integrating live API hooks for V2G (Vehicle-to-Grid) bidirectional charging fleets.

Built With

• asyncio
• electricity-maps-api
• epex
• fastapi
• framer-motion
• multi-agent-transformers-(mat)
• networkx
• next.js
• python
• pytorch
• qmix
• react
• recharts
• reinforcement-learning
• render
• spot
• tailwind-css
• typescript
• uvicorn
• websockets