Phoenix Purple AI Agent Security Scanning Pipeline

Phoenix Purple is an engineering-first application security platform launched July 7, 2026 by Phoenix Security. It connects directly to AI coding agents and scans generated code inside the agent session using graph-native code intelligence. Instead of feeding entire files to a frontier model line by line, Phoenix Purple builds a persistent knowledge graph of the codebase — mapping every function, call path, entry point, and taint trace across seven languages — and navigates that graph to find reachable, exploitable vulnerabilities. The result is a 10-33x reduction in scanning token cost compared to file-by-file LLM scanning. Findings surface as pull requests with inline explanations and auto-fix proposals via Phoenix Green, not as tickets in a backlog. The platform ships as Purplephx IDE plugins for Cursor, VS Code, Claude Code, and Windsurf, a GitHub App for pipelineless PR scanning, and an MCP server that exposes the knowledge graph to any Model Context Protocol-compatible agent. On a modeled 1,000-repo fleet at 250,000 lines each, Phoenix Purple scanned at $3.60 per confirmed vulnerability versus $64.30 for file-by-file scanning on the same frontier model — an 87% reduction for identical findings.

BUSINESS PROBLEM

AI coding agents now write more code than any security team can review. According to Phoenix Security data from June 2026, developers using Claude Code, Cursor, and Copilot ship 600-800 files per sprint versus 200 in a pre-AI workflow — a 3x increase in code volume. Traditional SAST tools were designed for human-paced development: file-by-file scanners that pay frontier-model rates to read millions of clean lines, then drop results into tickets that may never reach the developer who can act. The average organization running AI coding tools sees 800 findings per sprint, of which 788 are unreachable dead code, test utilities, or dependency noise. The 12 real vulnerabilities are buried, and 2 ship to production before anyone notices. A Gartner survey published September 2025 found that 32% of organizations reported prompt-injection style attacks, and the pace of AI-generated code has only accelerated since. File-by-file scanning at scale is financially unsustainable: at 1,000 repositories, a team paying frontier-model rates spends $64.30 per confirmed vulnerability — not including the engineering hours wasted on false positives, ticket routing, and back-and-forth between security and dev teams. Phoenix Purple solves the cost problem by using a knowledge graph instead of a frontier model to do the heavy lifting. The graph already knows what is reachable and where untrusted input flows. The LLM only gets asked the questions worth paying for.

WHO BENEFITS

Security engineers at mid-to-large organizations (500-5,000 engineers) who are drowning in SAST tool noise and need a single validated risk queue instead of 30 scanner dashboards. Phoenix Purple collapses 112,000 raw findings into roughly 3,000 graph-proven risks, and routes each one to the team that owns the code. For a security engineer spending 15 hours per week triaging false positives, the workflow saves 10-12 hours.

Engineering leaders whose teams adopt AI coding tools at scale. A VP of Engineering at a 1,000-engineer org sees 3x code velocity but also 3x vulnerability surface. Phoenix Purple installs in 20 minutes with no CI pipeline changes and no YAML configuration — the GitHub App scans the next PR automatically. An engineering leader who spends 5 hours per week on security escalations recovers 4 hours per week.

Individual developers using Cursor, VS Code, Claude Code, or Windsurf who want security feedback inside their editor, not in a Jira ticket three days later. A developer who writes 30 PRs per week with AI assistance saves 20-30 minutes per PR by catching vulnerabilities before the diff lands. Phoenix Green auto-fix PRs land in the review queue with a "safe to merge" or "needs review" label, so the developer approves or adjusts rather than investigating and writing a fix from scratch.

HOW IT WORKS

Step 1: Install the Purplephx plugin for your IDE (Cursor, VS Code, Claude Code, or Windsurf) or add the GitHub App to your repository. No CI YAML, no onboarding project, no scanner configuration.

Step 2: Phoenix Purple parses the codebase using Tree-sitter AST across seven languages (TypeScript, JavaScript, Python, Go, Kotlin, Java, Rust) at 500-1,000 files per second. Every symbol, import, and call site is extracted in parallel.

Step 3: JGraphT constructs a directed call graph with 2,000-5,000 symbols and 3,000-10,000 edges. PageRank scores identify entry points. Taint flow analysis maps data paths from untrusted sources (HTTP handlers, user input) to dangerous sinks (SQL execution, command execution, file writes).

Step 4: The knowledge graph persists across sessions. Subsequent scans navigate the graph with intent rather than re-parsing every file. Changes update the delta only. Token cost stays tied to findings, not file volume.

Step 5: OpenGrep executes 2,204 rules across FAST (seconds, no LLM cost), SMART (balanced), and DEEP (full graph traversal) scan modes. Taint traces validate whether a finding is reachable from an entry point.

