Log inGet a free assessment

SAST · Secrets · SCA

Real findings, not noise.
Built for AI agents.

A free, Semgrep-compatible security scanner. It combines tree-sitter AST analysis and cross-file taint tracking, 270+ secret detectors and software composition analysis to find vulnerabilities, leaked secrets and vulnerable dependencies in a single pass. A verified autofix harness then closes them out, all from one binary that drops into CI or runs inside your coding agent over MCP.

Get Started
Bash
$ npx @mondoohq/xgrep scan ./src


  287 files · 2,000+ rules · secrets on


  CRITICAL  sql-injection    src/db/query.py:42   request.args → cursor.execute
  HIGH      aws-access-key   src/config.py:11
  WARNING   weak-crypto      src/auth/hash.py:28


  3 findings · run `xgrep fix` to remediate, or `xgrep deps why` to trace dependencies

Three scanners. One tool.

xgrep unifies static analysis, secret detection and software composition analysis: no separate tools, no interpreter, no warm-up.

SAST→

Tree-sitter AST matching with cross-file taint analysis. Semgrep-compatible, accuracy-first.

Secrets→

270+ detectors across 150+ providers, with deep git-history scanning and live validation.

SCA→

Dependency inventory, reachability, and CVE matching in the same pass, with CycloneDX/SPDX SBOM and CBOM included.

SAST that reports what's actually exploitable.

xgrep parses your code with tree-sitter and traces untrusted input from source to sink across files and functions. It's built to report exploitable issues, not style nits.

AST, not regex
Tree-sitter parsers understand structure and typed metavariables: far fewer false positives than text matching.
Cross-file taint analysis
Follows tainted data through calls and modules to confirm a real source-to-sink path before reporting.
vuln vs. audit tiers
Exploitable issues are separated from hardening advice, so severity reflects real risk, not noise.

Vulnerability coverage

✓Injection (SQL, command, code, LDAP, template)
✓Cross-site scripting (XSS)
✓Server-side request forgery (SSRF)
✓Insecure deserialization
✓Path traversal
✓Authentication & session flaws
✓Weak crypto & TLS
✓ReDoS & denial of service
✓Sensitive-data exposure

Every rule is mapped to CWE and the OWASP Top 10, and every finding ships with code context and remediation guidance. Infrastructure as code is covered too: Terraform/HCL, Dockerfiles, and GitHub Actions workflows.

Bring your own rules: Semgrep-compatible YAML works unchanged
YAML
rules:
  - id: sql-injection
    patterns:
      - pattern: cursor.execute($QUERY)
      - pattern-not: cursor.execute("...")
    message: Possible SQL injection via string formatting
    severity: CRITICAL
    languages: [python]

40 languages supported

ApexBashCC++C#CairoClojureDartDockerfileElixirErlangGoGroovyHackHCLHTMLJavaJavaScriptJSONJsonnetJuliaKotlinLispLuaOCamlPerlPHPPowerShellPythonRRubyRustScalaSchemeSoliditySwiftTSXTypeScriptXMLYAML

Catch secrets before they ship, and the ones already leaked.

Secret scanning runs on every scan. 270+ provider-specific detectors match real key formats instead of guessing on entropy: prefixes, lengths, checksums. You get signal, not noise.

270+ detectors, 150+ providers
AWS, GitHub, Stripe, OpenAI, Anthropic, Slack, Cloudflare, and hundreds more.
Scans full git history
Find secrets that were committed and later removed, with the commit and author that introduced them.
Validates live credentials
Optionally calls the provider to mark each secret confirmed_live, revoked, or invalid.
Secrets hide in git history and encoded blobs. xgrep scans both
Bash
# Find secrets across full git history, with commit provenance
xgrep scan --history --category secrets .


# Decode base64/hex/gzip payloads to catch hidden keys
xgrep scan --decode --category secrets .


# Confirm which leaked keys are still live
xgrep scan --validate --category secrets .

Well-known placeholder values (like AWS’s documentation keys) are filtered out, so examples never page you. Secrets are reported even in test paths, where real credentials most often slip through.

