EcoCompute AI

Let's Code Green

Comment

Inspiration The Problem: Training a single AI model emits as much carbon as 5 cars over their lifetime—but for enterprises, the real pain is Cloud Bill Shock. Monitoring tools like Datadog see the symptoms (high CPU); we see the root cause (inefficient code). We asked: What if we could place a "Virtual Senior Performance Engineer" inside the CI/CD pipeline? One that not only blocks expensive code but also explains the ROI to the CFO? Enter EcoCompute V38. We moved beyond a simple linter to build a complete Green FinOps Infrastructure powered by Gemini 3. What it does EcoCompute AI is a Predictive Gatekeeper for AI Engineering. Intercepts: It acts as a GitHub Action / CI Gate, scanning PyTorch PRs (supporting everything from ResNet-50 to Llama 3). Grounds: It searches Google for real-time 2026 hardware specs (e.g., NVIDIA B200) to calculate precise Cloud Cost impacts. Calibrates: It uses a "Scientific Calibration" method—first verifying its physics engine against known baselines (MLPerf) before analyzing novel architectures. Verifies: It uses a Python Sandbox to mathematically prove "Arithmetic Intensity" (FLOPs/Byte), eliminating LLM math hallucinations. Refactors: It automatically generates optimized code (Quantization, Operator Fusion) to cut inference costs by 30-50%. Consults (New V38 Pilot): An interactive Wisdom Pilot that translates technical metrics into financial strategy, helping VPs and CFOs understand why an optimization matters. How we built it (The V38 Hybrid Engine) We de-risked AI optimization by combining Neuro-symbolic Verification with a Tiered Cost Architecture: The V38 Tiered Architecture (L1/L2/L3): To ensure positive unit economics, we built a smart router: L1 (Static Gate): Instant Regex/AST checks ($0 cost). L2 (Flash Router): Gemini Flash-Lite handles documentation & simple fixes ($0.001 cost). L3 (Deep Reasoning): Gemini 3 Pro is reserved for complex architectural changes, utilizing its 1024-token thinkingBudget to plan audits and verify math. Scientific Calibration Strategy: To address the critique that "LLMs don't know physics," we implemented a calibration loop. The agent grounds itself on public MLPerf data (ResNet-50) to determine error margins before predicting the energy usage of complex custom models. Agentic Tool Use: Google Search: Used to find dynamic data like "Carbon Intensity of Iowa Data Centers" or "H100 On-demand Pricing". Code Execution: Used to calculate FLOPs. We force the agent to write Python code to verify its own assumptions. Challenges we ran into Hallucination vs. Physics: LLMs are notoriously bad at arithmetic. We solved this by forcing Gemini 3 to use the Code Execution sandbox for all FLOPs/Byte calculations, effectively giving the LLM a calculator. Balancing Token Costs: Running a large reasoner model on every line of code is expensive. The V38 Architecture solves this by routing 80% of traffic to cheaper layers (Static/Flash), saving the heavy lifting for Gemini 3 Pro. Visualizing "Thinking": Streaming the raw "thought process" (e.g., "Checking MLPerf DB...") to the UI without breaking the JSON output required a custom stream parser. Accomplishments that we're proud of Scientific Rigor: We don't just guess; we provide Error Bars and Confidence Scores based on real MLPerf data. Measurable Impact: In our demo, we achieved 32.8% energy reduction on Llama 3 GQA blocks, translating to $12.50 saved per 1M inferences on NVIDIA H100. The "Dual-Persona" Interface: We built a tool that speaks Code to engineers (via PR Comments) and Money to executives (via the V38 Pilot), bridging the gap between DevOps and FinOps. What's next for EcoCompute AI Dynamic Tracing: Integrating torch.fx to capture complex dynamic graphs beyond static analysis. Enterprise Pilot: Onboarding 3-5 design partners from FinTech and Autonomous Driving sectors. IDE Plugin: Bringing the "Green Gatekeeper" directly into VS Code for real-time energy linting. Let's Code Green & Lean!

Built With

  • apis
  • gemini3
Share this project:

Updates

posted an update —

Technical Deep Dive: The "Hybrid Grounding" Architecture Unlike standard RAG apps, EcoCompute AI uses a Hybrid Grounding approach to ensure physics-compliant energy auditing.

  1. The "See-Search-Solve" Loop

See (Deterministic): We built a custom client-side Heuristic Scanner (TypeScript) that instantly maps code topology (ResNet blocks, Attention layers) using regex patterns. This gives Gemini "ground truth" context before it even starts thinking. Search (Dynamic): The agent uses Google Search to fetch real-time 2026 hardware specs (e.g., NVIDIA B200 TDP, Cloud Pricing). It doesn't hallucinate specs; it looks them up. Solve (Verifiable): We force the model to use a Python Sandbox for all FLOPs/Byte math.

  1. Taming Gemini 3 Pro We heavily customized the google/genai config to behave like a Senior Engineer:

Thinking Budget (1024 Tokens): Allocated specifically for the agent to plan its audit strategy and self-correct physics errors. Self-Correction Protocol: If the Python sandbox throws a ValueError (e.g., precision mismatch), the agent catches it, rewrites the code, and retries automatically.

  1. Infrastructure-First Design

CI/CD Simulator: We built a visual simulator to demonstrate how this acts as a "Blocking Gate" in GitHub Actions. Calibration Engine: The system is designed to ingest .nsys profiling logs to calibrate its energy model against ground truth.

Log in or sign up for Devpost to join the conversation.

posted an update —

