Skip to content
OpenTaint

Continuous, lean, and agentic application security testing

Turn frontier model reasoning into reliable static-analysis checks to detect vulnerabilities at low cost

InstallCVE study

Model reasoning finds new vulnerabilities. Formal program analysis searches for every match.

The open source taint analysis engine for the AI era

AGENTIC / DISCOVER

The flexibility of
model reasoning

Find new vulnerabilities and show which ones matter

LEARNS NEW VULNERABILITY PATTERNSFinds vulnerabilities that existing checks miss.
SHOWS WHICH FINDINGS CAN CAUSE HARMUses architecture, trust boundaries, and intended behavior.
FOLLOWS RISK THROUGH DEPENDENCIESFinds vulnerable paths across frameworks, libraries, and APIs.
CONTINUOUS / SCAN

The consistency of
formal program analysis

Find every instance of a known vulnerability pattern

COVERS EVERY MODELED PATHChecks the full program model instead of a sample.
REPRODUCES EVERY RESULTThe same code and rule produce the same findings.
RUNS ON HARDWARE YOU CONTROLRun unlimited scans at CPU cost and keep sensitive code private.
LEAN / ENACT

Turn one vulnerability into a formal check that searches the full codebase for every match

Code

@PostMapping("/preview")
String preview(String template) {
  var decoded = URLDecoder.decode(template);
  var view = decoded.strip();
  return engine.process(view, context);
}
Dependency models 
- function: java.net.URLDecoder#decode
  copy:
  - from: arg(0)
    to: result
- function: java.lang.String#strip
  copy:
  - from: this
    to: result

Taint rule

pattern: |
  $METHOD(..., String $UNTRUSTED, ...) {
    ...
    $ENGINE.process($UNTRUSTED, ...);
  }
$ENGINE=engine $UNTRUSTED=template $METHOD=preview
template$UNTRUSTED URLDecoder.decode()returns decoded strip()returns view engine.process()receives view

Find vulnerabilities LLMs miss using only local compute

Practical SOTA static analysis

Minimize missed findings and false alarms without making whole-project analysis impractical.

Open source, batteries included

Engine, rules, models, agent skills, CLI, viewer, and CI integrations — all open source and built to work together.

Turn one-off security review into unlimited scans

Discover

Discover trust boundaries andvulnerability patterns.

Enact

Enact security knowledge asrules and dependency models.

Scan

Search the whole project with formal program analysis.

Triage

Confirm findings and tune away false alarms.

First agentic scan

Scan your project in five minutes

01

Install OpenTaint

npm install -g @seqra/opentaint
02

Install the OpenTaint agent skills

npx skills add https://github.com/seqra/opentaint
03

Ask your agent to start a security scan

Run deep security scan and static triage with OpenTaint appsec-agent skill

As AI generates more code, security risk and review cost compound

Application security is the new tech debt

01 / Generated code

Would you notice the agent slipping a vulnerability into code you never reviewed?

44% of AI-generated solutions contained a known security flaw
Veracode 2026

02 / Exploitation

How long will you keep betting nobody will bother to exploit your code?

from 5% to 31% breaches beginning with vulnerability exploitation

Vulnerability exploitation became the leading breach entry point for the first time in 19 years.

5% 2023 14% 2024 20% 2025 31% 2026
Verizon DBIR 2026

03 / Repeatability

Will tomorrow’s security review catch what today’s review found?

14% of LLM-only findings recurred in all five runs on the same code and prompt

These were reported issues outside the deterministic reference set, not independently confirmed vulnerabilities.

REVIEW 1REVIEW 2REVIEW 3REVIEW 4REVIEW 5 ALL FIVE
Snyk VulnBench

04 / Model cost

How much money will you waste on reviewing the same parts of your application?

$20K spent across 1,000 security reviews
ONE SECURITY REVIEW CRITICAL BUG FOUND
Anthropic Mythos

A real-world review

How OpenTaint found critical CVE-2026-58138

Read the detailed case study
Reported finding
Open the report

Every finding opens to the flow that produced it.

Reported taint trace

  1. Source HTTP request Unauthenticated workflow input
  2. Step Task scheduling Across the workflow executor
  3. Step Executor lambda Captured, then run on another thread
  4. Sink Context.eval Evaluated with full host access

The complete trace spans 182 steps across the codebase.

Comparative results

See what the engine catches

Five-case comparison

Detection depth, compared

Compare Semgrep, CodeQL, and OpenTaint across five increasingly difficult Java XSS cases.

Read the comparison
XSS detection depth by tool and analysis mode across five Java test cases
Analysis depth Semgrep CodeQL OpenTaint
patterntainttaintpatterntaint
Direct return Detected Detected Detected Detected Detected
Local dataflow Missed Detected Detected Detected Detected
Inter-procedural Missed Detected Detected Detected Detected
Field sensitivity Missed Partial Partial Detected Detected
Virtual dispatch Missed Missed Partial Detected Detected

Detected Partial Missed

The agent skills

An application-security workflow

Fifteen composable skills, one workflow

