Get a Demo →

AIRA · AI Risk Analysis for code

See the risk. Fix the code. Prove it.

Self-trained AI that fixes the line — and nothing else.

AIRA scans your repositories with four detection engines, writes a patch for each finding, and tests that patch against eleven checks before you see it. Renamed variables, invented helpers, deleted statements and wrong SQL placeholders never reach your code. AIRA's own self-trained model runs on your own GPU — source code never leaves the machine.

  • Python · JS/TS · HTML · SQL
  • OWASP Top 10 2025
  • Self-trained AIRA model, run locally
  • No cloud calls
  • Air-gapped deployment
  • 11 validation checks per patch
OWASP Top 10 2025 coverage CWE mapped Air-gap ready No telemetry
app.py : 12 · get_user() High · CWE-89 SQL Injection
12− record = cur.execute(f"SELECT id, name FROM users WHERE id = {user_id}").fetchone()
12+ record = cur.execute("SELECT id, name FROM users WHERE id = ?", (user_id,)).fetchone()
13 conn.close()
14 if record is None:
15 return jsonify({"error": "not found"}), 404
16 return jsonify({"id": record[0], "name": record[1]})

One line changed. The variable keeps its name, the placeholder matches the driver, and the file still compiles.

11 / 11 checks passed · merged into the full file
4detection engines whose findings are merged into one fingerprinted finding per issue
11checks every patch must pass against the merged file before it is offered
3,000+OWASP cheat-sheet passages indexed for retrieval-augmented fixes
96%of applied fixes in our internal test suite kept every variable name and compiled cleanly
pipeline:1

From upload to merged patch in six stages

Every stage writes its result to the scan record, so you can see where a finding came from, which engines agreed, and why a fix was accepted or held back.

1 / ingest

Collect

Upload files or a ZIP up to 2 GB, or connect a GitHub repository. Archives are streamed to disk and checked for zip bombs, depth and entry count.

2 / detect

Scan

Rules, AST analysers, Semgrep and the local LLM run in a Redis-backed worker queue. You can cancel a scan or watch its progress live.

3 / fuse

Fuse

Findings from all engines are clustered by file, line proximity and evidence, then deduplicated with a stable fingerprint.

4 / fix

Patch

Deterministic fixers run first, then structural recipes, then RAG-guided LLM candidates with up to three repair rounds.

5 / verify

Validate

The patch is merged into the real file and must pass eleven checks, from syntax to a Semgrep re-scan.

6 / apply

Review

You approve a one-hunk diff. AIRA writes it, checks the file hash, and re-anchors every other finding in that file.

engines:2

Four engines look at every file

Pattern rules are fast and predictable. ASTs understand data flow. Semgrep brings community-grade rules. The LLM catches logic flaws the others miss. Each one covers gaps in the others.

OWASP Rule Engine

stage 1

Pattern matching. Each rule carries a stable id, severity, CWE and OWASP category, so findings map straight into reports.

  • Hard-coded secrets, private keys and AWS credentials
  • Debug mode, weak hashes and insecure cookies
  • Outdated jQuery and DataTables CDN scripts (CWE-1104)

AST Analysers

Babel · Acorn · Python ast

Taint-aware checks follow request data from req.query or request.args into dangerous sinks.

  • JavaScript/TypeScript and inline <script> blocks in HTML
  • Python AST analyser running as a local subprocess
  • SQL analyser for dynamic PREPARE and CONCAT, plus SQLite schema inspection

Semgrep

custom ruleset

Runs AIRA's own rule pack alongside Semgrep's engine, and runs again on every candidate patch to confirm the original rule no longer fires.

  • AIRA's own custom rule pack, kept up to date with the product
  • Baseline compared with the post-fix scan, adjusted for line shifts
  • Fails if the patch introduces a vulnerability family the file didn't have before

Local AI Review

self-trained AIRA model

Reads each file for logic-level issues pattern matching can't catch, then a revalidation pass confirms or drops each claim.

  • Trained in-house for secure-code review, served locally on port 1234 — no cloud calls
  • Truncated or empty generations are marked incomplete, never reported as "0 findings"
  • Long titles are cut down to a canonical name; the detail moves to the description

One issue, one finding

When the AST engine and Semgrep both flag line 18, you see a single finding confirmed by two engines, with a fingerprint that persists across rescans. That lets AIRA label each finding as new, persisting or resolved.

