Open-source semantic SAST engine

Find real vulnerabilities in AI-written code.

Local, deterministic, MCP-native. Trace tainted data across functions, files, and frameworks — from your terminal, your CI, your product, or Claude's tools. No server, no phone-home, no LLM tokens burned per scan.

See where Cognium runs View on GitHub

$ npm install -g cognium-dev

AuthController.java

String id = req.getParameter("id");

source: HTTP parameter

String q = "SELECT * WHERE id=" + id;

taint: full propagation

stmt.execute(q);

sink: SQL execution

CWE-89 SQL Injection Critical - line 25

CLI cognium-dev Library circle-ir Browser circle-ir/browser MCP @cognium/mcp-server

100 %

OWASP · Synthetic

Upstream fixes shipped

Languages

CWE types

Analysis model

Built around data flow, not pattern matching.

Traditional scanners match dangerous text. Cognium builds a flow graph, follows values through the program, and only reports when tainted input reaches a sensitive sink without a sanitizer.

01 · Source detection

HTTP parameters, headers, cookies, file uploads, environment variables, CLI args, and framework-specific request objects.

02 · Inter-procedural tracking

Flows are followed across function calls, return values, object fields, map keys, array indexes, conditionals, and common framework abstractions.

03 · Sanitizer aware

Prepared statements, HTML escaping, URL validation, framework encoders, and custom YAML definitions reduce noise without hiding risk.

Published evidence

Benchmarks with artifacts you can inspect.

The figures below are from the April 22, 2026 static-only snapshot. Machine-readable results are published for independent review; the static engine runs without an LLM.

OWASP Benchmark v1.2 · synthetic

100%

Juliet Test Suite · synthetic

156/156

SecuriBench Micro · real-world

97.7%

CWE-Bench-Java · real-world

50.8%

CWE-Bench-Java · static-only detection real-world

Cognium (static)     50.8%   61 / 120 CVEs
IRIS + GPT-4         45.8%   55 / 120 CVEs
CodeQL               22.5%   27 / 120 CVEs

Dated static-only snapshot; public result artifacts available.

Open full benchmark page Read benchmark research

Coverage

Framework-aware rules across the stack.

Cognium ships with source, sink, and sanitizer definitions for popular server frameworks, plus YAML configuration for teams adding their own architecture patterns.

Java

Spring, JAX-RS, Servlet

JavaScript

Express, Fastify, Koa

TypeScript

Express, Fastify, Koa

Python

Flask, Django, FastAPI

net/http, Gin, Echo

Rust

Actix-web, Rocket, Axum

Bash

Shell scripts

HTML

Security attributes

C# / .NET

ASP.NET Core, ADO.NET, EF Core Preview

CWE classes

The high-risk paths AI agents keep getting wrong.

SQL injection, command injection, XSS, path traversal, SSRF, deserialization, XXE, LDAP injection, NoSQL injection, response splitting, weak randomness, weak crypto, and more.

View all CWE rules

CWE-89 · SQL Injection

Tainted data flowing into SQL queries without parameterization.

CWE-78 · Command Injection

Unsanitized user input passed to OS command executors.

CWE-79 · Cross-Site Scripting

Reflected or stored tainted content rendered in browsers without escaping.

CWE-22 · Path Traversal

User-controlled paths reaching file system operations without normalization.

CWE-918 · SSRF

Server-side request forgery from tainted URLs in HTTP client calls.

CWE-502 · Deserialization

Untrusted data passed to object deserialization sinks.

Where to use it

One engine. Every surface a developer works on.

The cogniumhq/cognium-dev monorepo ships the cognium-dev CLI, the circle-ir Node/browser library, and the @cognium/mcp-server package — so the same deterministic engine runs from your terminal, inside your product, or as a tool your AI agent can call.

Terminal CLI

Global install, scan a folder, get findings back. The fastest way to try it on your own repo.

npm i -g cognium-dev
cognium-dev scan ./src

Node / TS library

Embed the circle-ir package inside your own product, service, or agent framework — the same engine used by the CLI, called programmatically.

import { initAnalyzer, analyze } from 'circle-ir';

await initAnalyzer();
const result = await analyze(code, 'app.ts', 'typescript');

Browser web build

The circle-ir/browser export runs the engine in the browser — power web IDEs, code playgrounds, or client-side review tools without a server.

import { init, analyzeCode } from 'circle-ir/browser';

