SYKE
Pricing Cortex GitHub
Dashboard Log In
SYKE v1.8.11

Stop cascading
failures before
they start.

Your AI edits one file — 15 others silently break. SYKE gives every AI agent a live dependency map so it knows what breaks before it builds.

Without SYKE
AI: "Fixed auth.ts. Done!"
⚠ UserService.ts — import broken
⚠ SessionStore.ts — type mismatch
⚠ api/middleware.ts — undefined ref
+19 more files broken — discovered 3 days later
With SYKE
✓ auth.ts → 22 dependents detected
✓ gate_build: FAIL — 15 cascade errors blocked
✓ "3-day bug prevented in 3 seconds."
▶
Real-time Safety Gate
PASS / WARN / FAIL — your AI's last checkpoint before every build
◆
Zero-Config Analysis
8 languages auto-detected. Full dependency graph in seconds, no setup.
■
Visual Dependency Map
See every connection. Simulate file changes. Refactor with confidence.
◆
5-Min AI Onboarding
New hire joins Friday. They ship Monday. scan_project maps the full codebase in minutes.
8 languages
Zero config
Free open source
One command to start
npx @syke1/mcp-server@latest
Secure Your AI Workflow — Free

5-minute setup. No credit card required.

FOUNDING 20

First 20 developers get 30 days of Pro free. Sign up, star our GitHub repo, and unlock your founding Pro access.

Get Started Free

Works with your favorite AI coding tools

Claude Code Cursor Windsurf Copilot

🔒 Your source code never leaves your machine. SYKE runs 100% locally.

Click any node in the graph to see its impact analysis.

auth/auth_repository.dart
Layer BE
Risk HIGH
Deps 9 dependents
Imports 3
DESCRIPTION