Technical Deep Dive: The "Hybrid Grounding" Architecture Unlike standard RAG apps, EcoCompute AI uses a Hybrid Grounding approach to ensure physics-compliant energy auditing.

  1. The "See-Search-Solve" Loop

See (Deterministic): We built a custom client-side Heuristic Scanner (TypeScript) that instantly maps code topology (ResNet blocks, Attention layers) using regex patterns. This gives Gemini "ground truth" context before it even starts thinking. Search (Dynamic): The agent uses Google Search to fetch real-time 2026 hardware specs (e.g., NVIDIA B200 TDP, Cloud Pricing). It doesn't hallucinate specs; it looks them up. Solve (Verifiable): We force the model to use a Python Sandbox for all FLOPs/Byte math.

  1. Taming Gemini 3 Pro We heavily customized the google/genai config to behave like a Senior Engineer:

Thinking Budget (1024 Tokens): Allocated specifically for the agent to plan its audit strategy and self-correct physics errors. Self-Correction Protocol: If the Python sandbox throws a ValueError (e.g., precision mismatch), the agent catches it, rewrites the code, and retries automatically.

  1. Infrastructure-First Design

CI/CD Simulator: We built a visual simulator to demonstrate how this acts as a "Blocking Gate" in GitHub Actions. Calibration Engine: The system is designed to ingest .nsys profiling logs to calibrate its energy model against ground truth.

Log in or sign up for Devpost to join the conversation.

posted an update —

Title: Building a "Green FinOps" Gatekeeper with Gemini 3

The Spark We often talk about AI's potential to solve climate change, but we rarely talk about the climate cost of AI itself. I was shocked to learn that training a single large language model can emit as much carbon as five cars over their entire lifetimes. As developers, we want to build powerful models, but we lack the tools to see the invisible energy cost of our code. I realized that if we want "Green AI" to be more than a buzzword, we need to make energy auditing as automatic as linting. That’s why I built EcoCompute AI.

What it does EcoCompute AI is an intelligent infrastructure agent—a virtual "Senior Performance Engineer"—that lives in your CI/CD pipeline. It doesn't just estimate carbon; it actively optimizes your code.

See: It scans PyTorch code and even hand-drawn architecture sketches. Search: It uses Google Search to find real-time 2026 hardware specs (e.g., NVIDIA B200 TDP) and MLPerf benchmarks, ensuring the data is never stale. Solve: It uses a Python sandbox to mathematically verify bottlenecks (like Arithmetic Intensity) and automatically refactors code to reduce energy consumption by 30-50%. How I built it ⚙️ The core is built on the Gemini 3 Pro model using the google/genai SDK. I implemented a "Hybrid Grounding" architecture:

Deep Reasoning: I allocated a thinkingBudget of 1024 tokens. This allows the agent to plan its audit strategy and "think" through complex physics calculations before generating a response. Tool Use: I integrated the googleSearch tool for live grounding and a custom codeExecution tool. The agent writes Python scripts to calculate FLOPs/Byte ratios, ensuring the math is accurate and not hallucinated. Self-Correction: I built a robust error-handling loop. If the Python sandbox throws an error (e.g., a precision mismatch), Gemini 3 catches it, analyzes the traceback, adjusts its assumptions (e.g., switching from FP32 to FP16), and retries automatically. Challenges I ran into The biggest challenge was the "Hallucination vs. Physics" problem. Early versions of the agent would confidently invent hardware specs or get the math wrong. I solved this by implementing Strict Tool Enforcement: forcing the model to cite sources for every number and use the sandbox for every calculation. If it can't prove it with code or a citation, it doesn't say it.

Accomplishments that I'm proud of

The "Cinematic" Demo Flow: I created a simulation engine that visualizes the agent's thought process—from searching Google to fixing its own code errors—making the "black box" transparent to the user. Infrastructure-First Design: Following the "Cal.com model," I made the reports embeddable. You can drop a live energy audit widget directly into a HuggingFace Model Card or internal documentation. What I learned Working with Gemini 3 taught me that Agentic workflows > RAG. For technical domains, giving the model tools to discover truth is far more powerful than just feeding it static documents. I also learned that "sustainability" is really a data problem—once developers see the "Carbon Debt" in their PRs, they naturally want to fix it.

What's next for EcoCompute AI I plan to implement a true backend parser for .nsys profiling logs to replace the current simulation, making the calibration engine enterprise-ready. I’m also looking to integrate it directly as a GitHub Action for automated PR reviews.

Log in or sign up for Devpost to join the conversation.

posted an update —

Update: The "Agentic" Engine is Live! (Gemini 3 Integrated) We've just pushed a massive update to EcoCompute AI, and the results are electrifying!

What's New in v2.0? We have moved beyond simple static analysis. The core engine is now fully powered by the Gemini 3 Agentic Stack:

Deep Thinking Budget: We've allocated a 2048-token budget for the model to "reason" before answering. Watch the "Thinking Panel" to see it debate the trade-offs between int8 quantization and accuracy loss in real-time! Real-Time Grounding: The Agent now uses Google Search to fetch 2026-era hardware specs (like NVIDIA B200 TDP) instead of relying on outdated training data. Code Execution Sandbox: No more hallucinations! The Agent writes and executes Python scripts to mathematically verify Arithmetic Intensity (FLOPs/Byte) before making recommendations. Visual Upgrade: Check out our new "Decision Triangle" visualization (see screenshots). It forces you to balance Performance, Cost, and Carbon—because the fastest model isn't always the best one for the planet.

Try it out: Paste your PyTorch code snippet and click "Deep Energy Audit". Let Gemini be your virtual Performance Engineer!

Let's Code Green!

Log in or sign up for Devpost to join the conversation.