AWSAzureGoogle CloudGitHubGitLabStripeOpenAIAnthropicSlackDiscordTwilioSendGridDatadogCloudflareVaultMongoDBSnykVercelJWTPrivate keys+150 more

Software composition analysis, in the same pass.

xgrep inventories your dependencies straight from lockfiles, traces which of them your code actually reaches, and flags the vulnerable ones. A single xgrep scan covers your first-party code and your dependencies at once.

What’s in here?
A standards-compliant SBOM across 21 ecosystems, from Go, npm, Python, Java, and .NET to Rust, C/C++, Terraform, and GitHub Actions, emitted as CycloneDX or SPDX with PURLs, CPEs, and licenses. Fully offline: nothing is installed or executed.
What actually uses it?
deps why traces every package back to the first-party files that import it, over the same code graph your agents query for reachability. A dependency nobody imports is a very different risk.
What’s vulnerable?
The same run matches dependencies against known CVEs, so vulnerable packages surface alongside code findings. (CVE matching calls the Mondoo vulnerability service; SBOM and deps queries stay fully offline.) Dependencies are also checked against the OpenSSF Malicious Packages feed, so malicious packages are flagged too.
One toolchain for inventory, reachability, and vulnerabilities
Bash
# A standards-compliant SBOM, straight from lockfiles
xgrep sbom --format cyclonedx-json -o sbom.json .


# Which of our own code actually reaches this package?
xgrep deps why --package requests .


# SAST plus dependency CVEs, in a single pass
xgrep scan .
GonpmPythonRustRubyPHPJava.NETDartElixirSwift
Cryptography and AI bills of materials

Inventory the cryptography in your code for post-quantum migration. Run xgrep sbom --cbom . for a CycloneDX 1.6 CBOM. xgrep can also produce an AI-BOM of the models, agents and AI frameworks your code uses.

Read more →

Your CI pipeline shouldn't wait for your scanner.

No interpreter to boot, no packages to install, no warm-up, and no AI agent or hosted backend required. SAST, secrets, and SCA all run from one binary the moment CI calls it.

60 ms cold start
Scanning starts the moment CI calls it
Single binary
Zero dependencies. No Python interpreter, no Docker.
Parallel by default
Scales to all CPU cores

Findings your agent can actually fix, verified.

Discovery is only half the job. xgrep hands your agent a fix contract for each finding and verifies the result, so the loop closes with a real remediation instead of a suggestion. scan discovers and never mutates source; fix is the only command that writes.

Deterministic
One provably-correct edit (for example verify=False → verify=True). Applied automatically, no agent required.
Assisted
xgrep emits a fix contract describing exactly what a valid fix must satisfy, and your coding agent writes the edit to meet it.
Advisory
Where no safe automated edit exists, xgrep returns structured, natural-language remediation guidance instead.
Every edit is verified before it lands

A fix passes a parse-clean gate, an atomic write, and a re-scan gate that rejects it unless it actually cleared the finding without introducing an equal or higher severity issue. xgrep never writes an unverified fix.

Agents drive the same loop over MCP as fix_verify and fix_apply. The interactive TUI (bare xgrep fix) walks findings, delegates assisted fixes to your coding agent, pulls graph context with g, and opens a pull request for applied fixes with P.

Preview, apply, or review interactively. The fix always re-scans clean.
Bash
# Preview diffs without touching disk
xgrep scan --json ./src | xgrep fix verify


# Write the accepted edits
xgrep scan --json ./src | xgrep fix apply


# Or review every finding in the interactive TUI
xgrep fix

Built for the AI-native security workflow.

Traditional SAST dumps 500 findings. Your team ignores 400 of them. xgrep lets AI agents triage with full code context.

Traditional SAST

1Scan codebase
2Dump 500 findings
3Human triages for days
4Next sprint, repeat

AI-Native SAST

