Cross-source security intelligence that finds what scanners miss.

28% of critical security incidents originate OUTSIDE code repositories — in Slack, Jira, and collaboration tools. No existing scanner connects the dots. — GitGuardian State of Secrets Sprawl 2026

DeepSentinel is an autonomous AI agent that correlates GitHub PRs, Issues, review comments, Slack discussions, and codebase architecture to find security risks that live in the gaps between your tools. It doesn't just scan code — it scans context.

See it in action: Security review posted on a real PR | Install skill: npx skills add ElijahUmana/deep-sentinel --skill deepsentinel

Snyk finds a SQL injection. CodeQL finds a hardcoded credential. GitHub Advanced Security flags a command injection. These are real vulnerabilities — but they're the ones every tool already catches.

What no tool catches:

• The Slack message where a developer said "skip input validation for the MVP — we'll add it in Q2." Three sprints later, the payment endpoints are still exposed.
• The GitHub Issue tracking hardcoded credentials that was created two months ago and is still open. The same credentials are in the PR being merged right now.
• The PR review comment where a teammate flagged os.system() as dangerous. The fix was deferred. The vulnerability persists.

These are institutional security failures — known risks that accumulate because information is fragmented across tools. DeepSentinel connects the dots.

DeepSentinel runs a 7-step autonomous pipeline that pulls data from multiple sources, correlates findings across them, and produces a composite risk score that factors in team awareness, deferral history, architectural criticality, and historical patterns.

1. GATHER    — Airbyte pulls GitHub PRs, Issues, PR comments + Slack messages (3 connectors)
2. UNDERSTAND — Macroscope analyzes codebase architecture for context-aware severity
3. CACHE     — Aerospike matches code against 10 CWE vulnerability patterns (<5ms)
4. ANALYZE   — TrueFoundry routes multi-model LLM analysis (fast scan + deep verification)
5. CORRELATE — 3-strategy engine: keyword matching + file/module correlation + LLM discovery
6. STORE     — Ghost Postgres persists findings, correlations, audit history + DB forking
7. AUTHORIZE — Auth0 FGA gates access; CIBA escalates to human approval for write actions

Traditional scanners assign severity based on the vulnerability type alone. DeepSentinel computes a composite risk score that no code-only tool can produce:

COMPOSITE RISK = (Code Severity + Deferral Penalty + Historical Frequency) × Architecture Multiplier

A MEDIUM SQL injection scored 82/100 composite because:

• The team deferred the fix for 3 sprints (deferral penalty: +15)
• It's in the payment module (architecture multiplier: 1.3x)
• The same CWE appeared 40 times in historical scans (history bonus: +20)
• A team member flagged it in Slack but it remains unfixed

Snyk would call this MEDIUM. DeepSentinel calls it the highest-risk finding in the repo — because it factors in what the team knows, what they've deferred, and where in the system it lives.

        Auth0 (Device Flow + Token Vault + CIBA + FGA)
                        |
    ┌───────────────────┼───────────────────┐
    |                   |                   |
GitHub PR+Issues    Slack Msgs          Codebase
(Airbyte GitHub)   (Airbyte Slack)    (Macroscope)
    |                   |                   |
    └─────────┬─────────┘                   |
              |                             |
      3-Strategy                    Architecture
      Correlation Engine             Context
              |                             |
              └──────────┬──────────────────┘
                         |
                Security Analyzer + Risk Scorer
               (TrueFoundry Gateway + Overmind)
                         |
              ┌──────────┼──────────┐
              |          |          |
         Aerospike    Ghost DB    Output
         (patterns)   (history)  (PR comment + SARIF)

All 7 integrations are verified working with real credentials and real data. Run python test_integrations.py to confirm.

Every cross-source correlation traces back to verifiable data:

Snyk finds 4 code-level vulnerabilities in payment.py.
DeepSentinel finds those same 4 PLUS:

1. [HIGH] Team explicitly deferred input validation (Slack #engineering, Mar 14)
   → Connected to PR adding unvalidated payment endpoints
   → WHY SCANNERS MISS: Code looks the same whether validation was forgotten or deferred

2. [HIGH] Hardcoded credentials flagged but not remediated (GitHub Issue #3)
   → Connected to same credentials still in codebase
   → WHY SCANNERS MISS: Scanners can't see that the team KNOWS about the issue

3. [HIGH] os.system() flagged by reviewer (PR #1 comment)
   → Still in codebase despite explicit security concern
   → WHY SCANNERS MISS: Review comments exist outside the code

4. [CRITICAL] Compound risk: SQL injection + hardcoded creds + command injection
   in a PAYMENT module with 40 historical occurrences
   → Composite score: 100/100 (vs. Snyk's simple "CRITICAL" label)
   → WHY SCANNERS MISS: No single-source tool computes risk from team context

git clone https://github.com/ElijahUmana/deep-sentinel
cd deep-sentinel

python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt

cp .env.example .env
# Add your API keys (Auth0, GitHub, Slack, TrueFoundry, Ghost, Macroscope, Overmind)

# Scan a specific PR
python scan.py ElijahUmana demo-vulnerable-app --pr 1

# Scan a full repository
python scan.py ElijahUmana demo-vulnerable-app

# Autonomous monitoring mode
python scan.py ElijahUmana demo-vulnerable-app --autonomous

# Generate SARIF output (GitHub Security compatible)
python scan.py ElijahUmana demo-vulnerable-app --sarif

# Run integration verification
python test_integrations.py

• Terminal: Rich formatted security report with cross-source correlations
• GitHub PR comment: Posted directly on the PR (example)
• SARIF 2.1.0: GitHub Security compatible for direct integration
• Ghost DB: Persistent storage with historical trend analysis

• 51 commits during hackathon
• 7,029 lines of Python
• 44 Python files across 8 modules
• 7/7 integrations verified passing
• 1,069+ findings persisted in Ghost DB
• 27+ real Slack messages across 3 channels
• $0.003 average cost per full scan via TrueFoundry

MIT

Elijah Umana — GitHub | Minerva University