> TheAuditor

Final release preparation

Deterministic Code Context & Advanced Polyglot SAST for AI Agents.

A database-first platform that indexes your entire codebase into queryable, deterministic facts, giving AI agents ground truth instead of guesswork. The same deep analysis that answers your agent's questions through the MCP server (who calls this, what breaks if it changes, where this value goes) also drives broad polyglot security analysis from the same indexed truth.

findings, through the MCP server
 # Your agent asks for the critical findings. [CRITICAL] SQL Injection in src/api/users.py:42
Source: user_input (HTTP body)
src/middleware/parse.py:18
Sink: cursor.execute()
           src/db/query.py:67
Path: 8 hops across 3 files
[CRITICAL] Command Injection in src/upload/handler.go:88
Source: query.Get("filename")
Sink: exec.Command(filename, ...)
Path: 3 hops, no sanitization
[CRITICAL] XXE in src/parsers/xml.java:124
Source: request.getInputStream()
Sink: DocumentBuilder.parse()
Path: 4 hops, framework: Spring Boot
3 critical issues across a polyglot codebase.
# Ask where a value goes before you edit the code around it. 

The three problems we solve

Different problem. Different architecture.

PROBLEM 01

LLMs guess relationships from raw code.

We return verified facts from indexed data.

Standard AI agents read 5,000 lines of source to infer call graphs. TheAuditor returns the call graph from a sub-millisecond database query. No inference. No guessing. The same answer every time.

PROBLEM 02

Tools re-parse files for every query.

We index once, query in milliseconds.

Most SAST tools rebuild the AST on every run. TheAuditor indexes incrementally into SQLite, then answers every question about symbols, callers, callees, data flows, and framework boundaries straight from the database. Cross-tool correlation comes free.

PROBLEM 03

Single-dimension analysis misses real risks.

Four independent vectors converge.

Static linters miss runtime risk. Churn metrics miss vulnerability patterns. Taint trackers miss complexity. We fuse all four (STATIC, STRUCTURAL, PROCESS, FLOW) into a Four-Vector Convergence Engine that surfaces the files where three or more independent signals agree.

Architecture

Custom compilers, not generic parsers.

TheAuditor's analysis accuracy comes from deep compiler integrations, not generic parsing. Each language gets the right tool for the job.

Python

Framework-aware semantic analysis

Understands how Django, Flask, FastAPI, Celery, Pydantic, and 100+ framework patterns actually behave, rather than leaning on regexes or generic tree walks. Security and data-flow analysis run with that framework context, so findings reflect real execution paths.

Framework-aware Full data flow No code execution

JavaScript / TypeScript

IDE-grade type resolution

Real type-aware analysis across complex import graphs, JSX/TSX, tsconfig path aliases, and Vue SFCs, with the same depth of understanding your editor has. It goes past tree-sitter and pattern matching.

Type-aware Monorepo-aware JSX / TSX / Vue

Java

Compiler frontend, no execution

The same proven approach as PMD, SpotBugs, and SonarQube: compiler-frontend analysis with full type resolution, no bytecode generation, and no code execution. Build-system aware for an accurate classpath. Never guesses, never relies on heuristics.

Full type resolution Build-aware No code execution

Polyglot support

10 languages. Zero second-class citizens.

TheAuditor supports 10 languages: Python, TypeScript, JavaScript, Go, Rust, Bash, Java, PHP, Ruby and C, plus Solidity for smart contracts. The table shows the main ones, with the frameworks and infrastructure formats analyzed through them. Security checks run as dynamic rules queries built on cwe+lang+frame+cloud+category. Parity is enforced: if it's listed, it works.

Python

Indexing Full Taint Full CFG Full Call Graph Full

TypeScript / JavaScript

Indexing Full Taint Full CFG Full Call Graph Full

Java

Indexing Full Taint Full CFG Full Call Graph Full

Go

Indexing Full Taint Full CFG Full Call Graph Full

Rust

Indexing Full Taint Full CFG n/a Call Graph Full

PHP

Indexing Full Taint Full CFG n/a Call Graph Full

Ruby

Indexing Full Taint Full CFG Full Call Graph n/a

Bash

Indexing Full Taint Full CFG Full Call Graph n/a

Vue

Indexing Full Taint Full CFG n/a Call Graph Component Tree

Svelte / SvelteKit

Indexing Full Taint Full CFG Full Call Graph Full

GitHub Actions

Indexing Full Taint Full CFG n/a Call Graph n/a

Terraform / HCL

Indexing Full Taint Full CFG n/a Call Graph n/a

AWS CDK

Indexing Full Taint Full CFG n/a Call Graph Via JS/TS

Four-Vector Convergence Engine

When three or more independent vectors agree, confidence is exponentially higher.

The FCE identifies high-risk code by finding where multiple independent analysis vectors converge. Most tools have one signal. We have four, and we measure agreement across all of them.

STATIC

Linters

ESLint, Ruff, Clippy

Code quality issues

STRUCTURAL

Code complexity

Cyclomatic complexity

Structural risk

PROCESS

Git churn

Modification history

Frequently changed code

FLOW

Taint propagation

Source→sink taint

Data flow vulnerabilities

Convergence runs as part of every full analysis (aud full).

Taint Analysis

Source-to-sink tracking across 8 languages with dedicated pattern registries.

Source-to-sink interprocedural analysis. Each language gets its own registry of sources, sinks, and sanitizers, tuned by hand. Cross-language patterns (HTTP clients, env vars, file I/O) live in a shared polyglot registry.

JavaScript / TypeScript

