AART is a security engineering agent that lives inside VS Code. It's not a linter and
it's not a report generator — it detects vulnerabilities, investigates why they're
real (or aren't), proposes fixes you review before anything touches your files, and
keeps a persistent memory of your project's security posture across sessions and scans.
Status: public beta. AART is under active development. The core scan → findings
loop is stable and used daily; some deeper features (full remediation workflows,
Architect-mode hardening bundles) are newer and still maturing. See the
CHANGELOG for what's shipped.
What AART actually does
- Detects. A curated, first-party rule corpus (thousands of rules across dozens of
languages and frameworks) runs via the Opengrep engine, plus AST-aware taint analysis
and dependency/secret scanning.
- Investigates. Beyond pattern matching, AART builds a structural understanding of
your codebase — call graphs, route maps, data flow — and reasons about whether a
candidate finding is actually exploitable in your specific code, not just whether it
matches a pattern.
- Remediates. When you ask it to, AART proposes a concrete patch for a finding, shown
as a side-by-side diff. Nothing is written to your files without your explicit
approval (unless you turn that off yourself).
- Remembers. Findings, decisions (including false-positive dismissals), and your
project's evolving threat model persist across scans — AART doesn't start from zero
every time.
The three agent modes
AART's tool access and mutation rights are governed by a mode you pick per session:
| Mode |
What it does |
Can it change your files? |
| Analyze |
Maps your codebase, scans for vulnerabilities, validates findings, and reports — a read-only investigation. |
No |
| Fix |
Full remediation pipeline: generates patches for findings and applies them only after you approve each one (a human confirmation gate on every write). |
Yes, always confirm-gated |
| Architect |
Broader security design work — threat modeling and hardening bundles (e.g. writing project security rules, CI hooks) — for when you want AART to help shape how the project defends itself, not just fix one finding at a time. |
Yes, confirm-gated |
Switch modes from the mode selector in the AART sidebar. Analyze is the default and the
safest place to start.
Getting started
- Install the extension and sign in from the AART sidebar (the shield icon in the
Activity Bar) — AART uses your Supabase-backed account, the same one behind the web
dashboard.
- Open a workspace. AART detects it automatically on your first scan — there's no
manual "connect repo" step. If it's a git repository, AART identifies it by remote
URL; otherwise it uses a local, machine-scoped identity.
- Run your first scan — click the scan button in the sidebar, right-click a file for
AART: Scan Current File, or use the Command Palette (Ctrl+Shift+P /
Cmd+Shift+P) → AART: Scan Workspace.
- Review findings in the sidebar's Findings tab as they come in.
A guided walkthrough covering these same steps is also available: open the Command
Palette and run Help: Open Walkthrough, then pick Get Started with AART Security.
- Findings — every vulnerability AART has detected in your workspace, each with a
severity, a plain-language explanation (not just a rule ID), and the exact file/line
it's rooted in. Click a finding to jump to it with an inline squiggle and hover card.
Findings persist across VS Code restarts — this tab always reflects your most recent
completed scan, not just what ran in the current session.
- Scan — live progress for an in-flight scan, streamed stage by stage (mapping,
static analysis, graph analysis, verification) so a multi-minute deep scan doesn't look
like it's hung.
FAQ
Is my code sent anywhere?
By default, no — AART scans your workspace using a structural manifest (file paths,
sizes, content hashes) built entirely on your machine. No file contents leave your
machine for a default scan. A separate, opt-in-only mode lets a specific repository
be scanned via a filtered, compressed archive upload for deeper server-side analysis;
this is off by default for every repository and has to be explicitly enabled per-repo. If
you never opt in, this never happens.
What LLM provider processes my data when deeper (Engine B) analysis runs?
AART's interactive agent and deep-reasoning paths currently use DeepSeek as the primary
provider, with a small number of specific verification steps (e.g. an independent
"judge" check) using a different provider family so it isn't grading its own homework.
Only the minimal context needed for a given reasoning step is sent — never your entire
repository at once.
Does AART modify my files without asking?
No. Analyze mode never writes anything. Fix and Architect modes show you a diff for
every proposed change and require your explicit approval before it's applied, unless you
deliberately turn on aart.autoAcceptFixes yourself (off by default).
What if AART flags something that isn't actually a problem?
Use AART: Mark Finding as False Positive / Dismiss (also available as a button on each
finding card). This isn't just a UI hide — it's a real signal AART uses to improve rule
quality over time.
Does this replace my existing linters/SAST tools?
No — AART is complementary. It's built for reasoning about exploitability and business
logic that pattern-matching tools structurally can't reach, alongside its own
pattern-based detection layer. Keep your existing tooling running.
Where can I see this running against a real backend, or connect it to my own?
The aart.apiUrl setting lets you point the extension at a different AART backend (e.g.
a local instance) at runtime. See the extension's settings (search AART in VS Code
Settings) for the full list of configuration options, including terminal-command policy,
scan-on-save, and telemetry (local-only instrumentation, off by default toggle available).
Feedback
This is a public beta. If something looks wrong, a finding seems off, or a feature is
missing, please open an issue on the
GitHub repository.