1xgrep scans the codebase
2Agent skills trace call chains via the code graph
3Auto-classifies TP / FP with evidence
4Generates fixes with full context
xgrep-triage
Investigate and classify scan findings using code-graph call-chain and dataflow analysis
xgrep-inspect
Navigate and understand source code with AST-powered code intelligence
xgrep-rule-creator
Create custom detection rules with a test-first methodology
xgrep-remediate
Safely fix confirmed findings with the verify/apply autofix harness
secure-coding
Proactively avoid generating vulnerable code patterns while writing

Guard hooks for Claude Code and Codex review every file the agent writes and fix new issues in the same turn.

Bash
# Install the bundled skills into Claude Code
npx @mondoohq/xgrep skill install

“xgrep does not embed an LLM. It gives your agent skills and tools.”

Works with your AI agent.

xgrep integrates as a backend skill for any coding agent, via MCP, CLI, or direct tool calls. Your agent scans, traces, and fixes without leaving the session.

Claude CodeClaude Code
CursorCursor
OpenAI CodexOpenAI Codex
Gemini CLIGemini CLI
GitHub CopilotGitHub Copilot
WindsurfWindsurf
GooseGoose
ClineCline
KiroKiro
RooRoo
TraeTrae
OpenCodeOpenCode
Kilo CodeKilo Code
Claude CodeClaude Code
CursorCursor
OpenAI CodexOpenAI Codex
Gemini CLIGemini CLI
GitHub CopilotGitHub Copilot
WindsurfWindsurf
GooseGoose
ClineCline
KiroKiro
RooRoo
TraeTrae
OpenCodeOpenCode
Kilo CodeKilo Code

In the Mondoo platform

The same engine, across every repository

xgrep, our Semgrep-compatible SAST built for AI agents, runs in the same platform: it powers Code Inspection in Mondoo. Connect your GitHub, GitLab or Azure DevOps organization, and every repository is scanned, new ones included, with no agent and no CI change. Keep xgrep in your pipeline too if you block pull requests on findings. Code is analyzed locally, and only the findings flow into Mondoo, next to your endpoint, server, cloud and SaaS risk.

One supply chain view.

Code, secrets, vulnerable dependencies, malicious packages and infrastructure as code for every repository, in one place.

Fixes at the source.

The same deterministic, assisted and advisory fixes, delivered as pull requests and verified by rescan.

Run it yourself or as a service.

Code Inspection is part of the Mondoo platform and the Agentic Managed Vulnerability Service.

See software supply chain security →Get an assessment

Fix Now. Fix Forever.

First scan in 30 seconds.

Add xgrep as a backend skill for your coding agent, or run it directly.

Install as agent skill

Bash
# Claude Code: install the bundled skills
# (triage, inspect, rule-creator, remediate, secure-coding)
npx @mondoohq/xgrep skill install


# Cursor / Windsurf / any MCP client
{
  "mcpServers": {
    "xgrep": {
      "command": "npx",
      "args": ["@mondoohq/xgrep", "mcp"]
    }
  }
}

Run directly

Bash
# npx (zero install)
npx @mondoohq/xgrep scan ./src


# Or install globally
npm install -g @mondoohq/xgrep


# Rules are built in. Just point at your code
xgrep scan ./src

Common commands

Bash
# Scan for vulnerabilities and secrets
xgrep scan .


# Diff-aware scan in CI (auto-detects the provider)
xgrep ci


# Remediate findings with the verified autofix harness
xgrep fix


# Generate a CycloneDX SBOM, or a Cryptography BOM
xgrep sbom --format cyclonedx-json -o sbom.json .
xgrep sbom --cbom .


# Trace which of your code reaches a dependency
xgrep deps why --package requests .


# Scan git history for leaked secrets
xgrep scan --history --category secrets .


# Output SARIF for GitHub Code Scanning
xgrep scan --sarif -o results.sarif .

In your editor

The Mondoo VS Code extension and the IntelliJ plugin run xgrep’s language server for real-time, in-editor diagnostics, taint visualization and fixes. The VS Code extension is available on the Visual Studio Marketplace and Open VSX (for VSCodium, Cursor and Windsurf).

VS Code MarketplaceOpen VSXIntelliJ