mcp2agy
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp2agy Run a full multi-agent security audit on ./src and generate report + fix diff"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.

Model Context Protocol · Multi-Agent 0day Research & Audit Pipeline
mcp2agy is an MCP-native, multi-agent security audit engine engineered for the Google Antigravity (AGY) ecosystem. It coordinates specialized subagents across the complete 0day research lifecycle: static AST taint analysis, 7-class confounder elimination, deterministic Proof-of-Concept verification (≤60s triggers), multi-chain exploit synthesis, publication-ready security reporting, and atomic code remediation.
Key Capabilities (v3.1.0 Resilient Architecture)
Strict Path Safety & Directory Containment: Validates all paths through
assertSafePath(), preventing root directory escapes, path traversal (..), and symlink attacks.Direct Object Tool Interfaces: MCP tools accept native JavaScript objects and arrays directly, eliminating JSON string escaping errors and handler parsing crashes.
Automated Run Artifacts & Compact Summaries: Saves all heavy artifacts (
candidates.json,verified_findings.json,exploit_chains.json,report.md,fixes.diff) tomcp2agy_workspace/runs/<runId>/, returning clean executive summaries to prevent LLM context explosion.Confidence-Calibrated Scanning & Noise Reduction: Categorizes candidate findings into
high,medium, andlowconfidence while automatically ignoring build/test noise (node_modules,dist,tests/,fixtures/).Strict Verifier Gating: Enforces formal reachability checks and confounder clearance before confirming findings, preventing false positives from propagating downstream.
Resilient Phase Progression: Tracks pipeline execution across 5 distinct phases with per-candidate error isolation and detailed
pipeline_state.jsonlogs.Contextual Fix Generation: Patches are generated directly from actual file code snippets and verified candidate line ranges, cross-checked with known call sites.
Related MCP server: zeroforge
Architecture & Agent Pipeline
┌────────────────────────────────────────┐
│ Master Audit Orchestrator │
│ (/audit) │
└───────────────────┬────────────────────┘
│
┌──────────────────┬─────────────────┴──────────────┬──────────────────┐
│ Phase 1: SCAN │ Phase 2: VERIFY │ Phase 2.5: CHAIN │ Phase 3: REPORT & FIX
▼ ▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Scanner │──►│ Verifier │───────────────►│ Chainer │──►│ Reporter & │
│ Subagent │ │ (Parallel) │ │ Synthesis │ │ Fixer Agents │
└──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘
│ │ │ │
[Gate 1: AST] [Gate 2: PoC] [Compound CVSS] [Gate 4: Diff][+] Core Subagents & Modules
Subagent | Role Identifier | Primary Responsibility | Input | Output |
Orchestrator |
| Workflow management, gate checks, agent delegation | Target directory |
|
Scanner |
| Static AST triage, dangerous sink grep, candidate generation | Physical source files |
|
Verifier |
| 7-class confounder clearance, reachability trace, MTS PoC |
|
|
Chainer |
| Multi-primitive correlation, compound CVSS calibration |
|
|
Reporter |
| Publication-ready advisories (Mode A/B/C), root cause breakdown |
|
|
Fixer |
| 16 CWE grounded patches, multi-site call site fixes, unit tests |
|
|
Slash Commands Matrix
Command | Subsystem | Description | Example Usage |
|
| Orchestrates Scanner → Verifier → Chainer → Reporter → Fixer |
|
|
| Static 0day AST analysis producing normalized candidate records |
|
|
| Rigorous PoC verification (≤60s reproducer) & CVSS calibration |
|
|
| Composes Mode A internal reports & Mode B GHSA advisories |
|
|
| Generates minimal atomic patches ( |
|
|
| Inspects active subagents, host OS context, and workspace inventory |
|
|
| Interactive documentation hub and comprehensive tool guide |
|
|
| Concurrent OSINT, port scanning, and cloud asset mapping |
|
|
| Pwntools ROP generation, web payload weaponization |
|
|
| Static decompilation (Ghidra), dynamic Frida hooking |
|
|
| AFL++/LibFuzzer harness generation, custom scanners, Sigma rules |
|
|
| Autonomous multi-category challenge solving (pwn, rev, web, crypto) |
|
|
| Launches synchronized multi-agent offensive mesh |
|
Native MCP Tools — 15 Tools
┌──────────────────────────────────────────────────────────────────────────────────┐
│ Native MCP Tools (15 Tools) │
├──────────────────────┬──────────────────────────┬────────────────────────────────┤
│ Target Profiling │ Static Analysis │ Verification & PoC │
│ • detect_platform │ • analyze_code │ • check_reachability │
│ • profile_target │ • scan_file │ • verify_finding │
│ │ • get_patterns │ • generate_poc │
│ │ │ • calculate_cvss │
├──────────────────────┼──────────────────────────┼────────────────────────────────┤
│ Exploit Chaining │ Remediation & Fix │ End-to-End Automation │
│ • chain_findings │ • generate_fix │ • audit_pipeline │
│ • generate_report │ • check_fix_completeness │ │
│ │ • list_fix_templates │ │
└──────────────────────┴──────────────────────────┴────────────────────────────────┘Category | MCP Tools | Primary Capability |
Target Profiling |
| Detects OS environment, file hashing, and codebase topology |
Static Analysis |
| AST data-flow analysis, dangerous sink inspection & taxonomy matching |
Verification & PoC |
| 7-class confounder clearance, deterministic PoCs (≤60s), empirical CVSS |
Exploit Chaining |
| Multi-primitive exploit correlation & publication-ready advisories |
Remediation & Fix |
| 16 CWE grounded patches, multi-site call site fixes, test generation |
End-to-End |
| Automated orchestration across all pipeline phases with state persistence |
Workspace Directory Structure
All persistent outputs, candidate records, evidence bundles, and patches reside in mcp2agy_workspace/:
mcp2agy_workspace/
├── runs/
│ └── <YYYYMMDD_HHMMSS>/ ← Dedicated per-run execution directory
│ ├── pipeline_state.json ← Orchestrator state & phase progression
│ ├── candidates.json ← Scanner normalized candidates
│ ├── verified_findings.json ← Verifier confirmed findings
│ ├── exploit_chains.json ← Synthesized multi-step exploit chains
│ ├── report.md ← Reporter publication-ready markdown report
│ ├── fixes.diff ← Fixer minimal unified diff
│ ├── evidence/ ← Verifier PoCs & reachability traces
│ │ └── <CAND_ID>/
│ │ ├── reachability.md
│ │ └── mts_poc/ (poc.py, Dockerfile, run.sh)
│ └── regression_tests/ ← Fixer unit test harnesses
├── auditor_zone/
│ └── results/
│ └── <YYYYMMDD_HHMMSS>/ ← Synchronized auditor zone artifacts
├── recon/results/ ← Attack surface maps & OSINT data
├── exploits/pocs/ ← Standalone weaponized exploit scripts
├── reverse/analysis/ ← Decompiled symbols & binary call graphs
├── tools/ ← Custom scanners & fuzzing harnesses
├── ctf/solves/ ← CTF solve scripts & writeups
└── loot/ ← Discovered credentials, keys & tokensAnti-Hallucination Invariants
All subagents operate under 10 strict invariants defined in .agents/plugins/mcp2agy/rules/AGENTS.md:
# | Invariant | Description |
01 | Zero Invention | Never report a finding that static code analysis did not physically produce. |
02 | Line Count Ceiling | Never cite line ranges exceeding the physical file's total line count. |
03 | Physical Hash Echo | Every candidate record must echo the physical SHA-256 hash of the target file. |
04 | Deterministic PoC | Never mark a finding |
05 | Dual-Leg Verification | Both legs of multi-step exploit chains must be independently proven. |
06 | 7-Class Confounder Clearance | Dead code, auto-escaping, auth gates, and strict types must be formally evaluated. |
07 | Empirical CVSS | Score deductions require reproducible technical evidence — no estimation. |
08 | One-Way Information Valve | Downstream agents strictly receive normalized facts to prevent confirmation bias. |
09 | Clean Negative Results | If 0 defects exist, output |
10 | Atomic Minimal Diff | Remediation diffs must touch only vulnerable lines without introducing new TOCTOU races. |
Cross-Platform Compatibility
Node.js Lifecycle Hooks (
hooks.json): Eliminates shell script dependencies —preToolCalllogging andpostFileWritepermission hardening execute via cross-platform Node.js.Permission Hardening: Enforces
chmod 600on POSIX systems and expliciticaclspermission stripping on Windows (icacls <file> /inheritance:r /grant:r "%USERNAME%:(R,W)").Context-Aware Escaping: Distinguishes single-quote (
_pse) vs double-quote (_pde) shell string evaluation in PowerShell heredoc contexts.
Documentation
Detailed technical documentation is available in the docs/ directory:
Document | Description |
How to setup and run | |
Multi-agent orchestrator lifecycle, integrity gates & one-way information valve | |
Complete reference for all 13 slash commands and usage examples | |
Detailed input/output schemas and examples for all 15 native MCP tools | |
Cross-primitive exploit synthesis, gadget chaining & compound CVSS | |
2026+ 0day vulnerability patterns, AST grep signatures & root causes | |
Directory layout, candidate schemas, verified findings & advisory formats | |
Windows NTFS ACLs, POSIX permissions, lifecycle hooks & shell differentials |
mcp2agy · Hyperdope AI · mcp2agy_workspace/
Available Tools
15 toolsanalyze_codeC
Scan source files for 0day vulnerabilities using 72+ research-calibrated patterns. Returns structured candidate records with CWE, priority, confidence tiers, data-flow, and grounding anchors.
Inputs: filePaths (required), language, priority, projectRoot, +1 more.
audit_pipelineA
Run the full resilient 0day audit pipeline: Scan → Verify → Chain → Report → Fix. Writes complete persistent artifacts into mcp2agy_workspace/runs// and returns a compact executive summary.
Inputs: filePaths (required), reportMode, minPriority, projectName, +4 more.
calculate_cvssB
Calculate CVSS v3.1 base score, severity, and metric breakdown from a vector string.
Inputs: vector (required).
chain_findingsA
Synthesize verified findings into multi-step, publication-grade exploit chains (e.g. Traversal + Write -> Persistent RCE; Header Injection -> Agent Escape).
Inputs: findings, candidates, projectRoot, findingsJson, +2 more.
check_fix_completenessC
Check if a fix has been applied at ALL vulnerable call sites in a file, cross-referenced with known candidates.
Inputs: cwe (required), filePath (required), candidates, projectRoot.
check_reachabilityA
Trace data flow from entry point to sink for a scan candidate. Returns reachability status, data-flow path, auth gates, sanitizers, and confidence level.
Inputs: filePath (required), candidate, projectRoot, candidateJson.
detect_platformA
Detect the current host operating system (Windows, Linux, macOS), architecture, shell, homedir, path separators, permission commands, and OS-specific vulnerability nuances.
Inputs: no named parameters.
generate_fixB
Generate a contextual fix based on candidate line range, actual snippet, and verified finding.
Inputs: filePath (required), finding, candidate, findingJson, +2 more.
generate_pocB
Generate a per-CWE Proof-of-Concept template with setup, trigger, expected output, cleanup, and Dockerfile.
Inputs: cwe (required).
generate_reportB
Generate a security report from verified findings. Mode A = internal audit report, Mode B = GHSA advisory draft, Mode C = public writeup.
Inputs: mode (required), findings, ecosystem, candidates, +4 more.
get_patternsA
List vulnerability detection patterns with optional filtering by priority, CWE, language, or vulnerability class.
Inputs: cwe, language, priority, vulnClass.
list_fix_templatesA
List all available per-CWE fix templates with their fix class and description.
Inputs: no named parameters.
profile_targetA
Profile a target project: detect ecosystem, languages, frameworks, entry points, manifest files, and file manifest with hashes and line counts. Phase 0 of the audit pipeline.
Inputs: projectRoot (required), exclude, include.
scan_fileB
Scan a single file for vulnerabilities and return structured candidate records with grounding anchors (file hash + line count).
Inputs: filePath (required), priority, projectRoot, outputFormat, +1 more.
verify_findingA
Verify a scan candidate: check reachability, run 7-class confounder elimination, calibrate CVSS score, and generate per-CWE PoC template. Requires high/medium confidence and cleared confounders for CONFIRMED status.
Inputs: filePath (required), candidate, projectRoot, candidateJson.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
Most tools have distinct purposes (e.g., calculate_cvss vs generate_poc), but scan_file and analyze_code both scan for vulnerabilities with overlapping output structures, and check_reachability is a subset of verify_finding's workflow. Descriptions help differentiate, but some confusion is possible.
All tool names follow a consistent snake_case verb_noun pattern (generate_fix, scan_file, verify_finding, audit_pipeline). No mixed conventions or vague verbs; naming is highly predictable.
With 15 tools, the server is well-scoped for a comprehensive security audit pipeline. Each tool addresses a distinct stage (profiling, scanning, verification, fixing, reporting, chaining), and none feel redundant or excessive.
The tool surface covers the full audit lifecycle: profile_target (discovery), scan_file/analyze_code (detection), verify_finding/check_reachability (validation), calculate_cvss (scoring), generate_poc (exploitation), generate_fix/check_fix_completeness (remediation), chain_findings (synthesis), and generate_report (output). The audit_pipeline orchestrates everything, leaving no major dead ends.
Related MCP Connectors
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
Governed MCP: agent audit, provenance, deterministic checks, and receipt-backed FragGate execution.
Zero-secret MCP gateway for AI agents: risk-scored, audited calls with human-in-the-loop approval.
IaC, CI and dependency security review for coding agents: local scan CLI plus hosted OAuth MCP.
Related MCP Servers
FlicenseAqualityFmaintenanceEnables AI agents to orchestrate security research workflows by connecting to containerized security tools via MCP, allowing automated vulnerability analysis and pipeline execution.24803-- FlicenseNot gradedqualityDmaintenanceEnables adaptive binary 0day research with persistent knowledge graph and adaptive planning, automating vulnerability analysis and exploit development through HexStrike and local tools via MCP.-
- AlicenseAqualityDmaintenanceBridges Google Antigravity CLI with MCP clients, enabling 13 specialized tools for AI-assisted coding, automation, and security audits.13MIT
- FlicenseNot gradedqualityDmaintenanceEnables local AI agents to generate code and interact with Google Antigravity (Gemini Pro) via MCP, consuming zero API tokens.-