SentryMesh AI

Autonomous multi-agent incident response and self-healing engine powered by NVIDIA Nemotron models for real-time telemetry triage and automated code patching.

Comment

Inspiration

Modern microservice architectures generate massive volumes of logs, telemetry dumps, and stack traces during system outages. On-call engineers often spend critical hours sifting through stack traces and isolating broken dependencies.

We created SentryMesh AI to transform incident management from reactive manual troubleshooting into an autonomous, self-healing pipeline. By decoupling emergency response into tiered AI agents, SentryMesh AI compresses incident triage, root-cause analysis, and code patch generation down to seconds.

What it does

SentryMesh AI is an autonomous multi-agent incident response engine. When a service fails or fires high-severity exceptions, SentryMesh AI executes an automated two-stage remediation workflow:

Fast-Path Triage: Evaluates high-throughput log streams and stack traces to produce structured anomaly signatures, affected service components, and confidence metrics.

Deep Remediation & Patching: Takes the triage diagnostic to perform architectural root-cause analysis, generate explicit code patches (git diffs), outline verification commands, and provide automated rollback instructions.

Interactive Command Center: Provides site reliability engineers (SREs) with a real-time Streamlit dashboard to monitor active telemetry, review AI-generated code fixes, and trigger automated deployment pipelines.

How we built it

SentryMesh AI relies on a tiered multi-agent architecture optimized for speed and reasoning depth using NVIDIA open-source models on Nebius Token Factory:

Triage Agent: Powered by NVIDIA Nemotron-3 Nano via Nebius Token Factory for fast, high-concurrency log evaluation and JSON key-value extraction.

Remediation Agent: Powered by NVIDIA Nemotron-3 Ultra via Nebius Token Factory to perform complex architectural reasoning and syntactically valid code patch synthesis.

Backend Microservice: Built using FastAPI and Pydantic for structured data validation, asynchronous processing, and API routing.

User Interface: Developed with Streamlit for real-time telemetry monitoring, manual incident simulation, and interactive patch review.

Container Orchestration: Fully containerized using Docker and Docker Compose for seamless local execution and cloud deployment.

Challenges we ran into

Model Tiering & Routing: Balancing real-time operational response with deep code generation required structuring strict JSON schemas across both Nemotron-3 Nano and Ultra tiers.

Local Development & Deployment: Resolving local environment and regional billing constraints by architecting Docker-based containerization and seamless fallback mechanisms so the core stack operates reliably in any environment.

Accomplishments that we're proud of

Successfully decoupled incident response into specialized, cooperative AI agents using NVIDIA Nemotron models.

Achieved an end-to-end incident resolution time of under 3 seconds from log ingestion to verified code patch.

Built a production-grade, containerized microservice repository complete with full Docker Compose orchestration and an interactive command dashboard.

What we learned

How to leverage tiered LLM routing (using lightweight models for rapid categorization and massive reasoning models for code patching) to optimize both response latency and computational resources on Nebius infrastructure.

Structuring robust Pydantic schemas and JSON response enforcement for autonomous multi-agent pipelines.

What's next for SentryMesh AI

Automated Git PR Generation: Integrating GitHub/GitLab webhook triggers to automatically open Pull Requests containing Nemotron-generated patches.

Kubernetes Operator: Building a custom K8s controller that automatically deploys and verifies patches in isolated staging pods before merging to production.

Long-Term Telemetry Memory: Implementing vector search on historical incident resolutions to enable continuous organizational learning.

Built With

  • ai-agents
  • docker
  • docker-compose
  • fastapi
  • nebius
  • nemotron
  • nvidia
  • openai-api
  • pydantic
  • python
  • rest-api
  • streamlit
Share this project:

Updates

posted an update —

SentryMesh AI Update: Autonomous Incident Response Engine is Live!

We have reached a major project milestone for SentryMesh AI as we finalize our submission for the Nebius x NVIDIA Global AI Hackathon! SentryMesh AI is an autonomous, multi-agent incident response and code self-healing engine designed to handle the entire lifecycle of cloud infrastructure failures.

Here is a look at what we've built, how the engine evolved, and what powers it under the hood:

How SentryMesh AI Works Instead of relying on human on-call engineers to manually comb through log dumps during an outage, SentryMesh AI orchestrates a two-stage agentic workflow:

Stage 1: Autonomous Triage (NVIDIA Nemotron-3 Nano) When telemetry spikes or error logs are ingested, the Triage Agent parses the high-throughput stack traces in real time to isolate anomaly signatures and rate incident severity.

Stage 2: Code Self-Healing & Remediation (NVIDIA Nemotron-3 Ultra) The Remediation Agent evaluates system context from Stage 1, performs root-cause analysis, and synthesizes production-ready code patches along with a verification test suite.

Key Technical Features & Deployment Updates FastAPI Asynchronous Core Engine: Engineered high-throughput REST endpoints (server/main.py) to manage asynchronous agent handoffs and structured JSON state streams.

Streamlit Mission Control UI: Built an interactive operational dashboard featuring live log stream simulations, target microservice selectors (e.g., payment-processor), real-time agent output visualizations, and manual patch overrides.

Nebius Token Factory Integration: Powered entirely by NVIDIA Nemotron-3 models hosted on Nebius Token Factory for ultra-low latency inference and structured schema adherence.

Open Source Compliance: Licensed under Apache 2.0 with full setup instructions, Docker support, and containerized runtime definitions.

Code Architecture Highlight: Two-Stage Agent Handoff Here is a snippet showing how our FastAPI engine routes telemetry from Nemotron-3 Nano (Triage) directly into Nemotron-3 Ultra (Remediation):
@app.post("/api/v1/incident/dispatch") async def dispatch_sentrymesh_agents(telemetry: TelemetryPayload): # Stage 1: Rapid Anomaly Triage via Nemotron-3 Nano triage_result = await triage_agent.analyze( model="nvidia/nemotron-3-nano", logs=telemetry.raw_logs, service=telemetry.service_name )

# Stage 2: Deep Context Remediation & Patch Generation via Nemotron-3 Ultra
remediation_patch = await remediation_agent.synthesize_patch(
    model="nvidia/nemotron-3-ultra",
    anomaly_signature=triage_result.signature,
    stack_trace=triage_result.stack_trace,
    system_context=telemetry.context
)

return {
    "status": "resolved",
    "triage_summary": triage_result,
    "code_patch": remediation_patch.diff,
    "verification_tests": remediation_patch.test_suite
}

Explore & Test SentryMesh AI Live Interactive App: SentryMesh AI Streamlit Mission Control

GitHub Repository: github.com/Masngo/sentrymesh-ai

Drop a comment below with your feedback or thoughts on automated SRE workflows!

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

Submission history