Aether

Autonomous self-healing SRE control plane powered by Gemini 3.6 Flash & Cloud Run, featuring zero-trust AppSec governance and isolated canary verification.

Comment

Here is your complete, publication-ready Project Story ("About the project") formatted in Markdown with LaTeX support, ready to copy and paste directly into your Devpost submission:

🛡️ AETHER: Autonomous Self-Healing SRE Control Plane

Track: The Fortified Enterprise Fleet
Live Production Dashboard: https://aether-target-app-101289885622.us-central1.run.app
Autonomous Worker Service: https://aether-worker-101289885622.us-central1.run.app

💡 Inspiration: Eliminating 3 AM On-Call Toil

In modern microservice architectures, silent performance degradation, unhandled exceptions, and latency regressions cost enterprises millions of dollars per minute of downtime. Traditional Site Reliability Engineering (SRE) relies heavily on manual human triage:

  1. An alert fires at 3 AM.
  2. An on-call engineer wakes up, reads distributed traces, and attempts to isolate the faulty code path.
  3. A fix is manually written, reviewed, tested, and deployed through CI/CD pipelines.
  4. Mean Time to Resolution (MTTR) averages $45\text{ to }90\text{ minutes}$.

We asked ourselves: What if a cloud fleet could heal itself autonomously, safely, and deterministically within seconds?

We built AETHER—a headless, autonomous SRE control plane that closes the loop between Observability, Root-Cause Diagnosis, Adversarial Security Governance, Isolated Sandbox Compilation, Canary Probing, and Production Promotion without human intervention.

🧠 What AETHER Does

AETHER continuously observes live production telemetry. When an SLO threshold is breached—such as latency exceeding $P_{95} > 150\text{ ms}$ or error rate surpassing $E > 1.0\%$—AETHER executes a fully autonomous 12-Stage Remediation Lifecycle:

$$\text{SLO Breach} \xrightarrow{\text{Telemetry}} \text{Incident} \xrightarrow{\text{Gemini 3.6}} \text{AST Patch} \xrightarrow{\text{AppSec Gate}} \text{Sandbox Build} \xrightarrow{\text{Canary Probes}} \text{Promotion}$$

The 12-Stage Closed Loop:

  1. FAILURE_DETECTED: Continuous rolling circular buffer detects anomalous latency or error rate spikes.
  2. INCIDENT_CREATED: A cryptographically signed SEV-1 incident envelope is opened.
  3. WORKER_ASSIGNED: Autonomous daemon thread claims the incident lease.
  4. AI_INVESTIGATION: Gemini 3.6 Flash analyzes runtime stack traces, Git history, and microservice AST source code.
  5. DIAGNOSIS_COMPLETE: Pinpoints exact root cause (e.g., blocking database loops, uncaught exceptions).
  6. CANDIDATE_FIX_GENERATED: Synthesizes a unified diff candidate patch targeted to the source file.
  7. SECURITY_PERF_REVIEW: Zero-trust AppSec Governor (CWE-94, CWE-89 scanning) and Performance Governor review and approve the candidate diff.
  8. SANDBOX_BUILD: A temporary isolated sandbox executes a strict 16-Gate Validation Suite (including tsc --noEmit, AST linting, and Vite bundling).
  9. CANARY_DEPLOYED: Deploys an isolated canary instance on ephemeral port 8081.
  10. HEALTH_VERIFICATION: Orchestrates 10 real HTTP synthetic traffic probes against the canary.
  11. PROMOTION_TO_PRODUCTION: Atomically promotes the verified candidate to version v1.0.1.
  12. COMPLETED: Resolves incident, updates telemetry baseline, and returns to IDLE_MONITORING.

🛠️ How We Built It