IMPACT ANALYSIS
DIRECT (0)
    TRANSITIVE (0)
      GATE CHECK
      ⚠ Modifying this file would trigger WARN from gate_build (9 impacts)
      Try SYKE Free

      Why SYKE Exists

      THE PROBLEM
      • AI edits code blindly
        Claude Code, Cursor, and Copilot are powerful — but they have no awareness of your dependency graph. They modify files without knowing what breaks downstream.
      • Without SYKE: silent failures
        Broken imports. Cascade type errors. Build failures that only appear 10 commits later. The AI moved fast and broke things — in files it never even touched.
      THE SOLUTION
      • MCP Server — eyes for your AI
        SYKE plugs into your AI coding tool as an MCP Server. Before any file is changed, the AI calls check_safe and gets a full cascade map.
      • Dependency graph, always current
        Multi-language static analysis across 8 languages. Parses your entire codebase into a live dependency graph that the AI can query — not a snapshot, not a config file.
      • gate_build — mandatory build gate
        A hard PASS / WARN / FAIL verdict runs before every build. If impact is HIGH, the build is blocked. No more "it compiled but everything is broken."
      WHY DEVELOPERS CHOOSE SYKE
      • 60 seconds to full protection
        One command. Zero config files. SYKE auto-detects your language, builds the entire dependency graph, and starts protecting your codebase. Nothing to install, nothing to configure.
      • Your code never leaves your machine
        SYKE runs 100% locally. No cloud uploads, no telemetry, no third-party access to your source code. Enterprise-grade privacy by default.
      • Plugs into your existing workflow
        Claude Code, Cursor, Windsurf, Copilot — SYKE works as an MCP server inside the tools you already use. No new IDE, no new CLI, no learning curve.
      YOUR CODE NEVER LEAVES YOUR MACHINE
      YOUR MACHINE
      💻 Your Source Code STAYS HERE
      ↓
      ⚙ SYKE MCP Server Static analysis • Dependency graph • Impact scoring
      ↓
      🎨 3D Dashboard localhost:3333
      Only this crosses the network ↓
      🔒 License key + device hash
      SYKE CLOUD
      ✅ License Validation key + device ID → valid/invalid
      🛡
      Zero code transmission. No telemetry. No cloud uploads. No third-party access.
      Your AST, dependency graph, and analysis results never leave your filesystem.
      UNDER THE HOOD — 5 ALGORITHMS, ZERO AI TOKENS

      Most tools stop at counting imports. SYKE runs five production-grade graph algorithms locally — no API calls, no token cost, instant results.

      • SCC Condensation + Topological Sort
        Tarjan's algorithm detects every circular dependency cluster, condenses them into a clean DAG, then computes correct cascade levels. Before: "47 files affected" (inflated by cycles)
        After: "3 in cluster (L0) → 5 (L1) → 4 (L2)"
      • Composite Risk Score (0–1)
        Five weighted signals in one score: fan-in (30%), stability index (20%), cyclomatic complexity (20%), cascade depth (15%), and PageRank (15%). Your AI gets a calibrated number, not just "HIGH." auth_service → 0.82 CRITICAL | utils → 0.31 LOW
      • Git Change Coupling
        Mines your commit history to find files that always change together — even without import relationships. Catches hidden dependencies that static analysis misses entirely. config.json (85% co-change) | auth.css (72%)
      • PageRank for File Importance
        Google's PageRank adapted for code. A file imported by many important files ranks higher than one imported by many leaf files. Every file gets a rank and percentile. auth.ts: rank #1, 99th pctl | utils.ts: rank #4, 92nd
      • Incremental Updates + Memoized Queries
        One file changed? Only that file is re-parsed. BFS results are cached with smart invalidation. Large codebases stay fast — 50ms updates instead of 2-second rebuilds. 10K files: full rebuild 2s → incremental 50ms
      5-MINUTE ONBOARDING CORTEX

      New team member joins your project.
      They're productive by end of day.

      Traditional onboarding burns 2–4 weeks of senior developer time walking through architecture, module ownership, and danger zones. scan_project generates that entire document in under 5 minutes — automatically.

      WITHOUT CORTEX
      → Day 1–3: Architecture walkthrough with a senior dev
      → Week 1–2: Mapping modules, owners, conventions
      → Week 3–4: First cautious PR. Still asking questions.
      2–4 weeks lost
      WITH CORTEX
      ✓ Minute 1: Run scan_project
      ✓ Minute 5: Full architecture doc — modules, risk zones, entry points
      ✓ Day 1: First meaningful PR shipped confidently
      5 minutes. Ship same day.
      • Full architecture document, auto-generated
        Directory structure, module ownership, high-risk files, circular dependencies, entry points, and a quick-start guide — written in plain English by AI, grounded in your live dependency graph. scan_project → ARCHITECTURE.md (auto-written)
      • Saves weeks of senior developer time
        At $29/mo, Cortex pays for itself the first time a new hire skips the two-week ramp. One onboarding cycle saved covers 6+ months of subscription.
      Learn more about Cortex →
      WHY PRO $12/MO
      • Real-time monitoring
        Catches cascade issues as the AI codes, not after the build fails. Every file save triggers an instant impact re-analysis.
      • Advanced graph algorithms
        PageRank hub ranking, composite risk scoring, SCC circular dependency detection, and cascade-level analysis on the condensed DAG.
      WHY CORTEX $29/MO
      • AI-powered semantic analysis
        Gemini, OpenAI, or Claude (BYOK) reads the impacted files and flags broken imports, type mismatches, and interface violations before you even run the compiler.
      • Full codebase onboarding
        scan_project generates a comprehensive architecture document — directory structure, module map, danger zones, and quick-start guide — so new team members ramp up in minutes, not days.

      Pricing

      FREE $0 forever
      • 200 files per project
      • 3 tools (gate_build, check_safe, get_dependencies)
      • Single project
      • 8 language support

      Always free. No credit card required.

      PRO $12/mo ★
      • Unlimited files & multi-project
      • 7 tools + advanced algorithms
      • Real-time monitoring + web dashboard
      • Priority support
      $12 / month $99 / year (save 31%)

      14-day money-back guarantee. No questions asked.

      CORTEX $29/mo
      • Everything in Pro
      • ai_analyze — AI semantic analysis (BYOK)
      • scan_project — full codebase onboarding doc
      • Bring your own AI key (Gemini / OpenAI / Claude)
      $29 / month $249 / year (save 28%)

      Uses your own API key — no token markup.

      FOUNDING 20

      First 20 developers get 30 days of Pro free.
      Sign up and star our GitHub repo to claim yours.

      Start Your Free Trial

      Limited spots. Once they're gone, they're gone.

      Feature Comparison
      Feature Free Pro Cortex
      gate_build (PASS/WARN/FAIL) ✓ ✓ ✓
      check_safe ✓ ✓ ✓
      get_dependencies ✓ ✓ ✓
      analyze_impact + risk scoring — ✓ ✓
      get_hub_files (PageRank) — ✓ ✓
      check_warnings + refresh_graph — ✓ ✓
      ai_analyze (Gemini/OpenAI/Claude) — — ✓
      scan_project (codebase onboarding) — — ✓
      Files per project 200 Unlimited Unlimited
      Multi-project support — ✓ ✓
      Real-time monitoring + dashboard — ✓ ✓
      8 language support ✓ ✓ ✓

      Quick Start

      Step 1 — Create config file
      // ~/.syke/config.json
{
  "licenseKey": "SYKE-XXXX-XXXX-XXXX-XXXX",
  "geminiKey": "your-gemini-api-key"
}

      Get your license key at syke.cloud/dashboard. AI key optional — supports geminiKey, openaiKey, anthropicKey.

      Step 2 — Register MCP server
      # Claude Code