AppSec Agent builds and scans, writes rules and models, triages findings, and generates proof-of-concept checks.

Read the release post
buildsourcesscanapproximationsinkstriagevulnerabilities.mdtriagedependenciesdiscover attacksurfaceanalyzeexternalpass-throughtestskipped.yamlsinksdataflowanalyzefindingsgeneratepocdebug rulereport issuetestcreate rulejoinsourcesapproximationtriagedebugrule creationsaturation loop buildsourcesscanapproximationsinkstriagevulnerabilities.mdtriagedependenciesdiscover attacksurfaceanalyzeexternalpass-throughtestskipped.yamlsinksdataflowanalyzefindingsgeneratepocdebug rulereport issuetestcreate rulejoinsourcesapproximationtriagedebugrule creationsaturation loop

Analysis coverage

Supported languages and frameworks

Available now

Java + Kotlin
Spring

Roadmap

  • Go
  • Python
  • C#
  • JavaScript + TypeScript

FAQ

  • Taint analysis tracks data from untrusted sources to security-sensitive sinks and shows the path that can cause a vulnerability. Developers use this path to find the cause and make a precise fix for injection, path traversal, SSRF, XSS, and other data-flow vulnerabilities.
  • OpenTaint is an open source taint analysis engine that turns one security finding into a formal check for the full codebase. AST-pattern rules and dependency models store the security knowledge, and formal program analysis finds every modeled match in each scan.
  • OpenTaint runs the same vulnerability checks in pull requests and CI/CD builds, so teams can use the results as a security gate before release. GitHub Actions and GitLab CI can start the checks with the same rules and dependency models, and OpenTaint creates SARIF results for pipeline tools.
  • Yes. Developers can use the CLI to find and fix vulnerabilities before they push code, with the same engine, rules, and dependency models as CI. The same inputs produce the same findings in GitHub Actions and GitLab CI. Developers can also examine source-to-sink traces in SARIF or the report viewer and edit YAML rules locally.
  • OpenTaint detects more than 20 built-in data-flow vulnerability classes, including SQL injection, XSS, SSRF, SpEL injection, SSTI, path traversal, and command injection. OpenTaint agent skills can discover project-specific vulnerability patterns during a security review and turn them into formal checks. The engine then searches the full codebase for every match and shows the complete data-flow path. Developers use this evidence to confirm the risk and fix its cause.
  • AST-pattern rules let people and agents describe untrusted inputs, dangerous operations, and sanitizers with readable syntax similar to Semgrep and ast-grep. OpenTaint translates each AST-pattern rule into a configuration for the taint analyzer and interprets each metavariable as a taint mark on matching data. Formal program analysis then tracks the tainted data through methods, fields, asynchronous code, and persistence layers. This process lets simple rules drive deep data-flow analysis.
  • LLM agents can find new vulnerability patterns and understand application context, but repeated reviews can produce different results and use more model tokens. OpenTaint stores each learned pattern in taint rules and dependency models, then formal program analysis finds every modeled match with local compute.
  • No. Built-in rules and dependency models let OpenTaint scan a project without an agent, while optional agent skills learn application-specific patterns and add formal checks. Teams can start with standard coverage and add project knowledge when necessary.
  • OpenTaint applies the same formal checks to agent-generated and human-written code, so the author does not change the analysis. Teams can run these checks in CI before the code enters the main branch or a release.
  • Application security becomes technical debt when software changes faster than teams can review it, because unreviewed attack surfaces and unresolved vulnerabilities increase with each release. OpenTaint stores review knowledge in reusable rules and models, so later scans use this knowledge instead of repeating the same review.
  • OpenTaint supports Java and Kotlin, with deep analysis for Spring Boot, Spring MVC, and Spring Data. Bytecode analysis resolves inheritance, generics, and library calls, which helps OpenTaint follow data through application code and dependencies. The roadmap includes support for Python and Go.
  • OpenTaint follows tainted values through Spring application code, framework calls, asynchronous boundaries, and JPA persistence, with dependency models for Reactor, Spring WebFlux, and Kotlin coroutines. OpenTaint also connects stored data across requests to find long vulnerability paths that cross framework and storage boundaries.
  • Both tools use readable code patterns, but OpenTaint provides open source inter-procedural taint analysis across endpoints and persistence layers. The OpenTaint AST-pattern format supports existing Semgrep syntax, so teams can move compatible rules in stages.
  • Both tools provide inter-procedural taint analysis, but OpenTaint uses readable AST-pattern rules instead of QL queries. Developers and agents can edit these rules without QL knowledge, and OpenTaint is fully open source for public and private code.
  • Yes. The core engine uses the Apache 2.0 license, while the CLI, CI integrations, and rules use the MIT license. These licenses permit use on public, private, and commercial codebases, and OpenTaint does not charge a fee for each scan.
  • Yes, if the rule uses supported syntax. OpenTaint lets teams reuse existing rule knowledge and reduce migration work, but it also has extensions and restrictions. OpenTaint tracks metavariables across function calls, so its scans can report different findings than Semgrep.
  • Ask us on Discord