AETHER is built native to the Google Cloud and Gemini Agent Ecosystem:

 ┌────────────────────────────────────────────────────────┐
 │            AETHER CONTROL PLANE ARCHITECTURE           │
 └────────────────────────────────────────────────────────┘
                       │
       ┌───────────────┴───────────────┐
       ▼                               ▼
 ┌───────────────┐               ┌───────────────┐
 │ Google Cloud  │               │ Gemini 3.6    │
 │ Run Services  │               │ Flash Engine  │
 └───────┬───────┘               └───────┬───────┘
         │                               │
         ▼                               ▼
 ┌───────────────┐               ┌───────────────┐
 │ 16-Gate Temp  │               │ Zero-Trust    │
 │ Sandbox Build │               │ AppSec Filter │
 └───────┬───────┘               └───────┬───────┘
         │                               │
         └───────────────┬───────────────┘
                         ▼
             ┌───────────────────────┐
             │ Isolated Canary 8081  │
             │ Real Traffic Probes   │
             └───────────┬───────────┘
                         ▼
             ┌───────────────────────┐
             │ Production v1.0.1     │
             │ Zero-Downtime Traffic │
             └───────────────────────┘
  • AI Reasoning Core: Gemini 3.6 Flash (gemini-3.6-flash) via the official @google/genai SDK for ultra-fast, highly accurate code investigation and AST patch synthesis.
  • Compute Infrastructure: Containerized fleet deployed on Google Cloud Run in us-central1, with auto-scaling container revisions.
  • Container Registry: Google Artifact Registry (us-central1-docker.pkg.dev/aether-506214/aether-repo).
  • Persistence & Observability Tier: Persistent SQLite in WAL mode with WASM SQL Studio and real-time Server-Sent Events (SSE) telemetry.
  • Frontend Control Dashboard: Dark glassmorphic React 18 interface with syntax-highlighted Candidate Patch Diff Inspector, interactive OpenAPI 3.1 Contract Explorer, and Live Infrastructure Topology.

⚡ Mathematical Safety Envelope & SLO Formula

AETHER calculates real-time SLO health utilizing circular buffer quantile estimations:

$$P_{95} = \text{Percentile}\left({L_1, L_2, \dots, L_N}, 0.95\right) \le 150\text{ ms}$$

$$\text{Error Rate } E = \left( \frac{\sum_{i=1}^N \mathbf{1}_{[\text{HTTP } \ge 500]}}{N} \right) \times 100\% \le 1.0\%$$

If $P_{95} > 150\text{ ms}$ or $E > 1.0\%$, the autonomous state machine triggers deterministic remediation within $\Delta t < 2.0\text{ seconds}$.

🥊 Challenges We Overcame

  1. Deterministic Execution vs. LLM Non-Determinism:
    Allowing an AI model to write code directly to production is a severe security vulnerability. We engineered a Zero-Trust Safety Envelope: Gemini 3.6 Flash cannot execute shell commands directly. Instead, its patches must pass through an AppSec Governor, a 16-Gate isolated sandbox compilation test (npm run build, type-checking, AST sanity checks), and a real 10-probe HTTP canary before any traffic is routed.
  2. Real Physical Execution Paths:
    Unlike mock simulations, AETHER's target application executes actual Node.js HTTP payment pipelines and SQLite ledger writes. The faults injected are real blocking delays and exceptions, proving true self-healing under production workloads.
  3. Sub-90-Second MTTR on Cloud Run:
    Optimizing container image layers, sandbox compilation caching, and Gemini prompt structured schemas enabled the entire 12-stage cycle to complete in under 75 seconds.

🎓 What We Learned

  • Gemini 3.6 Flash is Exceptionally Fast for AST Code Reasoning: The reasoning speed of Gemini 3.6 Flash allowed us to generate pinpoint diffs without latency bottlenecks.
  • Autonomous SRE Requires Strict Governance: Bounded agent execution with deterministic gatekeeping creates the trust required for enterprise cloud adoption.

🚀 What's Next for AETHER

  • Kubernetes Multi-Cluster Operator: Deploying AETHER as a native K8s Custom Resource Definition (CRD) controller.
  • Predictive Anomaly Pre-Healing: Using Gemini time-series analysis to patch memory leaks before an SLO is breached.
  • Multi-Agent Consensus Councils: Orchestrating competing agent proposals (e.g., Performance Agent vs. Cost Optimization Agent) for complex enterprise refactors.

Built With

Share this project:

Updates