Aeon Core: Autonomous Closed-Loop SRE Remediation Engine

An autonomous, closed-loop Site Reliability Engineering engine that shifts enterprise operations from passive monitoring to true, self-healing automation using Gemini and the Model Context Protocol.

Comment

💡 Inspiration

Modern enterprise system operators face severe alert fatigue across disconnected infrastructure monitors. When production environments face critical resource exhaustion, human engineers must manually log in via SSH, correlate telemetry data, find rogue PIDs, and execute recovery commands.

We asked a core question: What if an AI agent operated as a unified, autonomous Site Reliability Engineer—ingesting real-time host telemetry, managing its own operational state memory, and executing precise, type-safe infrastructure remediations without human latency or intervention?

⚙️ What it does

AEON Core is an autonomous, closed-loop Site Reliability Engineering (SRE) incident triage and mitigation engine:

  • Real-Time Observability Streaming: Continuous infrastructure health and host metrics (CPU, Memory) are streamed from the target host (aeon-nexus) straight to our control plane using a high-frequency Socket.IO telemetry pipeline.
  • Cognitive Ingestion: When workload anomalies breach safety thresholds (such as an intense, flatlined 100% CPU spike), the embedded AEON Copilot processes the failure state using the advanced reasoning capabilities of Gemini 2.5 Flash.
  • Model Context Protocol (MCP) Actions: Instead of relying on static scripts, the agent utilizes a dynamic Model Context Protocol (McpToolset) server layer to translate linguistic intent into safe, structured system execution commands.
  • Closed-Loop Remediation: The agent directly isolates and terminates the resource-hogging process, dropping system utilization from a crippled 100% flatline back down to a stabilized 14.2% baseline in seconds—fully visible via the live dashboard graph.
  • State & Audit Management: Every incident lifecycle phase, system state change, and remediation audit log is recorded into a persistent MongoDB backend tier to ensure absolute traceability.

🛠️ How we built it

  • The Brain: Google Agent Development Kit (ADK) running an optimized Python framework powered by the Gemini 2.5 Flash model.
  • The Interconnect: The Model Context Protocol (MCP) acting as the architectural bridge, exposing type-safe system tool definitions directly to the model's reasoning loop.
  • The Control Plane: A custom-engineered Operational Control Plane dashboard featuring real-time charting, persistent incident ticketing feeds, and live Socket.IO data transport layers.
  • The Memory: A scalable MongoDB database layout serving as our persistent ledger for state tracking and event tracking.
  • The Repository Architecture: Vertically integrated project layout hosted securely on GitLab under our dedicated hackathon codebase.

🚧 Challenges we ran into

  • Type-Safe MCP Tool Serialization: Mapping infrastructure state to runtime boundaries presented strict serialization challenges. Getting Gemini to reliably construct arguments for our McpToolset endpoint without parsing failures required meticulous schema engineering, explicit type hints, and deep validation constraints within our custom agent definitions.
  • High-Frequency Telemetry Data Synchronization: Managing continuous live updates over Socket.IO without causing chart-rendering lag or database write bottlenecks required careful handling. We engineered atomic document updates using specific database modifiers ($set) to keep our MongoDB layer highly responsive while telemetry lines spiked and dropped.
  • Development Environment Framework Handshakes: Orchestrating our backend API layers through the native adk web engine required configuring clean cross-origin permissions and port bindings (--port 8000) so our local control plane could effortlessly signal the agent execution matrix without throwing network drops.

🏆 Accomplishments that we're proud of

We successfully moved past standard conversational AI wrappers to build a true, action-oriented automation platform. By unifying the Google Agent Development Kit, Model Context Protocol, and real-time frontend streaming, we engineered a fully functional, self-healing SRE loop capable of taking a server from total CPU exhaustion to full stability completely autonomously.

💡 What we learned

  • Agents Require Deterministic Actions: Relying on language models for loose text generation is dangerous in production environments. Using the Model Context Protocol taught us how defining strict, type-safe schemas guarantees that an agent remains within bounded, predictable operational lanes.
  • State Management Prevents System Chaos: An autonomous agent executing infrastructure alterations without a persistent state machine is a hazard. Using MongoDB as an immutable ledger proved crucial for grounding the agent's memory and ensuring clear audit tracking.
  • Unified Tooling Optimizes LLM Reasoning: Structuring host metadata into predictable JSON schemas vastly reduces model token overhead and dramatically accelerates the speed at which Gemini can select and trigger corrective tooling.

🔮 What's next for AEON Core

  • Predictive Proactive Healing: Transitioning from reactive remediation to preventative maintenance by building forecasting layers that catch resource exhaustion patterns before they flatline a system node.
  • Multi-Agent Consensus Matrix: Developing a secondary "Validator Agent" schema to cross-examine and authorize high-privilege tool execution payloads before applying production-level changes.
  • Multi-Host Orchestration Scale: Expanding the control plane architecture to safely register, monitor, and manage thousands of federated server nodes across hybrid-cloud footprints.

Built With

Share this project:

Updates