claude mcp add syke -- npx @syke1/mcp-server@latest
      Cursor / Windsurf / Other IDEs

      Cursor (.cursor/mcp.json):

      {
  "mcpServers": {
    "syke": {
      "command": "npx",
      "args": ["@syke1/mcp-server@latest"]
    }
  }
}

      Windsurf (~/.codeium/windsurf/mcp_config.json): same format as Cursor.

      Windows: If npx is not found, use: "command": "C:\\Program Files\\nodejs\\npx.cmd"

      Step 3 — Add build gate
      # Add to your project's CLAUDE.md
After completing code changes, always run the gate_build MCP tool before committing or deploying.

      Your AI will automatically run SYKE's safety check after every task — catches what AI missed before you ship.

      Step 4 — Restart & open dashboard
      Restart your AI agent. Open http://localhost:3333 to see your live dependency graph.
      Available Tools
      • gate_build
      • analyze_impact
      • check_safe
      • get_dependencies
      • get_hub_files
      • refresh_graph
      • ai_analyze
      • check_warnings
      Troubleshooting
      • Port 3333 already in use Set a different port via environment variable: 
        "SYKE_WEB_PORT": "3334"  // in your MCP config env
      • "Could not detect project root" Specify your project root explicitly: 
        SYKE_ROOT=/path/to/your/project npx @syke1/mcp-server@latest
      • Windows: native module build error Requires Node.js 18+ LTS. If you see build errors, try running in PowerShell (Admin): 
        npm install -g node-gyp
      Tool Reference
      Tool Description
      gate_build Mandatory PASS/WARN/FAIL check before builds
      analyze_impact Show all files affected by modifying a target
      check_safe Quick safety check for a single file
      get_dependencies List imports and dependents of a file
      get_hub_files Find the most connected files in your project
      refresh_graph Force re-scan of the dependency graph
      check_warnings (Pro) Detect potential issues across the codebase
      ai_analyze (Cortex) AI-powered semantic analysis of cascade impacts
      scan_project (Cortex) Generate full codebase onboarding document with AI
      87 nodes · 222 edges · 6 layers
      SYKE v1.8.11
      Scroll to zoom
      Drag to rotate
      Terms · Privacy · Security · Refund · FAQ · Changelog · GitHub
      support@syke.cloud
      © 2026 SYKE. All rights reserved.