Skip to main content
own2pwn

AI-Native AppSec

AI-Native SAST

The SAST that understands the data flow, not just patterns.

Classic static analysis matches patterns and drowns you in false positives. Our SAST does something else: a deterministic engine traces the data flow from source to sink (where it ends up being used: a SQL query, a system call, HTML rendering), then an LLM agent re-reads the code to decide exploitability and crush false positives before they land in your backlog. Every finding comes with its taint chain (the full route of the untrusted data), a plain explanation and a readable remediation, in an editable report. This is the core of the SecAI platform, built by an OSWE-certified pentester and hosted in the EU. Pre-launch product: we only describe what already runs today.

Start for freeTalk to a pentester
Read-only, hosted in the EU, your code trains no model
Multi-file taint tracking, not a pattern on a line
Source to sink
False positives cut before they reach your backlog
AI agent triage
Sources, sanitizers and sinks, plus 5 in light support
14 languages in depth

Features

What static analysis follows in your code.

Contextual taint-based SAST

We trace the data flow from the source up to the sensitive sink, across functions and files, not just a pattern on a single line. Every finding shows its source to sanitizer to sink chain, so you can see why it was flagged. Real depth on 14 languages: Python, JS/TS and Java first, then Go, PHP, Ruby, Kotlin, C, C++, C#, Rust, Swift, Scala and Bash.

Agent verification, fewer false positives

A deterministic pre-pass (a first pass with no AI, fixed rules, same verdict every time) discards cases with no source or already sanitized before any model call. On top of that, a LangGraph agent re-reads the code through AST analysis tools to confirm or dismiss what remains. You triage what matters, not a dump of alerts.

Prioritisation by real exploitability

The agent decides exploitability instead of spitting out an isolated CVSS score. A reachable, chainable finding rises to the top, a dead case or one already covered by a sanitization step sinks to the bottom. You fix what an attacker actually reaches, not a list sorted by theoretical severity.

AI-native static analysis pricing.

Starter

€0

  • SAST module included in the SecAI offering
  • In plain terms: 2 tracked Git repositories, 20 AI checks per month, 1 person.
  • Unlimited deterministic pre-pass (SAST, SCA, IaC, secrets)
  • Up to 10 scans per day
  • Scans on push/PR and cron-scheduled
  • HTML report and SARIF export
  • Free, no time limit and no credit card
Start for free
Recommended

Pro

€99 / mo

  • In plain terms: unlimited repositories for a team of 5, 250 AI checks per month.
  • Up to 200 scans per day
  • LLM agent verification and attack-path correlation
  • GitHub App, SARIF Action, severity gate and auto-fix PR/MR
  • Slack, webhook and email notifications
  • Extra validation at €0.30 (pay-as-you-go)
Subscribe

For businesses only, a company identifier is asked at the next step.

Team

€299 / mo

  • In plain terms: unlimited repositories for a team of 15, 750 AI checks per month.
  • SSO / SAML and RBAC
  • Priority analysis queue
  • Extra validation at €0.30 (pay-as-you-go)
Subscribe

For businesses only, a company identifier is asked at the next step.

Enterprise

On request

  • In plain terms: the validation volume and deployment mode you set in the contract.
  • SSO / SAML / SCIM, audit logs
  • Self-hosted runner, dedicated deployment
  • GDPR-compliant DPA, exports and evidence usable in an ISO 27001 or SOC 2 audit
  • Coupling with own2pwn pentests and EASM
Talk to an expert

VAT not applicable (art. 293 B of the French tax code)

How it works

From setup to the first alert.

  1. 01

    1. You connect your repository

    GitHub via the GitHub App, GitLab via OAuth or token. Read-only access, scope limited to the repositories you tick. No fork, no commit pushed into your code without your action. Data deletion on request, encryption at rest.

  2. 02

    2. Taint follows your data flows

    Tree-sitter spots the sensitive sinks, the taint engine walks the source to sink chain, inside a file then across files and modules. The deterministic pre-pass discards unreachable or already sanitized cases before calling the LLM. Every finding shows its full taint chain: you see why it was flagged, not an opaque verdict.

  3. 03

    3. The agent decides exploitability

    A LangGraph agent re-reads the code around each candidate with AST inspection tools, confirms the real cases, kills the false positives and ranks what remains by real exploitability. The scan runs on every push or pull request and on a cron schedule, so static coverage does not stop between two pentests.

  4. 04

    4. Report, remediation and CI/CD

    Editable HTML report with explanation and remediation, native SARIF export for GitHub Code Scanning, PR or MR comments, Slack alerts, webhook or email. The GitHub Action sets a configurable severity gate in your pipeline. GitLab, Jenkins and self-hosted runners go through the secai CLI. Final human verification remains the business of our OSWE pentests, a separate offering.

