Project Info
Inspiration
AI coding tools have made it possible for anyone to build and deploy software in hours. Platforms like Cursor, Claude Code, Replit, and Lovable dramatically lower the barrier to shipping products, but they don't answer a critical question: "Is this application actually secure?" We noticed that many founders, indie hackers, and student developers were deploying production applications without understanding common security risks such as exposed API keys, broken authentication, injection vulnerabilities, and insecure dependencies. Traditional security tools are designed for security professionals and often generate overwhelming reports filled with jargon and false positives. We wanted to build a security platform that works for the new generation of AI-powered builders—a system that doesn't just detect vulnerabilities, but actually proves, explains, and fixes them.
What it does
Sentinel is an AI-powered security platform that uses multiple specialized agents to scan applications, validate vulnerabilities, generate fixes, and continuously monitor security posture. Instead of producing long vulnerability reports, Sentinel follows a complete workflow: Detect vulnerabilities using specialized AI security agents. Simulate real-world attacks inside isolated sandboxes. Explain findings in plain English with visual evidence. Fix vulnerabilities by generating production-ready patches. Monitor applications continuously with a Trust Score. Sentinel can identify issues such as: Exposed secrets and API keys Authentication and authorization flaws SQL injection and XSS vulnerabilities Missing rate limits Vulnerable dependencies and supply-chain risks The result is a security experience that is understandable even for non-security experts.
How we built it
Sentinel combines three major components into a unified security pipeline: AI Security Engine We built a multi-agent architecture consisting of: Coordinator Agent Secrets Detection Agent Authentication Agent Injection Testing Agent Rate Limiting Agent Supply Chain Agent Validation Agent These agents work in parallel to investigate applications and verify findings. Exploit Simulation Layer Using Browserbase and isolated cloud sandboxes, Sentinel safely reproduces vulnerabilities against sandboxed copies of applications. Findings are only escalated when an exploit can actually be reproduced, dramatically reducing false positives. Platform Infrastructure Our stack includes: Next.js for the frontend Cloudflare Workers and Durable Objects for orchestration Browserbase for browser automation Upstash Redis for queues and rate limiting PostgreSQL and Prisma for persistence Anthropic and OpenAI models for reasoning and patch generation Sentry and Arize AI for observability Once a vulnerability is verified, Sentinel generates a fix and can automatically create a GitHub pull request containing the patch.
Challenges we ran into
Reducing false positives One of the biggest challenges in application security is alert fatigue. Most scanners report issues that are not actually exploitable. To address this, we built a validation layer that requires every finding to be reproduced in an isolated sandbox before it is considered verified. Safe exploit execution Running attack simulations is inherently risky. We needed a way to test exploits without touching production systems. We solved this by spinning up isolated environments for every scan, ensuring all attack activity remains contained. Multi-agent orchestration Coordinating multiple autonomous security agents introduced challenges around consistency, duplicate findings, and patch conflicts. We introduced dedicated Coordinator and Validator roles to manage communication and maintain deterministic results. Explaining security to non-experts Security reports are often difficult to understand. We spent significant effort translating technical findings into plain-language explanations supported by visual evidence and guided remediation.
Accomplishments we're proud of
Built a fully functional multi-agent security workflow. Created a validation system that proves exploitability before reporting issues. Generated real patches instead of generic remediation suggestions. Integrated live browser-based attack simulation. Produced an experience that makes security accessible to non-security builders. Unified detection, validation, explanation, and remediation into a single platform.
What we learned
Building Sentinel taught us several important lessons: Proof beats detection. A verified exploit is far more valuable than hundreds of theoretical warnings. Specialized agents outperform giant prompts. Giving each agent a focused responsibility improved reliability and reasoning quality. Security is also a UX problem. Users care less about vulnerability names and more about understanding risk and fixing it quickly. Isolation is critical. Safe testing environments are essential for trustworthy automated security validation.
What's next
Our roadmap includes: Launching a production-ready VS Code extension. Expanding continuous monitoring capabilities. Supporting additional vulnerability classes such as SSRF, CSRF, and IDOR. Releasing mobile notifications and voice-based security summaries. Building organization-wide security dashboards and Trust Passports. Our vision is simple: Make application security as accessible as modern AI coding tools. Sentinel helps builders understand what is vulnerable, see how it can be exploited, and fix it before attackers ever get the chance.
Sentinel
AI agents that scan, simulate, and explain security risks in modern apps — before attackers find them.
Overview
Sentinel is an AI-powered security platform built for the new generation of software: apps created with Cursor, Replit, Claude Code, Bolt, Lovable, freelancers, or plain momentum and vibes. These tools let anyone build and ship software faster than ever — but they don't tell you whether what you shipped is safe.
Sentinel closes that gap. Connect a repo or paste a URL, and Sentinel deploys AI security agents to investigate your application, simulates real exploits in a sandboxed environment, explains what it found in plain English, and helps you fix it.
Not a report generator. Not a dashboard full of CVE numbers. A system that scans, proves, explains, and fixes.
The Problem
Modern software development has a trust gap.
AI-assisted tools have made it possible for founders, indie hackers, small business owners, and non-traditional developers to build production applications in hours. But security tooling hasn't kept up. The people shipping these apps aren't security engineers. They haven't audited every line of code. Many didn't write the code at all — an LLM did.
The result: thousands of apps going live every day with exposed API keys, broken authentication, injection vulnerabilities, and misconfigured infrastructure. The builders don't know these problems exist, and the tools they're using don't warn them.
Traditional security scanners are built for security teams at large companies. They output jargon-heavy reports, require expertise to interpret, and stop at detection. They don't explain, don't demonstrate, and don't help you fix anything.
Sentinel is built for everyone else.
Why Now
Three things happened at the same time:
- AI tools democratized building. Millions of new apps are being created by people who have never touched a security scanner in their life.
- AI agents got capable enough to investigate. LLMs can now reason about codebases, identify vulnerability patterns, and generate meaningful patches — not just flag regex matches.
- Sandboxing infrastructure became accessible. Containerized environments and headless browsers make it possible to safely simulate attacks against live applications at low cost.
The window is open for a security product that meets builders where they are: fast, visual, understandable, and actionable.
What Sentinel Does
Sentinel combines three capabilities that are usually separate products — or don't exist at all:
1. AI-Powered Vulnerability Investigation
Sentinel doesn't just run a static rule set. It deploys AI security agents that explore your codebase the way a human pentester would: reading code, tracing data flows, identifying attack surfaces, and classifying vulnerabilities by type and severity. Findings are scored, prioritized, and translated into plain-English explanations that any builder can understand.
2. Sandboxed Attack Simulation
Instead of telling you "there's an auth bypass on line 43," Sentinel shows you. It spins up an isolated sandbox environment, reproduces the exploit path, and generates a cinematic attack replay — a visual walkthrough of exactly how an attacker would breach your application. This is the moment that turns an abstract warning into a concrete understanding.
3. Explainability and Remediation
Every finding comes with a plain-English risk explanation ("Someone could access your entire user database without logging in"), an impact assessment, and a suggested patch. The goal isn't just awareness — it's resolution.
How the Three Repos Come Together
Sentinel is the unified product formed by merging the strongest ideas, infrastructure, and prototypes from three purpose-built projects:
| Project | What It Contributes to Sentinel |
|---|---|
| VibeAudit | The consumer-facing product layer. Web app UX, scan dashboard, trust scoring, plain-English findings, patch suggestions, VS Code extension scaffolding, and the core thesis that security should be accessible to non-experts. |
| Codebreaker | The AI security intelligence engine. Agent orchestration, vulnerability investigation and localization, multi-model agent runtime, research-grade benchmark methodology (ECVEBench), and the infrastructure to run AI agents against real codebases at scale. |
| Synapse | The sandbox and simulation layer. Isolated container environments, real-time app interaction, collaborative sandbox architecture, telemetry-aware testing concepts, and the foundation for exercising applications dynamically rather than just scanning them statically. |
These weren't three disconnected experiments stapled together. They were three serious prototypes that each solved one piece of the same problem. Sentinel is the architecture where all three pieces fit.
┌─────────────────────────────────────────────────────────┐
│ SENTINEL │
│ │
│ ┌─────────────┐ ┌──────────────┐ ┌───────────────┐ │
│ │ Product & │ │ AI Security │ │ Sandbox & │ │
│ │ UX │ │ Engine │ │ Simulation │ │
│ │ (VibeAudit) │ │ (Codebreaker)│ │ (Synapse) │ │
│ └──────┬──────┘ └──────┬───────┘ └──────┬────────┘ │
│ │ │ │ │
│ └────────────────┼──────────────────┘ │
│ │ │
│ ┌───────────▼────────────┐ │
│ │ Unified Scan Pipeline │ │
│ │ Detect → Simulate → │ │
│ │ Explain → Fix │ │
│ └────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
Core Features
- URL-based and repo-based scanning — paste a deployed URL or connect a GitHub repo
- AI agent investigation — security agents explore and reason about your codebase, not just pattern-match
- Trust scoring — A–F grade that summarizes your application's security posture at a glance
- Plain-English risk explanations — "Your checkout page leaks credit card data," not "CWE-79 reflected XSS"
- Sandboxed exploit simulation — isolated environments where vulnerabilities are safely exercised
- Attack replay walkthroughs — cinematic demonstrations of how an exploit works, narrated and visual
- Patch recommendations — suggested code fixes for every finding
- Behavior-aware testing — dynamic app interaction, not just static file scanning
- Developer workflow integration — VS Code extension with inline findings and one-click patches (roadmap)
Product Flow
Connect repo or paste URL
│
▼
Sentinel launches AI security agents
│
▼
Agents investigate the codebase + scan the live app
│
▼
Sandboxed simulations exercise real exploit paths
│
▼
Findings scored, prioritized, explained in plain English
│
▼
Attack replay generated — see the breach happen safely
│
▼
Patch suggestions produced — fix it before you ship
Example User Journey
Maya runs a small e-commerce business. She hired a freelancer to build her storefront with Cursor and deployed it on Vercel. It looks great. She has no idea whether it's secure.
- Maya pastes her store's URL into Sentinel.
- Sentinel's AI agents investigate the codebase and the live deployment.
- The system finds a broken authentication check on the admin panel — anyone can access
/adminby manipulating a cookie value. - Sentinel spins up a sandbox, reproduces the exploit, and generates a 30-second replay showing exactly how an attacker walks into her admin dashboard.
- Maya sees: "Someone can access your admin panel and view all customer orders without logging in. Time to exploit: under 5 seconds."
- Sentinel suggests a two-line patch to fix the auth check.
- Maya sends the fix to her freelancer. Problem solved before a single customer was affected.
Technical Architecture
Frontend + Product Layer (from VibeAudit)
├── Next.js 15 + TypeScript + Tailwind
├── Clerk authentication
├── Prisma ORM + PostgreSQL
├── Dashboard: scans, findings, trust scores, patch viewer
├── Sentry error monitoring
└── Upstash Redis for scan queue + rate limiting
AI Security Engine (from Codebreaker)
├── Multi-model agent runtime (Anthropic, OpenAI, Google)
├── Cloudflare Workers + Durable Objects orchestration
├── Agent roles: Coordinator → Investigator → Validator
├── Vulnerability classification across 13 CWE-derived categories
├── ECVEBench: research-grade benchmark for agent evaluation
├── Hono API layer + Drizzle ORM
└── MCP SDK integration for tool use
Sandbox + Simulation Layer (from Synapse)
├── Cloudflare Containers for isolated environments
├── Per-scan sandboxed filesystem
├── Dynamic app interaction and behavioral testing
├── Headless browser exploit simulation (Browserbase)
├── ElevenLabs narration for attack replays
└── Supermemory for session context and changelog generation
Sponsor Integrations
| Sponsor | Role in Sentinel |
|---|---|
| Anthropic | Powers AI agents for vulnerability investigation + patch generation |
| Cloudflare | Workers, Durable Objects, and Containers for agent runtime + sandboxes |
| Sentry | Runtime error monitoring and trust-layer telemetry |
| Browserbase | Headless browser for live URL exploit simulation |
| ElevenLabs | Narrated attack replay walkthroughs |
| Upstash (Redis) | Scan queue management and API rate limiting |
| Arize AI | Observability for AI agent calls |
Why It's Different
| Traditional Scanners | Sentinel |
|---|---|
| Static rule matching | AI agents that reason about code |
| Jargon-heavy reports | Plain-English explanations |
| Detection only | Detection → simulation → explanation → fix |
| Built for security teams | Built for builders |
| "You have 47 findings" | "Here's a video of someone stealing your users' data" |
| Manual triage required | Prioritized, scored, and actionable |
Most security tools stop at telling you something is wrong. Sentinel shows you what happens if you don't fix it, explains why it matters in language you understand, and hands you the patch.
Built For
- Indie hackers shipping side projects and MVPs
- Startup founders who need confidence before launch
- Vibe coders building with AI tools and shipping fast
- Small business owners who hired someone to build their app and want to verify it's safe
- Developers who want a second pair of eyes before production
- Freelancers who want to prove to clients that their work is secure
MVP Scope
What's built or scaffolded:
- Full Next.js product shell with landing page, dashboard layout, and design system (glassmorphism, dark mode)
- Complete Prisma data model: Users, Projects, Scans, Findings (with plain-English fields, severity, patch diffs, sandbox payloads)
- Clerk authentication integration
- AI agent orchestration infrastructure with coordinator/investigator/validator architecture
- Multi-model agent runtime supporting Anthropic, OpenAI, and Google models
- Sandbox container infrastructure via Cloudflare Workers + Containers
- VS Code extension with activity panel, findings tree, CodeLens patches, and SSE streaming
- Benchmark framework (ECVEBench) for evaluating agent accuracy across 13 vulnerability classes
- Sponsor integration scaffolding (Sentry, Upstash, Browserbase, ElevenLabs)
What's planned:
- End-to-end scan pipeline connecting the product layer to the agent engine
- Live URL scanning via Browserbase headless browser
- Full attack replay generation with ElevenLabs narration
- Trust score computation and embeddable badge ("Secured by Sentinel")
- Auto-patch application through GitHub PRs
- Public API for CI/CD integration
- Continuous monitoring and deploy-hook triggers
- Richer developer tooling (deeper VS Code integration, CLI)
Future Roadmap
- Deeper simulation — multi-step exploit chains, not just single-vulnerability demos
- Richer replay media — personalized video walkthroughs with AI narration and visual annotations
- Continuous monitoring — re-scan on every deploy, alert on regressions
- Stronger patch automation — auto-open PRs with verified fixes, not just suggestions
- Broader integrations — Vercel, Netlify, Replit, and Shopify deploy hooks
- Embeddable trust badges — "Sentinel: A+" badge for sites to display
- Advanced developer tooling — CLI scanner, GitHub Action, CI/CD pipeline integration
- Marketplace — connect with vetted security professionals for issues that need human review
Stack
| Layer | Technologies |
|---|---|
| Frontend | Next.js 15, TypeScript, Tailwind CSS, Radix UI, Framer Motion |
| Auth | Clerk |
| Database | PostgreSQL + Prisma, Cloudflare D1 + Drizzle |
| Backend | Convex (real-time), Hono (API), Cloudflare Workers |
| AI | Anthropic Claude, OpenAI, Google Gemini, Vercel AI SDK |
| Sandbox | Cloudflare Containers, Browserbase |
| Queue | Upstash Redis |
| Media | ElevenLabs (TTS), Supermemory (context) |
| Monitoring | Sentry, Arize AI |
| Extension | VS Code Extension API, SSE streaming |
Getting Started
# Clone the repo
git clone https://github.com/your-org/sentinel.git
cd sentinel
# Install dependencies
npm install
# Set up environment variables
cp .env.example .env.local
# At minimum set DATABASE_URL and the two Clerk keys.
# Anthropic/GitHub are OPTIONAL — see below.
# Create the database schema (Drizzle, not Prisma)
npm run db:push
# Run the dev server
npm run dev
Works without paid APIs
Scans run on a deterministic engine (hardcoded-secret detection + OSV.dev
supply-chain CVE lookup) that needs no API key. Point it at any public repo and
you get real findings. Adding ANTHROPIC_API_KEY enables the AI engine
(logic-level vulns); adding GITHUB_TOKEN enables private-repo scans and real
fix-PR creation. Missing keys degrade gracefully — they never fail a scan.
Quality gates
npm run typecheck # tsc --noEmit
npm test # vitest — scoring + scanner unit tests
npm run build # production build
Documentation
docs/ARCHITECTURE.md— system design & scan pipelinedocs/DEPLOYMENT.md— deploy & onboarding (and secret rotation)docs/AUDIT.md— gap analysis & roadmap.env.example— every supported variable
Security note: any credential previously present in
.env.local(Neon, Clerk, Anthropic, GitHub, Upstash, Browserbase) should be treated as compromised and rotated before production. Seedocs/DEPLOYMENT.md.
Team
Built for the UC Berkeley AI Hackathon by a team that believes security shouldn't require a security degree.
Analysis
View
Metric
- 6
- 2
Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.
Technology
- AnthropicIn code
- CSSIn code
- HTMLIn code
- JavaScriptIn code
- Next.jsIn code
- OpenAIIn code
- ReactIn code
- SQLIn code
- Tailwind CSSIn code
- TypeScriptIn code
- VueIn code
- RedisClaimed
11 of 12 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.
AI coding agents
- Claude CodeConfig
- CodexConfig
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
1.5 MB
Source files
270
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
sudarshan-krishnan/Sentinel_AIHackathon_Berkley_2026
339 files · 2.2 MB · @ 1c3cd62
Structure
Interface
91 files · 27%Screens, components and styles rendered to the user.
+10 moreAPI & routing
27 files · 8%Request entry points: routes, handlers and controllers.
Application logic
62 files · 18%Domain rules, services and shared utilities.
Data & schema
9 files · 3%Schema definitions, migrations and data access.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- TypeScript65%
- Markdown32%
- CSS2%
- Shell1%
- SQL0%
- HTML0%
- Other (3)0%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
package.json
npm · 37- @anthropic-ai/sdk
- @clerk/nextjs
- @elevenlabs/client
- @ffmpeg-installer/ffmpeg
- @neondatabase/serverless
- @sentry/nextjs
- @upstash/ratelimit
- @upstash/redis
- @vapi-ai/web
- @xyflow/react
- cloudinary
- drizzle-orm
- fluent-ffmpeg
- framer-motion
- geist
- ioredis
- lucide-react
- next
- +19 more
app/.agents/skills/clerk-tanstack-patterns/templates/tanstack-basic-auth/package.json
npm · 10- @clerk/tanstack-react-start
- @tanstack/react-router
- @tanstack/react-router-devtools
- @tanstack/react-start
- react
- react-dom
- +4 more
apps/chrome/package.json
npm · 10- lucide-react
- react
- react-dom
- +7 more
app/.agents/skills/clerk-react-patterns/templates/react-basic-auth/package.json
npm · 8- @clerk/react
- react
- react-dom
- +5 more
app/.agents/skills/clerk-nextjs-patterns/templates/nextjs-basic-auth/package.json
npm · 7- @clerk/nextjs
- next
- react
- react-dom
- +3 more
app/.agents/skills/clerk-react-router-patterns/templates/react-router-basic-auth/package.json
npm · 7- @clerk/react-router
- react
- react-dom
- react-router
- +3 more
app/.agents/skills/clerk-expo-patterns/templates/expo-basic-auth/package.json
npm · 6- @clerk/expo
- expo
- expo-router
- expo-secure-store
- react
- react-native
app/.agents/skills/clerk-vue-patterns/templates/vue-basic-auth/package.json
npm · 6- @clerk/vue
- vue
- +4 more
app/.agents/skills/clerk-chrome-extension-patterns/templates/chrome-ext-basic-auth/package.json
npm · 4- @clerk/chrome-extension
- plasmo
- react
- react-dom
apps/vscode/package.json
npm · 44 development-only dependencies.
app/.agents/skills/clerk-astro-patterns/templates/astro-basic-auth/package.json
npm · 3- @astrojs/node
- @clerk/astro
- astro
app/.agents/skills/clerk-nuxt-patterns/templates/nuxt-basic-auth/package.json
npm · 2- @clerk/nuxt
- nuxt
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
Feature verification
Agentic-risk analysis of the target repo's own AI agents (MCP/agent permission graph)Verified
Not explicitly in Devpost/README, but present in code as part of the security engine's investigation capability
Claimed on readmemedium confidencelib/agent-scan.ts:4— Statically analyzes a repo for agentic risk: detects AI agents/MCP servers, maps tool permissions, and reasons about prompt-injection, secret-exfiltration, and blast-radius attack classes.
Automatic patch generation and GitHub PR creationVerified
Sentinel generates a fix and can automatically create a GitHub pull request containing the patch
Claimed on Devposthigh confidencelib/scan-service.ts:177— generateFix in lib/scanner.ts asks the model for a complete patched file.lib/github.ts:370— openFixPr creates a branch, commits the patched blob, and opens a real PR via the GitHub REST API.
Clerk authenticationVerified
Clerk authentication integration for the product layer
Claimed on readmehigh confidencemiddleware.ts:1— clerkMiddleware wired into Next.js middleware.lib/auth.ts:9— Uses Clerk's auth() helper for session/user resolution.
Dashboard with live scan/findings data (not fabricated demo data)Verified
Dashboard: scans, findings, trust scores, patch viewer, driven by real data
Claimed on readmehigh confidencedocs/AUDIT.md:39— Audit documents the dashboard was rewired from hardcoded fixtures to live /api/dashboard aggregation.app/api/dashboard— Dedicated dashboard API route exists to aggregate real scan/finding data.
Deterministic secrets and supply-chain scanning (no AI dependency)Verified
Works without paid APIs via a deterministic engine: hardcoded-secret detection and OSV.dev supply-chain CVE lookup
Claimed on readmehigh confidencelib/scanners/secrets.ts:1— Pure TypeScript Gitleaks-class secret scanner with provider regexes and entropy checks, no API key needed.lib/scanners/osv.ts:1— Queries OSV.dev for dependency CVEs without any API key.
ElevenLabs narrated voice briefing / conversational agentVerified
ElevenLabs narrated attack replay walkthroughs and voice-based security summaries
Claimed on readmehigh confidencelib/elevenlabs.ts:69— Real ElevenLabs TTS integration and signed conversational-agent URL minting.app/results/page.tsx:331— Results page calls /api/voice/narrate and supports an ElevenLabs/Vapi voice provider for narration.
Multi-model AI runtime (Anthropic, OpenAI, Google)Verified
Multi-model agent runtime supporting Anthropic, OpenAI, and Google models
Claimed on readmehigh confidencelib/ai/llm.ts:1— AI provider abstraction referenced by scanner.ts (aiAvailable/completeStructured).lib/ai/gemini.ts:1— Separate Gemini provider integration alongside Anthropic.lib/video.ts:7— Video pipeline explicitly uses OpenAI (script/TTS fallback) and Gemini (image generation) alongside Anthropic.
Plain-English risk explanationsVerified
Findings explained in plain English understandable to non-experts
Claimed on readmehigh confidencelib/scanner.ts:43— Scan schema requires a plainEnglish field per finding, generated by the LLM system prompt instructions.
Redis-backed agent memory across scans (recurring/new/resolved tracking + vector search)Verified
Agent memory layer for session context (implied by 'Supermemory for session context' and continuous monitoring)
Claimed on readmemedium confidencelib/agent-memory.ts:1— Implements first/last-seen tracking, embeddings-based vector clustering, and RAG-style context retrieval over Redis, though this is a custom implementation rather than Supermemory as named in the README.
Repo/URL security scanning with AI agent investigationVerified
Sentinel deploys AI security agents to investigate a codebase and classify vulnerabilities
Claimed on readmehigh confidencelib/scanner.ts:151— scanRepo sends real repo files to Claude via forced tool-use and returns structured findings classified by agent category (secrets/auth/injection/ratelimit/supply).lib/scan-service.ts:60— runScan orchestrates fetching the repo, running deterministic scanners plus the AI scanner, and persisting findings.
Sentry error monitoringVerified
Sentry runtime error monitoring and trust-layer telemetry
Claimed on readmehigh confidenceinstrumentation-client.ts:8— Sentry.init configured for client.sentry.server.config.ts:9— Sentry.init configured for server runtime.next.config.ts:17— next.config wraps the app with withSentryConfig.
Trust Score (A-F grade)Verified
Continuously monitors applications with a Trust Score (A-F grade summarizing security posture)
Claimed on readmehigh confidencelib/trust-score.ts:37— computeScore/scoreToGrade implement a deterministic severity-weighted 0-100 score mapped to A-F grades from real findings.
Vulnerable dependency and supply-chain risk detectionVerified
Identify vulnerable dependencies and supply-chain risks
Claimed on Devposthigh confidencelib/scanners/osv.ts:1— Parses manifests and batch-queries OSV.dev for known CVEs to produce supply-chain findings.
Cinematic attack replay walkthrough with narrationCode-supported
Generates a cinematic attack replay, a visual walkthrough narrated with ElevenLabs of exactly how an exploit works
Claimed on readmemedium confidencelib/attack-paths.ts:1— Deterministic attack-path/kill-chain engine derived from real findings, explicitly not a simulated attack (comment: 'not a simulated attack').lib/video.ts:1— Real video pipeline (script -> visuals -> ElevenLabs/OpenAI TTS -> ffmpeg -> Cloudinary) exists for scan summaries, but this is a generic findings summary video, not necessarily a per-exploit cinematic breach replay as described.
Missing rate limit detectionCode-supported
Identify missing rate limits
Claimed on Devpostmedium confidencelib/scanner.ts:35— The 'ratelimit' category is defined in the AI scanner's classification scheme and detected via LLM reasoning, not a dedicated deterministic check.
Multi-agent architecture (Coordinator/Investigator/Validator + specialized roles)Code-supported
A multi-agent architecture with Coordinator, Secrets, Authentication, Injection Testing, Rate Limiting, Supply Chain, and Validation agents working in parallel
Claimed on Devposthigh confidencelib/scanner.ts:10— Only a ScanAgent label enum (secrets/auth/injection/ratelimit/supply) exists; a single LLM call classifies findings into these categories rather than distinct autonomous agents with a Coordinator/Validator running in parallel.
PostgreSQL + Prisma persistenceCode-supported
PostgreSQL and Prisma for persistence
Claimed on Devpostmedium confidencelib/db/schema.ts:1— Real Postgres schema (projects/scans/findings/scanLogs) exists, but per docs/AUDIT.md the persistence layer is Drizzle ORM, not Prisma as claimed ('Create the database schema (Drizzle, not Prisma)' in README setup).drizzle.config.ts:1— Project is configured for Drizzle ORM rather than Prisma.
Sandboxed/live exploit simulation via BrowserbaseCode-supported
Simulates real-world attacks inside isolated sandboxes using Browserbase headless browser
Claimed on Devpostmedium confidencelib/browserbase.ts:74— runDastProbe creates a real Browserbase session and navigates a live URL via Playwright over CDP, checking headers/cookies/HTTPS, but this is passive header/cookie inspection, not reproducing a specific exploit path (e.g. auth bypass) as claimed.
Upstash Redis for scan queue and rate limitingCode-supported
Upstash Redis for queues and API rate limiting
Claimed on readmemedium confidencelib/ratelimit.ts:6— Real sliding-window rate limiting via Upstash Ratelimit, gating scans per user.lib/redis.ts:1— Redis client used for caching and agent-memory, but no dedicated job queue implementation was found; scans run inline rather than through a Redis-backed queue.
VS Code extension with inline findings and one-click patchesCode-supported
VS Code extension with activity panel, findings tree, CodeLens patches, and SSE streaming
Claimed on readmemedium confidenceapps/vscode/src— A real VS Code extension package exists (~1800 lines of source, packaged .vsix), but could not confirm end-to-end wiring to the live scan pipeline without deeper review.
Arize AI observability for agent callsClaimed only
Arize AI provides observability for AI agent calls
Claimed on readmehigh confidenceCloudflare Workers and Durable Objects orchestrationClaimed only
Cloudflare Workers and Durable Objects power agent orchestration; Cloudflare Containers provide sandbox infrastructure
Claimed on readmehigh confidenceContinuous monitoring / re-scan on deployClaimed only
Monitor applications continuously with a Trust Score; continuous monitoring capabilities on the roadmap
Claimed on readmehigh confidenceConvex real-time backendClaimed only
Backend stack includes Convex (real-time)
Claimed on readmehigh confidenceEmbeddable trust badge ('Secured by Sentinel')Claimed only
Trust score computation and embeddable badge
Claimed on readmehigh confidenceGitHub webhook / deploy-hook triggered scansClaimed only
GitHub webhook to push/PR-triggered scans; Vercel/Netlify/Replit/Shopify deploy hooks (roadmap)
Claimed on readmehigh confidenceSupermemory integrationClaimed only
Supermemory for session context and changelog generation
Claimed on readmehigh confidence
An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.