// fused finding
{ title: "SQL Injection",  cwe: "CWE-89",
  file: "app.py", line: 18,
  mergedFrom: 2, sources: ["ast", "semgrep"],
  lifecycleStatus: "Persisting",
  fingerprint: "sqli:app.py:get_user:c41f…" }
autofix:3

The cheapest correct fix wins

AIRA tries predictable transforms before asking a model. Each rung runs only if the one above could not produce a validated patch.

Tier 1

Deterministic fixers

no model call · ~1 second

Known-safe rewrites for common patterns. The SQL parameteriser understands string concatenation, f-strings, % formatting, .format() and template literals. Quotes and LIKE wildcards move into the bound parameter, and the placeholder follows your driver: ? for sqlite3 and mysql, %s for psycopg2 and PyMySQL, $1 for node-postgres.

# before
rows = db.execute("SELECT * FROM p WHERE n LIKE '%" + term + "%'")
# after: name kept, wildcard bound
rows = db.execute("SELECT * FROM p WHERE n LIKE ?", (f"%{term}%",))

Tier 2

Structural recipes

PatchEngineV2 · tree-sitter and Babel

Parser-backed recipes generate candidate patches, check them against constraints, rank them, and add any import they need, such as import ast or from markupsafe import escape, at the top of the file.

// jQuery XSS recipe
$('#out').html(msg);   →   $('#out').text(msg);
# eval recipe
value = eval(expr)   →   value = ast.literal_eval(expr)

Tier 3

RAG-guided model candidates

BGE-M3 retrieval · AIRA model · up to 3 repair rounds

The model sees the vulnerable lines, a short context window, a remediation plan and the most relevant OWASP guidance. When a candidate fails validation, the exact reason goes back to the model, for example "name is not defined anywhere in the file". A candidate identical to one already rejected stops the loop early.

<security_finding>  CWE-79 · hello.py:10
<rag_context>       XSS Prevention Cheat Sheet §3
<patch_target>      lines 10–11 (same taint block)
<repair>            UNDEFINED_NAME: name (line 10)
                    defined names include: visitor, …
deterministic

The knowledge base trusts a fixed transform, such as weak hash to SHA-256 or yaml.load to safe_load.

guided_llm

The model writes the fix, with OWASP 2025 guidance and a structured plan in the prompt.

manual_review

For design-level issues, AIRA gives a written recommendation instead of inventing code.

Benchmark: 96% of applied fixes in our internal test suite kept every variable name intact and compiled cleanly.

How was this measured? →
validate:4

Eleven checks between the model and your file

Every candidate is merged into the full original file first. Each check then looks at the result the way a careful reviewer would. Select a check to see a patch it rejects and the message it sends back.

ALWAYS BLOCKS marks checks that reject a patch even in demo validation mode, because a patch that fails them would break the program.

apply:5

Applying one fix never breaks the next

Writing the patch is the easy part. Keeping the rest of the scan accurate after the file changes is what makes the next fix land on the right line.

Conflict-checked writes

Each fix records the SHA-256 of the file it was generated from. If the file has changed since, AIRA shows the current code and asks you to regenerate instead of overwriting newer work.

Line re-anchoring

When a fix adds a guard, every other finding in the file moves with its code. A diff maps each old line to its new position.

os.system(cmd)6 →9 return eval(y)9 →12 import os1 →1

Fix all, file by file

Fix All chains patches within a file, so each one is generated on top of the last. You then apply one combined, validated patch per file, and every finding it closes is marked Resolved.

Rescan the patched workspace

Start a new scan of the patched workspace with one click to confirm the findings are closed and nothing new appeared.

Download the patched code

Export the patched workspace as a ZIP to open a pull request in your normal workflow.

Feedback-aware regeneration

Reject a fix and say why. AIRA stores the feedback, adds it to the next prompt, and never offers the same rejected patch again.

workspace:6

Everything a security team works in

Scanning and fixing sit inside a full review workspace: dashboards, reports, policies, team access and an assistant that knows your findings.