HTTP, DOM, Node.js, React, Express, GraphQL, CORS

Python

Django, Flask, FastAPI, SQLAlchemy, subprocess, Celery

Go

net/http, Chi, stdlib, database/sql, os/exec

Rust

Actix, Rocket, Tokio, std::process, diesel

Java

Spring Boot, Hibernate, JNDI, SpEL, LDAP, XXE, deserialization

PHP

Laravel, Symfony, WordPress, superglobals, PDO, unserialize

Ruby

Rails, Sinatra, ActiveRecord, system/exec, Marshal/YAML deserialization

Bash

curl/wget, eval, source, pipes, env vars

Vulnerability classes detected

SQL injection Command injection XSS Path traversal SSRF XXE LDAP injection Insecure deserialization Log injection SpEL injection JNDI injection (Java) Auth weakness TOCTOU Floating-point logic errors Regex DoS

Your agent reads these findings through the MCP server, alongside the code they sit in.

SAST Benchmark Results

100% True Positive Rate. 0% False Positive Rate.

Independently verifiable against the standard OWASP corpora. Methodology and per-test reproductions coming in a future blog post.

OWASP Java Benchmark
100% TPR 0% FPR
11/11 vulnerability categories perfect
OWASP Python Benchmark
100% TPR 0% FPR
All categories perfect
OWASP Juice Shop (Node.js)
100% TPR 0% FPR
31/31 true positives, 0 false positives

Evasion Detection

Identifies code that intentionally evades static analysis.

Flags high-impact operations hidden behind suspicious conditions, and uses your git history to keep confidence high and noise low. Compare any version against a known-good baseline to surface guards that were quietly introduced.

Time & environment gates

Logic that only fires on certain dates, clocks, or CI/CD environments

Identity & fork gates

Behavior keyed to a specific repository, package, or fork

Unjustified constant guards

High-impact operations hidden behind hardcoded constants with no real reason

Baseline deviations

New guards or control flow that did not exist in a known-good version

Over- or under-broad conditions

Catch-all wildcards or hyper-specific checks that smell like targeting

Framework-Aware Detection

138 frameworks, pinned by a frozen test.

This goes well past pattern-matching on import names. Each framework is understood on its own terms, covering Django signals, Flask routes, Celery tasks, Pydantic validators, Spring Boot annotations, Hibernate entities, Laravel middleware, and Express handlers, so taint and rules can reason about framework-specific semantics.

Django Flask FastAPI Spring Boot Hibernate JAX-RS Laravel Symfony React Vue Svelte/SvelteKit Next.js Express Angular SQLAlchemy Prisma Sequelize TypeORM Celery

Infrastructure Coverage

Most SAST tools stop at application code. We track taint across infrastructure boundaries.

TheAuditor covers 12 infrastructure-as-code substrates. Three of them, up close:

Terraform / HCL

Full structural

Terraform and HCL are read natively, with their full structure. Taint tracks across module boundaries, variable interpolations, and tfvars files. AWS / GCP / Azure resource graphs.

AWS CDK

Full semantic

Routes through JS/TS engine plus dedicated construct analysis. L1/L2/L3 constructs traced into the synthesized CloudFormation graph. Security groups, IAM policies, S3 ACLs analyzed at the source.

GitHub Actions

Full structural

Workflows are read as a graph, with checks for unpinned actions, secrets in logs, fork pull request escalation, and environment misuse. The CI/CD attack surface is no longer a blind spot.

AI Agent Integration via MCP

Focused Model Context Protocol tools. Queryable code truth for agent workflows.

TheAuditor ships a stdio MCP server (aud mcp), started per session by Claude Code or OpenAI Codex. Read-heavy workflows stay local and return bounded, task-specific context. aud setup-mcp connects it to either one, works before the first analysis, and keeps your own permissions in place. By default your agent sees one lookup tool and a status tool; the full set of single-purpose tools is one setup option away.

release workflow preview
 # Index locally. $ cd your-project $ aud full --offline # Connect your agent: Claude Code, or --client codex. $ aud setup-mcp [ok] MCP configuration ready
Restart the agent session to activate. # Your agent now asks focused questions # instead of rereading files. 
aud

Default. One lookup tool for the questions that replace reading files: who calls this, what a file declares, where a value goes, what depends on a module.

aud_status

Default. Whether the analysis of this project is current, and the progress of any update that is running.

aud_explain

Full context bundle: symbols, callers, callees, deps, findings, taint flow summary. Use before editing a file.

aud_query

Lightweight lookup: list file symbols, find callers/callees, search by pattern, check imports.

aud_findings

Security findings by bucket: exploitable (taint-confirmed), chains, security (patterns/CVEs), code intelligence.

aud_impact

Blast-radius analysis: upstream/downstream dependencies, coupling score, risk level. Use before refactoring.

aud_blueprint

Project architecture overview: languages, frameworks, entry points, security surface, data flow.

aud_export_sarif

Export the project findings as a SARIF 2.1.0 file, with code flows on tiers that include taint.

Query-first by design

Your agent asks for the answer and gets the answer, not the whole file around it.

Every answer comes from stored facts and says when it was cut short.

The ecosystem

Better alone. Unfair together.

Five focused tools for shipping with AI agents. Each stands on its own; together they cover code, action, orchestration, memory, and proof.

Newsletter

One email when something real ships.

The Code Reality Labs newsletter covers launches and major releases of TheAuditor, Warden, Arbiter, Curator and BenchProctor. Nothing in between.

Our newsletter service, Buttondown, opens in a new tab and sends one email to confirm. Every email has an unsubscribe link. Newsletter privacy