Benefits

What the data path changes for your developers.

01

A SAST that stops drowning devs

The pre-pass runs deterministically first: tree-sitter spots the sinks, the taint engine walks the source to sanitizer to sink chain. Anything with no attackable source or already sanitized is discarded before the slightest model call. Only the cases that survive go to the LLM verifier, which triages them to cut false positives. Your developers see the full data chain in the interface, not an opaque verdict, and stop closing tickets as won't fix.

02

Context decides, not the pattern

A pattern-based SAST does not know whether the input is really attacker-controlled, nor whether a sanitization step neutralises it along the way: it flags, you triage by hand. Here, the agent reads the code around the finding, follows the data and decides exploitability. Two identical lines get two different verdicts if the context differs. That is what drops the noise: the decision is about the real flow, not a regex.

03

From finding to fix, without switching tools

Every finding is ready to handle: visible taint chain, plain explanation, proposed remediation. When the fix is applicable, SecAI opens a PR or an MR directly, otherwise it drops a patch. Editable HTML report, Code Scanning-compatible SARIF export, Slack, webhook or email notifications: everything comes out of the same place, without stacking three tools that don't talk to each other.

Overview

The platform in pictures.

List of SAST, IAC, secrets and SCA findings on real repositories, with severities and the Verified by pattern + agent badgeSAST, IAC, secrets and SCA findings on real repositories, sorted by severity. The Verified by pattern + agent badge marks the ones an agent cross-checked.
Detail of a critical SAST finding (CWE, high CVSS) with triage, Evidence, Summary and Root causeA critical finding in detail: CWE, CVSS, Evidence, summary and root cause. Enough to fix it without reopening the code blind.
Taint analysis from source to sink (SOURCE req.body to SINK eval) with exploitable-candidate verdict and CVSS vectorTaint tracking from SOURCE req.body to SINK eval, exploitable-candidate verdict, detailed CVSS vector. The data path, not just a highlighted line.
Connected repositories with the count of open findings and scans per repositoryConnected repositories, with their open findings and scans. You spot right away which one carries the most debt.

Why own2pwn

Why we follow the flow rather than a pattern.

AI to triage, not to chat

The pre-pass is deterministic: tree-sitter spots the sinks, the taint engine walks the data flow to its destination. This step consumes no validation and discards cases with no source or already sanitized before any model call. Only the candidates that survive go to the LLM verifier, which kills the false positives. No chatbot, no opaque verdict: every finding shows its taint chain, so the reason for the flag.

Prioritised by what an attacker reaches

A useful SAST does not hand back a list sorted by theoretical severity. The agent decides exploitability from the code: what is reachable, what is chainable, what gets neutralised along the way. The ranking starts there, not from an isolated CVSS. You spend less time triaging and more time fixing what actually matters.

Built by an OSWE pentester

This SAST does not come out of a data team. The detection and prioritisation logic comes from real exploitation: what an attacker actually reaches, what deserves a fix, what can be deduced from the code alone. The OSWE certification is precisely about exploiting white-box application vulnerabilities, exactly where SAST plays out.

Hosted in the European Union

Your code is stored in the EU (Germany), encrypted at rest, with GDPR purge on request. For analysis, it is sent to Anthropic's Claude models served through Google Cloud Vertex AI in a European region: neither Google nor Anthropic uses your data to train their models. A CISO keeps a clear processing chain to document, without a three-week legal review.

Frequently asked questions

Your questions about AI-native static analysis.

How do you reduce SAST false positives?

In two stages. First a deterministic pre-pass discards anything with no attackable source or that passes through a sanitization step: those cases never reach the model and consume no validation. Then, on the candidates that survive, an LLM agent re-reads the code around the finding with AST inspection tools and decides real exploitability. A pattern-based SAST flags the line; we follow the data flow and look at the context. Two identical lines can get two different verdicts if one is reachable and the other is not. The result: whatever lands in your backlog has survived a deterministic filter then a contextual verification, not just a regex.

How does the contextual SAST work, concretely?

Two stages. First a deterministic pre-pass: tree-sitter spots the sensitive sinks, then a taint engine walks the data flow from its source to the sink, across the functions and files of the repository. Anything with no attackable source or that passes through a sanitization step is rejected right away, without consuming a validation. Only plausible chains survive, and they then go to verification. Every finding shows its full taint chain (source, intermediate steps, sink): you see why it surfaced, not an opaque verdict.

What does taint tracking add over a pattern-based SAST?

A pattern-based SAST often stops at the file and the line: it spots a suspicious code shape without knowing whether the input is really attacker-controlled, nor whether a sanitization step neutralises it further down. Taint tracking links the source to the sink across functions and files, so it reasons about the real data flow. That is what tells a genuine injection apart from a dead case, and drops the noise instead of stacking alerts nobody triages.