await init({
  wasmUrl: '/wasm/web-tree-sitter.wasm',
  languageUrls: {
    typescript: '/wasm/tree-sitter-typescript.wasm'
  }
});
const result = await analyzeCode(code, {
  filePath: 'app.ts',
  language: 'typescript'
});

AI agents MCP

Give Claude Code or Cursor a first-class scan tool. One-line install, eleven deterministic MCP tools ready to call.

claude mcp add cognium -- \
  npx -y @cognium/mcp-server

GitHub Actions CI

Run the current public composite action, emit SARIF, and upload it to GitHub Code Scanning. Grant the workflow security-events: write; no service account is required. View the public action definition.

permissions:
  contents: read
  security-events: write

steps:
  - uses: actions/checkout@v7
  - uses: cogniumhq/cognium-dev/packages/cli@main
    with:
      path: ./src
      version: latest
      format: sarif
      output: cognium-results.sarif

Pre-commit hook git

After installing the CLI, catch obvious taint flows before code leaves the developer's machine.

repos:
  - repo: local
    hooks:
      - id: cognium-dev
        name: cognium-dev scan
        entry: cognium-dev scan
        language: system
        types: [file]
        pass_filenames: false

Everywhere SARIF is read SARIF 2.1.0

Findings plug into GitHub / GitLab code scanning, DefectDojo, VS Code SARIF Viewer, and any dashboard that already reads the format.

cognium-dev scan ./src \
  --format sarif -o out.sarif

VS Code extension planned

A first-party editor extension is planned for Problems-panel findings, inline severity, and hover explanations. Follow progress in the public repository.

# planned
# ★ the repo to get notified

MCP server

SAST as a first-class AI-agent tool.

@cognium/mcp-server exposes the deterministic cognium-dev pipeline as eleven Model Context Protocol tools — scan, taint paths, entry points, sink descriptions, sanitizer checks. The LLM never guesses the engine's state; it calls a tool and gets a grounded answer.

scan Full polyglot SAST on a file or directory. Returns findings, taint flows, cross-file paths.

taint_paths Cross-file taint flows, filterable by source, sink, or sink type.

explain_finding CWE metadata, remediation, severity, sanitizer suggestions for one finding.

list_entry_points Every attacker-reachable handler grouped by framework.

list_reachable_sinks Sinks of a category that have a real taint flow reaching them.

attack_surface_summary Roll-up: entry points × sinks × cross-file paths + top files by finding count.

check_sanitizer Deterministic yes/no on whether a function sanitizes for a given sink category.

describe_sink CWE, remediation, severity, and sanitizer list for a sink category.

describe_source Framework API patterns treated as a source of a category.

find_similar Given a finding id, return other findings sharing the same rule or sink type.

refresh Invalidate the cached analysis for one project or every project.

Server docs Claude / Cursor config

Looking for more agent tools? Browse SkillsRegistry and inspect available trust information.

~/.config/claude/mcp.json

{
  "mcpServers": {
    "cognium": {
      "command": "npx",
      "args": ["-y", "@cognium/mcp-server"]
    }
  }
}

Get started

Install once. Scan anywhere.

Local, in pre-commit hooks, or in CI. SARIF output plugs into GitHub code scanning and every review workflow that already reads the format.

Read tutorials Open Community

terminal

$ npm install -g cognium-dev
$ cognium-dev scan ./src

src/controllers/AuthController.java
  [!!!] sql_injection (Critical) [CWE-89]
      Line 45: sql_injection vulnerability:
      tainted data flows from line 12 to line 45
      → Fix: Use PreparedStatement with parameterized
        queries instead of string concatenation

Found 1 security finding(s) in 1 file(s)

Cognium Ecosystem

Start open source. Explore the Cognium Ecosystem.

Scan code locally with Cognium Dev. Explore related tools for software verification and validation, agent-skill discovery, and structured specifications.

Open source · Code security

Cognium Dev

Open-source semantic security analysis for your code, terminal, CI, and AI agents.

Start your first scan

Verification & Validation

Cognium

Verify and validate software behavior against requirements, with supporting evidence for each finding.

Explore verification & validation

Agent skills

SkillsRegistry

Discover agent skills and inspect their available security and trust information.

Browse agent skills

Open format

Specifica

Keep requirements, design decisions, and tasks together in version-controlled Markdown.

Explore the format

Open source · MIT licensed

Help make AI-generated code trustworthy.

Contribute framework definitions, benchmark cases, editor integrations, and CI examples. MIT licensed and built in the open — jump into the community hub or head straight to Discussions.

Planning a contribution? Organize requirements and implementation plans with Specifica.

Open Community Join Discussions Star on GitHub