Next-Gen Security Signal Orchestrator

Protect Your Code
Before It's Built.

SENTINEL is an enterprise-grade forensic engine that intercepts threats in real-time. From secret detection to advanced mathematical supply-chain analysis.

View Plans →
SENTINEL SYSTEM ARCHITECTURE v2.1PIPELINE_VIEW
Layer 1 — IngestionINPUT_SOURCES
{}
source-code
AST-ready langs
⊕
dependencies
npm / pypi / go
⇄
pull-requests
diff + metadata
▶
ci/cd
pipeline triggers
▼
Layer 2 — Analysis EngineCORE_MODULES
sentinel-engine — deterministic analysis pipeline
LiteScannerv2.0
30 regex rules
DeepScanv2.1
AST-level (js/ts/py/go)
Secret Detectionv2.0
27+ pattern families
Supply Chainv2.1
dep maps + typosquat
Integrity Chainv1.3
SHA-256 boot verify
Kill Chain Builderv1.0
cross-session correlation
▼
Layer 3 — OutputSIGNAL_GEN
Signals
JSON
actionable security events
Kill Chain
DOT / JSON
attack narrative graph
Reports
SARIF / HTML
CI-ready artifacts
Not Another AI Dashboard

Sentinel does not use AI. It is a deterministic forensic engine — static analysis, taint tracing, supply chain verification, and real-time threat correlation. Every finding is reproducible, auditable, and yours.

No Black Boxes
Transparent Specification

What Sentinel Actually Does
And What It Does Not.

This is not marketing. Below is the exact technical capability of the Sentinel engine as it ships today — what it covers, what it misses, and what we are actively building. We do not claim to be a universal code analyzer. We are a supply chain security scanner with deep, AST-level analysis for JavaScript, TypeScript, Python, and Go, plus regex-based fallback for other languages. That is the honest scope. Everything else is on the roadmap.

Capabilities (Production)

JS/TS AST Analysis

PRODUCTION READY

Full Acorn-based AST parsing with walker for MemberExpression, CallExpression, NewExpression, Literal, VariableDeclarator, AssignmentExpression. Detects taint propagation, proxy traps, prototype pollution, obfuscated sink construction, reverse shells, dynamic code execution.

Supply Chain Detection

PRODUCTION READY

Lifecycle script deobfuscation (preinstall/postinstall), lockfile integrity verification, registry poisoning detection, typosquatting via weighted Levenshtein distance (npm adapter), phantom dependency analysis, dependency confusion.

CI/CD Threat Detection

PRODUCTION READY

10 GitHub Actions-specific rules: registry override, download-and-execute, auto-publish, .npmrc modification, token masking, self-hosted runner abuse, workflow self-modification, action injection, over-permissive tokens.

Secret Scanning (CLI + Cloud)

PRODUCTION READY

27 regex patterns in LiteScanner + 16 in secrets.yaml: AWS keys, GitHub tokens, OpenAI keys, Stripe keys, Google API, Discord tokens, Slack webhooks, SSH keys, JWT, MongoDB URIs, Supabase keys, Anthropic keys. High-entropy detection as secondary signal.

Multi-Layer Correlation

PRODUCTION READY

ConfidenceScorer (4-tier thresholds: NOISE/SUSPICIOUS/HIGH_RISK/CRITICAL), ScoringEngine (logistic regression model), RiskOrchestrator (jitter quantization, trust levels, session caching, probing detection, lockdown). KillChainBuilder groups cross-file findings into attack narratives.

Zero-Noise PR Filtering

PRODUCTION READY

Parses the complete file for full AST context, but applies an exact-match mathematical filter against the PR patch. It drops 100% of legacy (pre-existing) findings and only alerts developers on the exact lines they modified. No alert fatigue.

PR Baseline + Behavioral Drift

PRODUCTION READY

AuthorBaselineAnalyzer tracks historical PR patterns per contributor. Detects behavioral drift: unusual commit times, new file types, abnormal dependency additions. Integrated into risk scoring as a multiplicative factor.