Workspace features
Dashboard/dashboardSeverity summary cards, trend charts, recent scans, the most vulnerable repositories and a business risk score that weighs severity, exposure and how long issues stay open.
Threat intelligence/threatsFindings grouped by OWASP category and CWE, showing which classes of weakness dominate your codebase.
Issues/issuesEvery finding across all scans, with search, severity and category filters, CSV export, and a link straight into the review-and-fix flow.
ReportsHTML · PDF · JSON · CSVStructured assessment reports with an executive summary, plain-language narratives per finding, and the evidence and engines behind each one.
Suppressionsfalse positivesMark a finding as a false positive with a reason. The suppression follows its fingerprint into future scans and can be undone.
Policies and workflowsDefine which severities block a release and automate what happens when a scan finishes.
Team workspacesroles · invitationsInvite teammates by email with read, read-write, full or custom permissions. Invitation tokens are stored as SHA-256 hashes and expire.
GitHub integrationOAuthConnect GitHub, choose a repository and branch, and scan it with a shallow clone.
AI assistantAsk about a finding, a CWE or a fix. Answers draw on the findings in your workspace rather than generic advice.
NotificationsIn-app and email alerts when scans finish and when teammates act on findings.
languages:7

Coverage that follows your stack

Python, JavaScript/TypeScript, HTML and SQL get the full pipeline — AST analysis, deterministic fixes and name-safety checks. Every other language still gets rules, Semgrep where available and AI review, with OWASP remediation guidance.

Pick the languages you use

  • Full pipeline
  • Advanced
  • Detection + guidance
View the full coverage table
LanguageRulesASTSemgrepAI reviewDeterministic fixesName checks
Python✓✓✓✓✓✓ symtable
JavaScript / TypeScript✓✓✓✓✓✓ Babel scope
HTML (inline scripts)✓✓partial✓✓undefined names
SQL / SQLite✓✓–✓PREPARE–
Other languages✓–partial✓––
architecture:8

Your code stays on your machine

Every component runs locally. The model, the embeddings and the knowledge base live on your own hardware. Scans make no third-party API calls.

your workstation · 16 GB GPU
:3001

Web app

React 19 interface for scans, review, reports and team settings.

:4000

API server

Express with JWT auth. Hosts AutoFix, validation and apply-fix.

:6379

Scan queue

Bull on Redis 7. A separate worker process runs the scans.

:27017

MongoDB

Scans, findings, fingerprints, feedback, suppressions and audit logs.

:1234

Model server

AIRA's self-trained model, OpenAI-compatible API.

:8010

RAG service

BGE-M3 embeddings over a bundled OWASP cheat-sheet index.

CLI

Semgrep

Runs as a subprocess on scans and on every candidate patch.

stdlib

Python analysers

AST and symtable checks with no extra packages.

upload → API streams to disk → queue job (IDs only, never file bytes) → worker runs 4 engines → fusion → MongoDB → AutoFix → RAG + LLM → 11 checks → your approval → hash-checked write

Air-gap guarantee: No API key required. No telemetry. No call home. AIRA's self-trained model runs on your GPU, retrieval uses a local embedding model and a bundled OWASP index, and Semgrep runs from the CLI. The only outbound connections are ones you set up: GitHub clones or your own SMTP for invitations.

run:9

Running in about ten minutes

AIRA runs on Windows 10 or 11 with a single CUDA GPU. The tested stack is listed below.

  • Node.js / npm24.x / 11.x
  • Python3.13
  • MongoDB8.x
  • Redis (Docker)7.x
  • Semgrep1.159+
  • AIRA modelSelf-trained code model (~9 GB)
  • GPU memory16 GB (model + BGE-M3)
  • OSWindows 10 or 11 (CUDA GPU)
  • Ports required3001 · 4000 · 6379 · 1234 · 8010 · 27017
1 · databases
docker run -d --name redis -p 6379:6379 redis:7
docker run -d --name mongo -p 27017:27017 -v aira-mongo:/data/db mongo:8
2 · model
lms load aira-code-model --gpu max --context-length 16384

3 · services

Installation package

AIRA's services are provided with your evaluation or licence, together with setup guidance.

Request the package
pricing:10

Self-hosted licences for every team size

All plans are on-premise — no SaaS subscription. Start free on a single machine, then add team access, reporting and enterprise support as you grow.

Developer

Individual

Free for evaluation

Seats: 1 developerRepos: up to 3
  • All 4 detection engines
  • AutoFix and all 11 validation gates
  • Basic dashboard
  • Reports (HTML / JSON)
  • GitHub integration
  • Community support
Request evaluation
Most PopularTeam

Security Team

Contact for pricing

Seats: up to 10 engineersRepos: unlimited
  • Everything in Developer, plus
  • Team workspaces with roles and invitations
  • All report formats (HTML / PDF / JSON / CSV)
  • Policies & workflows
  • Suppressions management
  • AI assistant
  • Priority email support
Get a Demo
Enterprise

