Final release preparation / Early August 2026
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 powers aud query,
aud explain, and aud impact also
drives broad polyglot security analysis from the same indexed truth.
$ aud taint --severity critical [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.
# Run `aud chain-analyze` for multi-step exploitable paths. 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.
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.
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.
Polyglot support
13 languages. Five capability axes. Zero second-class citizens.
Every supported language has full semantic extraction with dedicated taint pattern registries, graph strategies, and rule packs, adding up to 267 rules across 230 files (~700 individual checks). Parity is enforced: if it's listed, it works.
Python
TypeScript / JavaScript
Java
Go
Rust
PHP
Ruby
Bash
Vue
Svelte / SvelteKit
GitHub Actions
Terraform / HCL
AWS CDK
| Language | Indexing | Taint | CFG | Call Graph | Rules |
|---|---|---|---|---|---|
| Python | Full | Full | Full | Full | Full |
| TypeScript / JavaScript | Full | Full | Full | Full | Full |
| Java | Full | Full | Full | Full | 10 rule files |
| Go | Full | Full | Full | Full | 9 rule files |
| Rust | Full | Full | n/a | Full | 11 rule files |
| PHP | Full | Full | n/a | Full | 25 rule files |
| Ruby | Full | Full | Full | n/a | 20 rule files |
| Bash | Full | Full | Full | n/a | 5 rule files |
| Vue | Full | Full | n/a | Component Tree | 6 rule files |
| Svelte / SvelteKit | Full | Full | Full | Full | (via JS/TS) |
| GitHub Actions | Full | Full | n/a | n/a | 9 rule files |
| Terraform / HCL | Full | Full | n/a | n/a | 1 rule file |
| AWS CDK | Full | Full | n/a | Via JS/TS | (via JS/TS + infra) |
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
aud fce --threshold 3 # Files where 3+ vectors converge 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
~1,520 lines
HTTP, DOM, Node.js, React, Express, GraphQL, CORS
Python
~1,100 lines
Django, Flask, FastAPI, SQLAlchemy, subprocess, Celery
Go
~680 lines
net/http, Chi, stdlib, database/sql, os/exec
Rust
~660 lines
Actix, Rocket, Tokio, std::process, diesel
Java
~530 lines
Spring Boot, Hibernate, JNDI, SpEL, LDAP, XXE, deserialization
PHP
~500 lines
Laravel, Symfony, WordPress, superglobals, PDO, unserialize
Ruby
~340 lines
Rails, Sinatra, ActiveRecord, system/exec, Marshal/YAML deserialization
Bash
~400 lines
curl/wget, eval, source, pipes, env vars
| Language | Patterns | Coverage |
|---|---|---|
| JavaScript / TypeScript | ~1,520 lines | HTTP, DOM, Node.js, React, Express, GraphQL, CORS |
| Python | ~1,100 lines | Django, Flask, FastAPI, SQLAlchemy, subprocess, Celery |
| Go | ~680 lines | net/http, Chi, stdlib, database/sql, os/exec |
| Rust | ~660 lines | Actix, Rocket, Tokio, std::process, diesel |
| Java | ~530 lines | Spring Boot, Hibernate, JNDI, SpEL, LDAP, XXE, deserialization |
| PHP | ~500 lines | Laravel, Symfony, WordPress, superglobals, PDO, unserialize |
| Ruby | ~340 lines | Rails, Sinatra, ActiveRecord, system/exec, Marshal/YAML deserialization |
| Bash | ~400 lines | curl/wget, eval, source, pipes, env vars |
Vulnerability classes detected
Run aud chain-analyze to correlate
findings into multi-step exploitable attack chains.
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.
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
aud eidl baseline --version v1.0.0 # Establish known-good baseline Framework-Aware Detection
21 frameworks, understood natively.
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.
Infrastructure Coverage
Most SAST tools stop at application code. We track taint across infrastructure boundaries.
Terraform / HCL
Full structuralDedicated HCL extractor. Full structural fidelity. Taint tracks across module boundaries, variable interpolations, and tfvars files. AWS / GCP / Azure resource graphs.
AWS CDK
Full semanticRoutes 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 structuralYAML extractor with workflow graph. 9 rule files for unpinned actions, secrets-in-logs, fork-PR escalation, 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-transport MCP server (aud-mcp),
launched per-session by your AI host (Claude Code, Cursor, Codex).
Read-heavy workflows stay local and return bounded, task-specific context.
aud setup-mcp wires the server into
compatible agent hosts and can install context-aware workflow hooks.
# Index locally. $ cd your-project $ aud full --offline # Ask focused questions instead of rereading files. $ aud query --symbol AuthService
$ aud impact --symbol AuthService
# Wire the MCP server into a compatible agent host. $ aud setup-mcp [ok] MCP configuration ready
Restart the agent session to activate. 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_session AI session efficiency: planning vs. working vs. research ratios, token usage from session logs.
aud_reindex Database update after edits. Auto-picks full online refresh (>2d old) or fast incremental.
aud_analytics Token-waste analysis: how many file reads could be replaced by aud_explain, with savings estimate.
Internal evaluation result
Selected query-first agent workflows used roughly 87% fewer tokens than file-reading baselines.
Measured on internal benchmarks and evaluations. Results vary by task and query type. Independent field validation begins after release.
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.
TheAuditor
Don't let agents guess about your code.
you are hereWarden
Keep AI coding work visible across supported providers.
wardenclient.com →Arbiter
The command center for your AI operation.
arbitermcp.com →Curator
Don't let agents guess about you.
curatormcp.com →BenchProctor
A public SAST benchmark built to resist label leakage.
benchproctor.com →Final release preparation
TheAuditor is measured in days now.
Public availability is planned for early August 2026. Get one email when the official release is live.