Which languages are covered in depth?

We cover 19 languages with a taint engine (tree-sitter grammar plus a flow walker), 14 of them in depth: sources, sanitizers and sink rules across several vulnerability classes. The most mature are Python, JavaScript/TypeScript and Java, followed by Go, PHP, Ruby and Kotlin, then C, C++, C#, Rust, Swift, Scala and Bash. Five languages (Dart, Lua, Perl, PowerShell, R) are parsed but limited to injection and path traversal, with no sanitizers: light support, which we label as such rather than oversell uniform coverage. If your stack is not in the list, write to us: we scope the perimeter before committing to anything.

Does the AI agent run my application?

No. This is static analysis: SecAI reads your code, it does not run it. The LangGraph agent re-reads the code findings with AST inspection tools to discard false positives, but it does not do DAST, does not execute your application and does not replay a pentest against a live target. No runtime, so no risk to your production. Coverage between two human audits comes from continuous static analysis, triggered on every commit or pull request and via cron-scheduled scans.

How is it different from Snyk, Semgrep, CodeQL or Checkmarx?

Classic pattern-based SAST often stops at the file and drowns the team in noise. Here, multi-file taint tracking walks the real data flow, and an AI verifier decides exploitability to kill part of the false positives before they land in your backlog. We're less exhaustive than the incumbents on exotic languages; our focus is elsewhere: triage, exploitability and readable remediation. And above all, this SAST fits a pentester's logic: it extends coverage, the human keeps the final decision.

Can I edit and export the reports?

Yes. Each scan produces an editable HTML report (you adjust, comment, remove what does not concern you) and a SARIF export (server and CLI) that integrates directly into GitHub Code Scanning. The results are also pushed to where your team works: PR/MR comments, Slack, webhook, email. If you stop, you export your reports and your data is deletable on request via the GDPR purge routes.

Does this SAST replace my human pentest?

No, and that's not the goal. Static analysis provides continuous coverage between two engagements, where your code moves on every deploy. Human verification remains our pentest offering, separate, run by an OSWE-certified pentester. The report even states it explicitly: findings must be reviewed by a professional. The SAST and the own2pwn pentest complement each other, they don't substitute for one another.

Is there a minimum term, and how do I cancel?

No minimum term. The subscription is monthly or annual (annual works out at ten months paid), renewed tacitly at each due date, and you cancel it at any time, with no justification to give: either you do it yourself from your billing area, or you write to contact@own2pwn.fr and the answer comes within 24 hours. No notice period to serve: cancellation takes effect at the end of the current billing period, and you keep access until then. In return, that period is not refunded pro rata. That is not a sales promise, it is article 7 of the terms of sale.

Do I need a credit card for the free plan?

No. The Starter plan opens from the sign-up form, with no payment method: no card to enter, no counter starting after fourteen days. It is not a trial but a free plan with no time limit and its own quotas (2 repositories, 20 AI checks per month, 10 scans per day). The SAST module is included in it, not sold separately. A card only comes into play if you move to a paid plan, and payment happens on own2pwn.fr, by card only.

How long between payment and actual access?

Access opens immediately after the payment is validated. In practice: as soon as the payment is confirmed, the subscription is attached to your account and the plan quotas apply, with no manual step in between. If you subscribe without an own2pwn account yet, the payment creates one and you get an email to set your password: access is live as soon as that is done. If anything gets stuck, write to contact@own2pwn.fr, the answer comes within 24 hours.

Can I change plan mid-subscription?

Yes, and without starting over: the account, the connected repositories and the scan history stay in place, only the quotas change. Modules are never billed separately: SAST comes with the SecAI subscription, so changing plan moves the quotas of every module at once. You request the change by email to contact@own2pwn.fr, stating the plan you want and the date it should take effect; the answer comes within 24 hours. What is settled on the billing side is that the period already paid for is not refunded pro rata (article 7 of the terms of sale); the exact amount and the effective date of the new plan are confirmed to you in writing before anything is validated.

What exactly does a developer see on a finding?

Every finding comes with its taint chain, a plain-language explanation of the flaw and a concrete remediation. On applicable cases, SecAI can open a PR (GitHub) or an MR (GitLab) that applies the fix in place, or drop a patch in .secai/fixes/. The fix goes through your usual review before merge, nothing is applied behind your back.

Go further

SAST, DAST, IAST: the comparison

Three ways to hunt application flaws, and what AI changes.

Read →

SAST and DAST in CI/CD

The DevSecOps guide to wiring analysis into the pipeline.

Read →

Vibe coding and security

Coding on vibes with AI: the security blind spots it introduces.

Read →

Want to connect a read-only repository?

The product is in pre-launch: ask for early access. For a hands-on code audit, a reply lands within 24 hours.

Book a demoWrite to us