Enterprise

Contact us

Seats: unlimitedRepos: unlimited
  • Everything in Team, plus
  • Air-gapped deployment support
  • Custom OWASP rule development
  • SLA-backed support
  • On-site / remote onboarding
  • Custom SSO integration
  • Compliance documentation (SOC 2 / ISO assistance)
  • Dedicated account manager
Contact Sales

Compare plans

FeatureDeveloperTeamEnterprise
Seats1Up to 10Unlimited
RepositoriesUp to 3UnlimitedUnlimited
All 4 detection engines✓✓✓
AutoFix (all 3 tiers)✓✓✓
11 validation gates✓✓✓
GitHub integration✓✓✓
Dashboardbasic✓✓
Reports (HTML / JSON)✓✓✓
Reports (PDF / CSV)—✓✓
Team workspaces—✓✓
Role-based access control—✓✓
Policies & workflows—✓✓
Suppressions management—✓✓
AI assistant—✓✓
Air-gap deployment support——✓
Custom rule development——✓
Custom SSO integration——✓
Compliance documentation——✓
SupportCommunityPriority emailSLA-backed + account manager

All plans are self-hosted. Your code never leaves your machine.

faq:11

Questions reviewers ask

Does any of my code leave the machine?

No. AIRA's self-trained model runs on your GPU, retrieval uses a local embedding model and a bundled OWASP index, and Semgrep runs from the command line. The only outbound connections are the ones you set up yourself, such as cloning from GitHub or sending invitation emails over your SMTP server.

What does AIRA stand for?

AIRA stands for AI Risk Analysis. It describes what the product does: AI that analyses the risk in your code, fixes it with the smallest possible patch, and proves the patch with eleven checks before you see it. AIRA is built by Securobe.

What happens when the model can't produce a safe fix?

You get no patch. AIRA shows "Automatic fix unavailable" with the OWASP remediation guidance for that finding. A missing fix is better than broken code, so every patch must pass validation before you see it.

Why do some fixes skip the LLM entirely?

When a deterministic fixer or structural recipe produces a patch that passes all checks, there's no reason to spend GPU time. In testing, most eval, pickle, path traversal, weak hash and DOM XSS findings were fixed this way in about a second.

What is demo validation mode?

Switching the validation mode to "demo" in your configuration turns some stylistic checks into warnings so more fixes are offered. Checks that protect the program itself — syntax, renamed or undefined names, deleted statements and SQL placeholders — always block a patch in both modes.

Which AI model does AIRA use?

AIRA ships with its own self-trained code-security model, built to produce small, validated patches rather than rewrites. It needs about 9 GB of GPU memory and fits next to the embedding model on a 16 GB GPU. It runs entirely on your hardware.

How was the benchmark measured?

We run an internal test suite of vulnerable Python and JavaScript files through the real AutoFix controller. Each returned file is audited for syntax, undefined or renamed names, the remaining vulnerable pattern and edits far from the finding. The figures on this page come from that suite; we're happy to walk through the method and results on a demo call.

What are the minimum system requirements?

Windows 10/11 with a CUDA GPU and 16 GB VRAM (for the model + BGE-M3). Node.js 24.x, Python 3.13, MongoDB 8.x, Redis 7.x (Docker), Semgrep 1.159+. See the Run Locally section for full details.

Can I use a different language model?

AIRA talks to a local OpenAI-compatible endpoint, so other models can be connected for evaluation. Models that are not trained for this task produce more rejected patches, reducing the auto-fix rate but never compromising safety — a failed check simply returns no patch.

How does team access control work?

Invite teammates by email. Assign roles: read, read-write, full, or custom permissions. Invitation tokens are stored as SHA-256 hashes and expire. Team leads manage workspace membership from the workspace settings panel.

start:12

Three ways to get started

See it live, book a time that suits your team, or ask us anything first. We reply within 1 business day.

Get a demo

A 30-minute live session: a real scan, AutoFix and the 11 validation gates, running fully local.

Get a Demo →

Book an appointment

Pick a date and time that works for you and we'll confirm it within 1 business day.

Book a time

Ask a question

Pricing, deployment, languages or partnerships — send us a message and we'll get back to you.

Contact us
  • Air-gapped deployment — your code never leaves your network
  • Backed by Securobe's enterprise security expertise

secureai · local secure code review

Review every finding. Trust every patch.

Four engines find the issue, the cheapest correct fix is tried first, and eleven checks stand between the model and your codebase.