Language Coverage Matrixas shipped / 2026
LanguageParserRulesCoverage DepthStatus
JavaScript / TypeScriptAcorn AST54+Full: taint, obfuscation, sink detection, lifecycle, supply chain, behavioralPRODUCTION
JSX / TSXAcorn AST54+Same as JS/TS (via acorn-jsx extension)PRODUCTION
PythonTree-sitter WASM42+Full AST taint propagation, eval/exec/base64+exec chain, pickle loads, ctypes native, composite kill chainsPRODUCTION
GoRecursive Descent35+Recursive AST, exec.Command taint, net/http.Get variable URL, C2 domains, base64+exec, cgo, go.mod replacePRODUCTION
Shell / BashRegex8+curl|bash pipelines, rm -rf, destructive commands, env exfiltrationPRODUCTION
GitHub Actions (YAML)Regex10Workflow injection, registry hijack, token leaks, self-hosted abusePRODUCTION
RustTree-sitter WASM12+Full build.rs AST monitoring, process execution (Command::new), outbound network connect, payload embedding, unsafe blocksBETA
DockerAdapter—Container image scanning (worker package only)BETA
pip / PyPIAdapter—Package metadata scanning (worker package only)BETA
Java / C# / Ruby / PHPNone0No parser, no rules. Regex may incidentally match.UNSUPPORTED
C / C++ / Swift / KotlinNone0No parser, no rules.UNSUPPORTED

Languages without a parser receive no AST analysis — only regex pattern matching, which produces higher false-positive and false-negative rates. Java, C#, Ruby, PHP, C, C++, Swift, and Kotlin are not currently analyzed by any Sentinel component. Adding language support requires building a language-specific AST parser or adapter, which is scheduled per subscriber demand.

Known Limitations (Being Addressed)
⚠

No AST parsers for Shell and C-family

JavaScript, TypeScript, Python, Go, and Rust (for build.rs) receive full AST-level analysis. Shell and CI/CD pipelines still rely on regex patterns. This means highly obfuscated payloads in bash scripts might escape detection.

ROADMAPRoadmap: The Rust AST MVP (via web-tree-sitter) targeting build.rs supply chain attacks has successfully rolled out to Beta. Shell parsing is planned for Q4.
⚠

Taint tracking is file-local, not inter-procedural

The current "taint tracking" detects source-sink co-occurrence within the same file. It does not follow data flow across function calls, module boundaries, or files. This limits detection of multi-step attack chains.

ROADMAPRoadmap: Cross-module data-flow graph is in design. Requires building a call-graph resolver per language.
⚠

Threat intelligence is platform-local

While Sentinel now dynamically synchronizes rules and IOCs from Supabase on every scan, it does not query live external reputational feeds (like VirusTotal or AlienVault) at scan-time to prevent scanning delay and credential exposure.

ROADMAPRoadmap: Pluggable proxy gateway for anonymous external threat intelligence feeds is in progress.
⚠

Kill chain correlation is file-name based, not semantic

The KillChainBuilder groups findings by file-name prefix matching and hardcoded chain templates. It does not perform semantic reasoning about attack graphs.

ROADMAPRoadmap: Semantic kill chain engine using capability graph analysis. Worker package has a prototype (capability_graph.js) pending integration.
⚠

Limited runtime sandbox environment

Dynamic analysis is executed via Node's vm.Script module with a 3-second timeout and mock global interceptors. It is not a full-kernel hardware sandbox (like a gVisor/microVM container). Extremely sophisticated malware that detects vm.Script virtualization or utilizes Node.js native bindings (addons) could evade detection.

ROADMAPRoadmap: MicroVM-isolated kernel-level dynamic sandboxing (Firecracker) is planned for the Enterprise tier in Q1.
⚠

No CI/CD platform execution tracing

Sentinel reviews static pipeline configurations (GitHub Actions, GitLab CI, CircleCI, Jenkins). It cannot monitor dynamic runners during runtime, meaning compromises during active pipeline jobs (like a compromised runner VM) are out of scope.

ROADMAPRoadmap: Runner runtime integrity agent is in feasibility study.
Honest Verdict