Step 6: The Agentic Code Triager runs a multi-pass verification pipeline (Hunt, Judge, Verify) using Exploit Developer AI personas. Only findings with validated exploit chains reach a human. False positives stop here, not in a ticket queue.

Step 7: Phoenix Green auto-generates remediation pull requests. Findings are risk-tiered as SAFE (auto-merge), MODERATE (PR opened for review), BREAKING (human review required), or BLOCKED (never automated). The threat context and fix rationale are written into the PR description.

Step 8: The MCP server exposes 20+ knowledge graph tools to Claude Code, Cursor, and any MCP-compatible agent. The agent queries the graph for reachability evidence without sending full file context to the model, reducing agent token spend on every request.

TOOL INTEGRATION

Purplephx for Cursor: Inline vulnerability highlighting as you type. MCP server integration lets Cursor agents query the graph for reachability context before writing code. Open a Cursor Composer session and Phoenix scans every generated block against the graph before it reaches the working tree. GOTCHA: Cursor agents must have the MCP server configured in .cursor/mcp.json. Without it, scanning falls back to post-save hooks instead of real-time.

Purplephx for VS Code: Editor gutter annotations show vulnerability severity and reachability status on the affected line. The VS Code panel surfaces the full evidence trail (graph path from entry point to sink). GOTCHA: VS Code Purplephx scans only files in the workspace root. Monorepo setups with nested workspaces need a .phoenix.yml config file at each workspace root.

Purplephx for Claude Code: Claude Code skills repository at github.com/Security-Phoenix-demo/security-skills-claude-code provides ready-made agent skills. Claude Code can call Phoenix scan, query the graph, and open fix PRs without leaving the terminal. GOTCHA: Skills must be installed per-session. Automate installation by adding them to your project's CLAUDE.md file under the skills section.

Purplephx for Windsurf: Real-time scanning in the Windsurf IDE with graph overlay diffs that show exactly which code paths a change touches beyond the diff itself. GOTCHA: Windsurf integration requires the GitHub App to be installed on the repository for PR scanning. Editor-only mode does not trigger the graph rebuild; run phx scan from the terminal to force a graph update.

ROI METRICS

| Metric | File-by-File Scanning | Phoenix Purple Graph-Native | |---|---|---| | Token cost per confirmed vuln (1,000 repos, 250K lines each, monthly scan) | $64.30 | $3.60 | | Cost reduction | Baseline | 87% lower | | Scan speed per PR diff | 12-45 seconds (full file re-scan) | 2-5 seconds (graph delta only) | | False positive rate | 60-80% (rule-based SAST average) | <10% (graph-validated reachability) | | Setup time | 2-8 hours (CI config, YAML, scanner tuning) | 20 minutes (GitHub App install + plugin) | | PR review time per finding | 25 minutes (investigate, reproduce, ticket) | 2 minutes (review auto-fix PR description) | | Backlog noise ratio | 788 of 800 findings are false positives | 12 of 12 validated findings are actionable | | Vulnerability escape rate to production | 2 per sprint (estimated per Phoenix Security) | Near-zero (validated before PR merge) | | Weekly hours lost to triage | 15-20 hours for a security engineer | 2-3 hours (auto-triaged by Agentic Code Triager) |

CAVEATS

• (HIGH) Graph rebuild required for existing Orange tenants. Organizations already running Phoenix Orange (ASPM) must trigger a knowledge graph rebuild after connecting Phoenix Purple. The graph schema differs between the two products. Run phx graph rebuild from the CLI and expect 5-15 minutes of indexing per 100,000 files. Schedule this during off-peak hours.

• (MEDIUM) Seven-language AST limit. Phoenix Purple supports TypeScript, JavaScript, Python, Go, Kotlin, Java, and Rust. Teams using C#, Ruby, PHP, Swift, or C++ must keep their existing SAST scanner for those languages and ingest results into Phoenix Orange for unified triage. Phoenix has announced Rust support is in private preview as of July 2026.

• (MEDIUM) MCP server token expiry. The default authentication token for the MCP server expires every 24 hours. Teams that rely on persistent MCP connections (e.g., long-running Claude Code sessions) must implement token refresh logic or configure a longer TTL in the server config. The Phoenix dashboard does not send expiration warnings to agents.

• (LOW) No CI pipeline enforcement for FAST mode. The FAST scan mode uses OpenGrep rules only with no LLM validation. Findings in FAST mode bypass the multi-pass agentic verification pipeline. Teams that set FAST as the default scan mode on critical repositories may miss complex vulnerabilities that only surface during DEEP mode graph traversal. Reserve FAST for documentation repos and non-production branches.