SENTINEL Engine v2.4

An automated, multi-agent AI security pipeline that doesn't just find vulnerabilities—it surgically heals them and writes the tests to prove it.

Comment

Inspiration

Modern software moves fast, but security audits are slow, expensive, and often leave developers with a daunting list of problems rather than actual solutions. We realized that finding a vulnerability (like an OWASP Top 10 issue) is only half the battle. We wanted to build an autonomous "immune system" for codebases that bridges the gap between identification and resolution, empowering developers to fix critical issues instantly without context-switching.

What it does

Sentinel Engine is a self-healing code platform powered by a dual-agent architecture:

  1. The Analysis Layer: Scans "dirty" or vulnerable code to detect OWASP security risks, time complexity (Big O) bottlenecks, memory leaks, and logical inconsistencies. It generates a detailed JSON audit report with severity scoring.
  2. The Execution Layer: Consumes the audit report to generate a surgically "healed" version of the code. It doesn't stop there—it also writes a comprehensive Jest or PyTest test suite to prove the vulnerability is patched and prevent future regressions.

All of this is presented in our "Hospital View"—an elegant, side-by-side diff editor that lets developers instantly compare their vulnerable code against the Sentinel-healed code, complete with threat-level badges and a sandbox test execution console.

How we built it

  • Frontend: React, TypeScript, and Tailwind CSS (featuring a custom "Elegant Dark" aesthetic inspired by modern developer tools).
  • Backend: Node.js and Express to securely proxy API requests.
  • AI Architecture: We utilize advanced LLMs (simulating the GPT-5.6 / Codex workflow) with strict structured JSON output parsing to ensure the Analysis agent perfectly hands off context to the Execution agent.

Challenges we ran into

  • Agent Handoffs: Ensuring the Analysis Agent returned perfectly structured JSON so the Execution Agent could accurately understand the context of the vulnerabilities without hallucinating.
  • UI/UX Design: Designing a complex diff-viewer and severity-tracking dashboard that provides deep technical insights (like Big-O notation) without overwhelming the user visually.
  • Prompt Engineering: Tuning the Execution agent to write only the fixed code and the test suite without adding unnecessary conversational filler.

Accomplishments that we're proud of

  • Seamless Multi-Agent Orchestration: We successfully engineered a dual-agent pipeline where the output of one model perfectly dictates the behavior of the next, operating reliably without human intervention.
  • The "Hospital View" Dashboard: Designing a high-performance, side-by-side diff editor that is visually striking yet functional. We managed to condense complex security data (like Big-O notation and OWASP classifications) into an intuitive, elegant interface.
  • Test-Driven Healing: Taking it a step beyond just fixing the code by having the execution agent generate a fully functional Jest/PyTest suite. We built a system that proves its own work.
  • Rapid Full-Stack Delivery: Architecting and deploying a robust React frontend and Node.js/Express backend capable of proxying complex AI requests within the tight constraints of a hackathon.

What we learned

  • Structured Outputs are Everything: In multi-agent systems, natural language is too fragile for agent-to-agent communication. Forcing strict JSON schemas for the handoff was the key to eliminating hallucinations.
  • Separation of Concerns Applies to AI: Giving an AI a singular, focused persona (e.g., "Analyst" vs. "Surgeon") yields vastly superior results compared to asking one model to "find the bugs and fix them."
  • Developers Want Solutions, Not Alerts: Providing a list of vulnerabilities induces alert fatigue. Providing the exact code needed to fix the problem—and the tests to verify it—changes the paradigm entirely.
  • UI Dictates Trust: Presenting the AI's suggestions in a professional, command-center style dashboard (our "Hospital View") makes the system feel like a reliable enterprise tool rather than a chaotic prototype.

What's next for SENTINEL Engine v2.4

The Vision The core lesson of the Sentinel project remains clear: UI Dictates Trust. Version 2.4 will continue to push the platform away from a chaotic prototype and toward an airtight, enterprise-grade automated immune system.

Built With

  • api-proxy
  • artificial-intelligence
  • automated-security
  • big-o-notation
  • bun
  • express.js
  • jest
  • json-schema
  • llm
  • mobile-first
  • multi-agent-systems
  • netlify
  • node.js
  • owasp-top-10
  • prompt-engineering
  • pytest
  • react
  • responsive-design
  • structured-outputs
  • tailwind-css
  • test-driven-development
  • typescript
  • ui-ux
  • vulnerability-healing
Share this project:

Updates