Sentinel is a production-grade multi-language supply chain security scanner.If your stack is JavaScript/TypeScript, Python, Go, or Rust (Beta AST build.rs scanner), Sentinel provides deep, full AST-level analysis (via Acorn, tree-sitter WASM, and recursive descent parsers) to block malicious dependencies, secret leaks, CI/CD pipeline attacks, and obfuscated supply chain threats.

If your stack is Java, C#, or other environments, Sentinel will scan your code using regex patterns or adapter-level metadata hooks. It provides partial coverage for these other environments, which we are actively expanding with native AST parsers.

We are transparent about this because we intend to fix it. Each subscriber's language usage directly determines which AST parsers we build next. Sentinel's architecture is designed to be extended — every limitation above has a corresponding open issue and allocated engineering time proportional to subscriber demand.

Subscriptions fund roadmap items//CLI ships all improvements free
Sentinel CLI

A security CLI
that scans what you tell it to.

Sentinel CLI runs locally. No data leaves your machine. No account required. It applies a set of regular expressions (30 rules) against added lines in a diff or a file tree and reports matches. That is what it does. It is not an AI, not a cloud platform, not a zero-day predictor.

What makes it different from running grep is that the rules are organized by intent (malicious, suspicious, exfiltration) and severity, the findings persist in a local SQLite database for historical correlation, and there is an optional OS-level interceptor that can gate package installs. The code is intentionally degraded relative to the private cloud engine.

It works on CI. The same scan you run locally can run in a GitHub Action on every pull request. No external services, no API keys, no billing.

Commands & DocumentationSource Code
Sentinel CLI Hub main interface
Agent Enforcement Protocol

Skills that bind
AI agents to Sentinel.

Sentinel is not an AI wrapper. It is a deterministic forensic engine — SAST, supply chain security, MCP server, dependency scanning, and PR auditing. Every finding is reproducible, auditable, and yours.

If you use AI coding agents, these skill files bridge the gap: they teach the agent to invoke Sentinel CLI operations directly — sentinel installfor package gating, sentinel scan for SAST analysis,sentinel precommit install for hook setup. The agent does not reason about security — it executes Sentinel commands and reports the output verbatim. Deterministic results are preserved; model hallucination is eliminated from the security path.

Each skill file encodes a three-tier enforcement protocol. The FORBIDDEN tier lists actions the agent must never take — suggesting npm installas an alternative to sentinel install, offering workarounds when Sentinel blocks a package, or committing without the pre-commit hook installed. The MANDATORY tier lists actions the agent must always take — run SAST before first commit, gate all dependency installations through sentinel install, report block verdicts with raw evidence. The Evidence Hierarchy tier assigns authority: Sentinel tool output (Tier 1) overrides local state (Tier 2), which overrides GitHub metadata (Tier 3), which overrides model reasoning (Tier 4). The model narrates findings; it never overrides them.

Adapting Sentinel output for AI consumption is not a goal of these skills. They exist because AI agents, left unguided, routinely bypass security tooling: they suggest direct npm install when Sentinel blocks a package, they commit secrets because no pre-commit hook was installed, they evaluate supply chain risk using model knowledge rather than real-time AST analysis. The skills close that gap without introducing a new attack surface — the agent holds no special credentials, executes no privileged code, and maintains no persistent state. It simply reads Sentinel output and formats it into the conversation.

sentinel install-skills# detects platform, writes adapter
Claude Code
CLAUD.md
auto-load
Cursor
sentinel.mdc
rules dir
Cline
CLINE.md
auto-load
Windsurf
.windsurfrules
flat rules
OpenCode
SKILL.md
skill dir
Roo Code
ROO.md
custom mode
Gemini CLI
GEMINI.md + CON.md
triple-file
OpenAI Codex CLI
CODEX.md
auto-load

One command writes the correct adapter to the correct path for the detected platform. Also includes a full MCP server implementation for tool-calling AI agents. No manual configuration. The skill loads automatically on the next agent session. All eight adapters maintained in a single source tree.

Sentinel Oracle

Merge Authority
Physical Isolation.

Sentinel Oracle is a physically isolated merge authorization server. The workstation that develops code never holds the credentials to merge it. Even a fully compromised workstation cannot authorize a merge. Oracle runs on a separate device (Raspberry Pi, NUC, mini PC) on the local network with no cloud dependency.

