NetSentry AI — MVP Explainer

Collaborative AI Agents and Critics for Fault Detection and Cause Analysis in Network Telemetry

---

1. Concept

NetSentry AI is an API-first SaaS microservice that transforms raw observability data (metrics, logs, traces) into actionable incident intelligence. It solves the alert-fatigue problem that plagues modern SRE/DevOps teams: instead of drowning operators in thousands of individual alerts, NetSentry correlates signals across multiple telemetry types, groups them by affected service, and uses a Large Language Model (LLM) Critic agent to generate a natural-language root-cause hypothesis — all in a single API call.

The Multi-Agent Pipeline

Telemetry Batch (OTEL)
        │
        ▼
 IncidentOrchestratorService
  ┌─────────┴──────────────────┐
  │  Virtual Threads (Java 25) │
  ├──────────────┬─────────────┤
  │  MetricsAgent│  LogsAgent  │
  │  (z-score)   │  (error rate│
  │              │   + pattern)│
  └──────┬───────┴──────┬──────┘
         │  Correlate   │
         ▼   by service ▼
    [CorrelatedAnomalies]
         │
         ▼
  CriticAgentService ──► LLM (OpenAI-compatible)
  (Circuit Breaker +       Root-cause hypothesis
   Retry via R4j)          in natural language
         │
         ▼
   IncidentReport (JPA → H2/PostgreSQL)

---

2. Architecture

Layer	Class	Role
Controller	%%INLINE0%%	%%INLINE1%% — accepts OTEL batches
Controller	%%INLINE2%%	%%INLINE3%% — query API
Controller	%%INLINE4%%	%%INLINE5%% — JWT issuance
Controller	DashboardController	Serves static dashboard HTML
Service	IncidentOrchestratorService	Central pipeline coordinator
Agent	MetricsAgentService	Sliding-window z-score anomaly detection
Agent	LogsAgentService	Error-rate + critical-pattern detection
Agent	CriticAgentService	LLM-powered root-cause analysis
Service	IncidentQueryService	Read-only incident/anomaly projection
Client	LlmFeignClient	OpenFeign declarative HTTP to LLM API
Security	%%INLINE13%% + %%INLINE14%%	HMAC-256 JWT bearer token validation
Entity	IncidentReport	Persistent incident record
Entity	CorrelatedAnomaly	Persistent anomaly record (child of incident)

Technology Choices

Concern	Choice	Reason
Concurrency	Java 25 Virtual Threads	High-throughput OTEL ingestion without thread-pool exhaustion
HTTP client	Spring Cloud OpenFeign 4.2.1	Declarative REST client for LLM API
Resilience	Resilience4j (CB + Retry)	Protects LLM quota; graceful fallback RCA
Auth	JJWT 0.12.6 + Spring Security	Stateless, API-key-compatible JWT bearer scheme
Persistence	Spring Data JPA + H2 (dev) / PostgreSQL (prod)	Zero-config dev; production-grade persistence
Serialisation	Jackson 3 (tools.jackson.*)	Spring Boot 4 default

---

3. API Endpoints

Authentication

POST /api/v1/auth/token
Content-Type: application/json

{"username": "admin", "password": "admin123"}

→ 200 OK
{"accessToken": "eyJ…", "tokenType": "Bearer", "expiresIn": 86400}

Pre-seeded users (MVP):

Username	Password
%%INLINE18%%	%%INLINE19%%
%%INLINE20%%	%%INLINE21%%
%%INLINE22%%	%%INLINE23%%

---

Telemetry Ingestion

POST /api/v1/ingest
Authorization: Bearer <token>
Content-Type: application/json

{
  "events": [
    {
      "serviceName": "payment-service",
      "resourceType": "metric",
      "name": "http.server.request.duration.p99",
      "metricValue": 4850.0,
      "timestamp": "2026-04-09T10:00:00Z",
      "attributes": {"env": "prod", "region": "us-east-1"}
    },
    {
      "serviceName": "payment-service",
      "resourceType": "log",
      "name": "app.log",
      "logBody": "ERROR: connection pool exhausted after 30s timeout",
      "logLevel": "ERROR",
      "timestamp": "2026-04-09T10:00:01Z"
    }
  ]
}

→ 202 Accepted
{
  "eventsProcessed": 2,
  "anomaliesDetected": 2,
  "incidentsCreated": 1,
  "message": "Processed 2 events — 2 anomalies detected, 1 incident(s) created."
}

Supported %%INLINE24%% values: %%INLINE25%%, %%INLINE26%%, %%INLINE27%%

---

Incident Query

# All incidents (newest first)
GET /api/v1/incidents
Authorization: Bearer <token>

# Filter by status
GET /api/v1/incidents?status=OPEN
GET /api/v1/incidents?status=RESOLVED

# Active (non-resolved) incidents only
GET /api/v1/incidents/active

# Single incident with full RCA and anomaly list
GET /api/v1/incidents/{id}

Response example (single incident):