Implements a three-device trust model: workstation (untrusted, polls dashboard), oracle server (trusted authority, polls GitHub directly), phone (identity proof, authenticates via WebAuthn biometric passkey). Every merge requires a fresh cryptographic challenge bound to the specific PR number.

Network transport is Tailscale (WireGuard mesh). No public ports are exposed. The oracle server is the only component with GitHub merge credentials. The workstation only has read-only access to the oracle dashboard.

Whitepaper & Quick StartSource Code
THREE-DEVICE TRUST MODELWORKSTATIONUntrustedPHONEBiometric PasskeyORACLE SERVERTrusted Merge AuthorityGITHUBOutbound OnlyHTTPSWebAuthnQRMerge API
CLI vs Cloud — Why Subscribe?

The CLI is Free.
Why Pay for Cloud?

The CLI is a powerful local tool — but it's manual and one-off. You run it when you remember. The Cloud tier runs the same engine, continuously, on every PR, automatically, and shows you everything in a dashboard.

CLIManual scan → read terminal output → move on
CLOUDPR opened → auto-scanned → dashboard alert → executive report → kill chain
CLINo collaboration — findings live on your machine
CLOUDTeam dashboard + historical trends + differential comparison
CLILiteScanner only (30 SAST rules)
CLOUDFull pipeline: AST taint → kill chain → risk scoring → confidence analysis
Automated PR Pipeline
01
PR Opened
GitHub webhook fires → Sentinel receives event
02
File Fetch
PR diff files fetched via GitHub API
03
AST + SAST
JS/TS → Acorn AST taint analysis. All files → LiteScanner
04
Correlation
Kill Chain Builder groups findings into attack chains
05
Scoring
Risk Orchestrator → Scoring Engine → Confidence Scorer
06
Report
Executive report stored in cloud dashboard
Common Questions

What Sentinel Does That AI Assistants Don't

AI coding tools write and review code. Sentinel secures the supply chain it travels through. They are complementary — not competitors. Here is why you need both.

Why install Sentinel if I already use AI coding assistants?+
AI assistants help you write code faster. Sentinel helps you ship it safely. They operate at different layers: AI tools generate and review syntax; Sentinel performs deterministic static analysis, supply chain verification, and behavioral capability mapping that AI models cannot guarantee. An AI assistant might miss a typosquatted dependency or a malicious postinstall script because it evaluates code semantically, not operationally. Sentinel evaluates what code can actually do — network access, filesystem manipulation, process execution — by running real AST parsers and behavioral mappers.
What specific tasks does Sentinel handle that AI tools cannot?+
Supply chain integrity verification (SHA-256 boot chains), dependency capability mapping (what every package can actually do on your system), typosquatting detection via weighted Levenshtein distance, PR diff surgical analysis with zero-noise filtering, kill chain correlation across findings, OS-level package install interception (Guard), integrity self-auditing, and signal vault cross-session threat correlation. These are deterministic operations — no model inference, no false positives from probabilistic reasoning.
Does Sentinel make my AI coding assistant redundant?+
No. They serve different purposes. Your AI assistant helps you write, debug, and understand code. Sentinel secures the ecosystem that code runs in — the dependencies you install, the PRs you merge, the secrets you might accidentally commit, the build pipelines you configure. A practical workflow: use AI to write the code, then use Sentinel to scan everything before you ship. The CLI is free, so there is no cost barrier to using both.
Which tasks take less time with Sentinel than with AI tools?+
Auditing a pull request for supply chain threats: seconds with Sentinel's surgical diff scanner versus minutes of manual or AI-assisted review. Verifying a package before install: one command (verify-pkg) versus reading through the entire source. Checking your system integrity: automated 6-point check in under a second. Correlating findings into attack narratives: automatic kill chain builder versus manual cross-referencing. Scanning a full repository: Sentinel covers 100+ files in seconds with deterministic results — no pagination, no context window limits.
Which tasks produce fewer errors with Sentinel?+
All of them — because Sentinel is deterministic. AI models produce different answers to the same question depending on context, temperature, and provider. Sentinel produces the same output every time for the same input. There is no hallucination risk in a LiteScanner finding, no drift in capability mapping, no probability in integrity verification. If you need reproducible, auditable security results — for compliance, for CI/CD gating, for incident response — Sentinel's deterministic engine is the difference between evidence and suggestion.
Is Sentinel harder to set up than an AI coding tool?+
No. The CLI runs with a single npx command — no installation, no configuration, no API keys required for the scanner. Compare this to AI coding assistants that require IDE plugins, model API keys, subscription plans, and cloud connectivity. Sentinel's CLI works in air-gapped environments, on CI servers with no internet, and on minimal hardware.

The CLI is free. Cloud is one plan. Try the CLI — no account, no install, no commitment.

Single Plan. Full Power.

Enterprise Intelligence

One plan. Every feature. Unlimited repos, full pipeline analysis, and governance-grade tooling — no tiers, no upsells.

RECOMMENDED

ENTERPRISE

Full governance suite: policy engine, forensic audit trail, HMAC-signed reports, SSO, unlimited repos, 365-day retention, and dedicated support.

👥 Unlimited Guest Collaborators
$789.99/MONTH
Detailed Specification Matrixv5.0 // 2026
FeatureENTERPRISE
Scanner Engine
LiteScanner — local regex rules for secrets, OS, network, eval, and obfuscation●
JS/TS AST Analysis — Acorn-backed source/sink signals, prototype pollution, reverse shell patterns●
Engine Coverage Disclosure — per-scan language depth, confidence, and non-JS limitations●
Lifecycle + Lockfile Analysis — package.json scripts, lockfile poisoning, registry hijack●
Binary + Entropy + Unicode Detection — WASM profiling, high-entropy payloads, zero-width chars●
Config Integrity — .npmrc/.yarnrc registry override, proxy injection, auth bypass●
Supply Chain Shield — npm/pip/docker typosquatting (Levenshtein), scope abuse, trust scoring●
Analysis & Correlation
Kill Chain Builder — correlates findings into SUPPLY_CHAIN_EXECUTION, RCE, EXFILTRATION chains●
Risk Orchestrator — signal aggregation, jitter quantization, risk band classification (P0–P4)●
Scoring Engine — context-weighted, semantic dedup, path-based noise reduction, EDS multiplier●
Confidence Scorer — adaptive signal accumulation, intent grouping, campaign fingerprinting●
Trigger Level Orchestration — 3-level escalation (fast scan → semantic → deep execution graph)●
Author Baseline Analyzer — PR trait comparison vs historical baseline, anomaly detection●
Reports & Governance
Executive Report Builder — 3-tier: Risk Brief, Technical Evidence, Raw Provenance●
Policy Engine — exposure levels, redaction modes, enforcement modes (strict/advisory)●
PR Policy Engine — path-based rules (no-modify, require-review), wildcard matching●
Forensic Audit — git blame trace, responsible author pinpointing●
HMAC-SHA256 Report Signing — Enterprise Certified integrity●
Cryptographic Audit Trail — SHA-256 chained, tamper-evident, verifiable chain●
Infrastructure
Cloud Dashboard — real-time scan results, trends, differential comparison●
GitHub PR Webhook — auto-scan on pull_request opened/synchronized●
Max Tracked RepositoriesUnlimited
Data Retention (cloud metadata)365 days
AES-256-GCM Evidence Encryption●
API Access100k req/mo
Dedicated 24/7 Support + 99.9% SLA●
CLI Tools (all plans)
Local SAST scanning — scan any file/directory offline (unlimited repos)●
npm Package Verification — downloads tarball, scans without installing●
Signal Vault — local SQLite historical tracking●
OS Guard — npm/pip/yarn/pnpm/cargo/docker shell interception●
File Classification — marks sensitive files, pre-commit hooks●
Baseline Management — dependency hash snapshots, drift detection●
Integrity Manager — self-validation, PATH poisoning detection●
Cloud features require a GitHub account. Enterprise includes priority onboarding, custom SLAs, and dedicated security engineer.