{
  "id": 1,
  "title": "Anomaly detected in service: payment-service",
  "status": "OPEN",
  "severity": "HIGH",
  "affectedServices": "payment-service",
  "rootCauseAnalysis": "**Summary**: The payment-service is experiencing connection pool exhaustion…",
  "detectedAt": "2026-04-09T10:00:02",
  "resolvedAt": null,
  "anomalies": [
    {
      "id": 1,
      "serviceName": "payment-service",
      "anomalyType": "LATENCY_ANOMALY",
      "description": "Metric 'http.server.request.duration.p99' deviated 3.8 standard deviations…",
      "correlationScore": 0.76,
      "detectedAt": "2026-04-09T10:00:02"
    }
  ]
}

Incident status lifecycle: DETECTING → ANALYZING → OPEN → RESOLVED

---

Dashboard (Read-only UI)

GET /dashboard.html   ← serves the static SPA
GET /                 ← redirects to /dashboard.html
GET /dashboard        ← redirects to /dashboard.html

---

4. Anomaly Detection Algorithms

MetricsAgentService — Sliding-Window Z-Score

• Maintains a rolling window of the last 100 samples per {serviceName}::{metricName}.
• Requires at least 5 samples before activating.
• Flags values deviating more than 2.5 standard deviations from the rolling mean.
• Automatically re-classifies anomaly type based on metric name keywords (%%INLINE30%%, %%INLINE31%%, rps, etc.).

LogsAgentService — Dual Strategy

1. Error-Burst Detection: if ≥ 10% of log entries for a service are %%INLINE33%%/%%INLINE34%%/%%INLINE35%%, raises a %%INLINE36%% anomaly.
2. Critical Pattern Matching: scans log bodies for known fatal patterns: %%INLINE37%%, %%INLINE38%%, %%INLINE39%%, %%INLINE40%%, %%INLINE41%%, %%INLINE42%%.

---

5. Business Analysis

Market

• TAM: The global AIOps market is projected to exceed $40B by 2030 (CAGR ~35%).
• Beachhead: Mid-to-large technology companies with microservices architectures spending significant engineering hours on incident response.

Differentiation

Competitor Pattern	NetSentry AI
Single-signal alerting	Multi-signal correlation (metrics + logs)
Threshold-based rules	Statistical z-score + ML-ready extension points
Alert → human	Alert → AI Critic → natural-language RCA
Dashboard-only	API-first (integrates with PagerDuty, Slack, JIRA)

Monetisation (SaaS tiers)

Tier	Events/day	Incidents	Price
Starter	1M	100/mo	$199/mo
Growth	10M	Unlimited	$999/mo
Enterprise	Unlimited	Unlimited + SLA	Custom

---

6. How to Run

Prerequisites

• Java 25
• Maven 3.9+
• (Optional) OpenAI-compatible API key for live LLM analysis

Quick Start (H2 in-memory, no DB setup)

cd solutions/2026-04-09-netsentry-ai-api

# Compile
mvn clean compile

# Run (H2 dev mode, LLM fallback if no key set)
mvn spring-boot:run

The application starts on http://localhost:8080.

Set your LLM API key (optional but recommended)

export NETSENTRY_LLM_API_KEY=sk-your-openai-key
mvn spring-boot:run

Or override via application.properties:

netsentry.llm.api-key=sk-your-openai-key
netsentry.llm.model=gpt-4o

Production (PostgreSQL)

Override the datasource:

export SPRING_DATASOURCE_URL=jdbc:postgresql://localhost:5432/netsentrydb
export SPRING_DATASOURCE_USERNAME=netsentry
export SPRING_DATASOURCE_PASSWORD=secret
export SPRING_JPA_HIBERNATE_DDL_AUTO=update

Get a JWT Token

curl -s -X POST http://localhost:8080/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"admin123"}' | jq .accessToken

Ingest Sample Telemetry

TOKEN=eyJ...  # from above

curl -s -X POST http://localhost:8080/api/v1/ingest \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "events": [
      {
        "serviceName": "checkout-service",
        "resourceType": "metric",
        "name": "http.server.request.duration.p99",
        "metricValue": 9500.0,
        "timestamp": "2026-04-09T10:00:00Z"
      },
      {
        "serviceName": "checkout-service",
        "resourceType": "log",
        "name": "app.log",
        "logBody": "ERROR: OutOfMemoryError in cart calculation thread",
        "logLevel": "ERROR",
        "timestamp": "2026-04-09T10:00:01Z"
      }
    ]
  }' | jq .

View the Dashboard

Open http://localhost:8080 in your browser, paste your JWT token, and click Load Incidents.

H2 Console (development only)

Open http://localhost:8080/h2-console — JDBC URL: jdbc:h2:mem:netsentrydb

---

7. References

• OpenTelemetry Specification
• Spring Boot 4 Virtual Threads
• Resilience4j Documentation
• JJWT 0.12.x API
• AIOps Research — arXiv cs.AI
• Spring Cloud OpenFeign

---

Generated by Forge-AI · NetSentry AI MVP · 2026-04-09

---

FinOps Analysis para NetSentry AI

Estimación de Costos Operativos Mensuales

La micro-startup NetSentry AI, con su enfoque en agentes de IA colaborativos para detección y análisis de fallas, presenta un modelo de costos inicial sorprendentemente eficiente, impulsado principalmente por el bajo costo del modelo de lenguaje grande (LLM) gpt-4o-mini y una infraestructura cloud lean.

• Estimación de Tokens LLM: Anticipamos un uso mensual de aproximadamente 5 millones de tokens. Esta estimación considera una base inicial de 10 clientes, cada uno generando un volumen moderado de incidentes que requieren análisis de causa raíz por el Agente Crítico. Se asume un promedio de 3000 tokens de entrada y 700 tokens de salida por incidente, con un búfer para pruebas y variaciones.

• Desglose de Costos Mensuales:

* LLM (OpenAI gpt-4o-mini): ~$5/mes * Este costo se basa en 5M tokens (aproximadamente 3.5M de entrada y 1.5M de salida) a las tarifas actuales de gpt-4o-mini ($0.15/M de entrada, $0.60/M de salida). Incluye un pequeño colchón para fluctuaciones. * Cloud Hosting (AWS/GCP/Azure baseline): ~$35/mes * Esto cubre una instancia de máquina virtual pequeña (ej. AWS t3.small EC2) para la aplicación Spring Boot, una base de datos PostgreSQL gestionada (ej. AWS db.t3.micro RDS), y costos mínimos de almacenamiento (S3), redes y monitoreo (CloudWatch). * Total de Costos Operativos Mensuales Estimados: $40/mes

Estimación de Ingresos Mensuales y Margen de Beneficio

• Ingreso Mensual Estimado: Para la fase de MVP, se proyecta un ingreso de $500/mes. Esto se basa en un modelo de monetización API-first SaaS, con 10 clientes iniciales pagando una tarifa de $50/mes cada uno. Este precio es un punto de entrada competitivo para empresas medianas que buscan una solución especializada en AIOps.

• Margen de Beneficio: Considerando los costos operativos y los ingresos proyectados, el margen de beneficio inicial es excepcionalmente alto:

* ((Ingresos - Costos) / Ingresos) * 100 = (($500 - $40) / $500) * 100 = 92%

Este alto margen de beneficio es una señal muy positiva para la viabilidad de NetSentry AI como micro-startup, indicando que el valor generado por la lógica de IA y la orquestación de agentes supera con creces el costo de los recursos computacionales y de LLM.

Optimizaciones FinOps Clave para Reducir Costos y Mejorar Eficiencia

1. Caché Inteligente de LLM: Implementar un sistema de caché para las respuestas del Agente Crítico. Si se detectan patrones de anomalías similares o se formulan preguntas idénticas, se puede servir una respuesta cacheada en lugar de realizar una nueva llamada al LLM, reduciendo significativamente el consumo de tokens y la latencia.
2. Optimización del Prompt Engineering: Refinar continuamente los prompts enviados al LLM para ser lo más concisos y efectivos posible, asegurando que se extraiga el máximo valor con el mínimo número de tokens. Considerar técnicas como el resumen previo de datos de telemetría antes de enviarlos al LLM.
3. Tiering de Almacenamiento de Datos: Para los datos de telemetría históricos, implementar una estrategia de almacenamiento por niveles (ej. S3 Glacier o similares) para reducir los costos de almacenamiento a largo plazo, manteniendo solo los datos más recientes y críticos en la base de datos de alto rendimiento.
4. Uso de Serverless para el Agente Crítico: Migrar la lógica del CriticAgentService a una función serverless (ej. AWS Lambda, Google Cloud Functions, Azure Functions). Esto permitiría pagar solo por el tiempo de ejecución de la función, escalando a cero cuando no hay incidentes activos que analizar, lo que es ideal para cargas de trabajo intermitentes de IA.
5. Monitoreo Continuo y Ajuste de la Infraestructura: Implementar herramientas de monitoreo de costos (ej. AWS Cost Explorer, GCP Billing Reports) y de rendimiento. Esto permitirá ajustar dinámicamente el tamaño de las instancias de VM y DB a medida que la carga de trabajo real evoluciona, asegurando que no se sobredimensione la infraestructura innecesariamente.

Consideraciones de Escalabilidad FinOps

A medida que NetSentry AI crezca, los costos se escalarán principalmente en dos áreas: el consumo de tokens LLM (si el volumen de incidentes aumenta drásticamente o se usan modelos más potulosos) y la infraestructura de base de datos/computación. Las optimizaciones propuestas no solo reducen los costos iniciales, sino que también establecen una base sólida para una escalabilidad eficiente. La clave será mantener una vigilancia constante sobre el uso de recursos y adaptar la estrategia FinOps a las necesidades cambiantes de la startup.