Published: July 19, 2026 | Reading Time: ~12 minutes | Channel: techminute
Here's a statistic that should keep every engineering lead awake at night: the average AI coding assistant now writes somewhere between 30-60% of new code in organizations that use them. And the developers reviewing that code? They're less familiar with it than code they wrote themselves. Security review, traditionally the last item on the checklist, is drowning under a tidal wave of AI-generated commits.
Vercel just open-sourced a tool that takes a direct shot at this problem. It's called DeepSec, and it's not another static analysis tool — it's a multi-agent AI pipeline that hunts vulnerabilities by thinking like a security engineer. It runs on your infrastructure, with your API keys, against your codebase. And at 5,700 GitHub stars and climbing, the developer community has noticed.
Traditional security scanning follows a predictable rhythm: code gets written, reviewed, merged — and somewhere down the line, a security team runs a scan. That model worked when development moved at a human pace. Teams shipped weekly or biweekly, and a pre-release security audit fit neatly into the schedule.
AI coding assistants broke that model. When Claude Code or Codex can generate hundreds of lines of functional code in seconds, the gap between "code written" and "code secured" becomes a chasm. Tools like Snyk, SonarQube, and Semgrep are sophisticated static analyzers, but they look for known patterns — CWE categories, dependency vulnerabilities, hardcoded secrets. They don't trace data flows through authentication middleware to find that one edge case where a session token can be reused. They don't reason about whether your rate limiter can be bypassed by a specific sequence of requests.
That's the gap DeepSec targets. It's not trying to replace SCA tools. It's doing something fundamentally different: using AI agents to think about your codebase the way a skilled security engineer would.
DeepSec's architecture is what makes it genuinely interesting. It implements a Multi-Agent System (MAS) pattern — five sequential stages, each with a distinct role, that together form an idempotent security investigation pipeline.
The scan stage is deliberately non-AI. It runs approximately 110 regex matchers across every file in the repository, identifying security-sensitive areas: authentication paths, database queries, file uploads, deserialization points, API endpoints with user-controlled input, and so on. On a 2,000-file project, this takes about 15 seconds and costs nothing in API calls.
This is clever architecture. Rather than throwing the entire codebase at an expensive reasoning model, DeepSec pre-filters to high-signal candidate sites. It's the equivalent of a triage nurse before the specialist sees the patient.
Here's where the heavy lifting happens. DeepSec dispatches coding agents — configured to use Claude Opus 4.7 at max thinking effort or GPT 5.5 at xhigh reasoning — to investigate each flagged file. These agents don't just pattern-match; they trace data flows, check for mitigations, and reason about exploitability.
For example: if the scan stage flags a file containing user.findById(req.params.id), the investigation agent traces whether that id parameter is ever sanitized, whether the database query uses parameterized inputs, whether the authentication middleware guarantees the requesting user has access to that ID, and what happens if the ID is manipulated.
Each investigation produces a finding with a severity rating and a specific recommendation.
Rather than using the expensive frontier models for classification, DeepSec uses lighter, cheaper models to sort findings into P0/P1/P2 severity buckets. This is a cost optimization that also reduces noise — not every finding deserves a senior security engineer's attention.
This is the stage that separates DeepSec from simpler AI security tools. A second, independent agent reviews every finding from Stage 2, checking for false positives, verifying exploit paths, and adjusting severity ratings. It also checks git history to determine whether a finding was already fixed in a subsequent commit.
The result? A false positive rate of roughly 10-20% — which, for an AI security tool operating on real production codebases, is remarkably good. (For context, many traditional SAST tools have FP rates well above 50%, which is why developers learn to ignore them.)
The final stage formats findings as markdown or JSON, ready to feed directly into issue trackers. It also uses git blame metadata to identify the contributors best positioned to fix each issue. No more "security found something, who owns this?"
| Metric | DeepSec | Traditional SAST | Manual Security Review |
|---|---|---|---|
| Scan speed (2K files) | ~15s + AI time | Seconds | Days to weeks |
| False positive rate | 10-20% | 30-70% | ~5% |
| Novel vulnerability detection | ✅ (reasoning-based) | ❌ (pattern-only) | ✅ |
| Infrastructure control | Full (runs locally) | Varies | Full |
| Cost (large codebase) | $1K-$10K+ in API calls | License fees | $50K-$200K+ |
| Idempotent/resumable | ✅ | Partial | N/A |
| Scales horizontally | 1,000+ parallel sandboxes | Varies | Limited by headcount |
The cost figure deserves attention. DeepSec's GitHub README is refreshingly honest: "Scans can cost thousands or even tens-of-thousands of dollars for large codebases." This isn't a free lunch. Running Claude Opus 4.7 at max thinking effort on thousands of files burns through API credits at an industrial scale.
But Vercel's customers, they say, have found it worth it — patching vulnerabilities that would have otherwise gone undetected for months or years.
DeepSec's security model is worth understanding because it's asking you to run a tool with full shell access on your source code:
The practical upshot: treat DeepSec like any coding agent with shell access. It's designed for trusted inputs (your code), and the safeguards are reasonable, but it's not a magic security boundary.
The most important thing about DeepSec isn't the tool itself — it's the pattern it represents. We're entering an era where AI writes code, AI reviews code, and AI audits code. DeepSec is one of the first production-grade examples of the audit layer.
Think about the trajectory:
This doesn't eliminate human security engineers — it elevates them. Instead of grep'ing for innerHTML and tracing authentication paths by hand, they configure and supervise the agents doing that work. The security engineer becomes the architect of the security pipeline, not the operator of every scan.
For teams already using AI coding tools — which is most teams shipping software in mid-2026 — DeepSec closes a critical gap. Every AI-generated PR is a potential vulnerability vector. Having an AI auditor that runs at the same speed as AI code generation makes the math work.
DeepSec is genuinely impressive, but it's not without sharp edges:
Cost can be eye-watering: Running frontier models at maximum thinking levels on large monorepos can produce five-figure API bills. Vercel's customers have found ROI, but for smaller teams, the economics may not pencil out — at least not for every-commit scanning. The sweet spot is likely periodic deep scans rather than CI-gating every PR.
10-20% false positives are still false positives: A 15% FP rate on 100 findings means 15 things a human needs to investigate that turn out to be nothing. That's manageable. On 1,000 findings, it's 150 dead ends. The revalidation stage helps, but triage overhead is real.
Applications, not libraries: DeepSec works best for services and applications — things with authenticated access, databases, and backend services. Libraries and frameworks may need custom prompts and scanners. That's a meaningful limitation if your org ships SDKs.
Dependency on frontier models: DeepSec is only as good as Claude Opus 4.7 and GPT 5.5. If either model has a bad day (a hallucination, a reasoning gap, a refusal pattern), findings can be missed. The dual-model approach mitigates this somewhat, but it's not a guarantee.
Prompt injection risk: As noted in the security model above, vendored code with embedded instructions could theoretically manipulate agent behavior. The sandbox mode limits exposure, but for repos with large dependency trees or vendored third-party code, this is a non-trivial consideration.
Not a replacement for SCA: DeepSec doesn't scan dependencies for known CVEs. You still need Dependabot, Snyk, or similar for that layer. DeepSec finds novel, logic-level vulnerabilities in your own code — it complements, rather than replaces, existing security tooling.
DeepSec isn't trying to replace your existing security stack — it's adding a layer that didn't exist before: agentic, reasoning-based vulnerability discovery that runs on your infrastructure. In an era when AI writes a significant fraction of production code and traditional security tools are drowning in false positives, a scanner that actually thinks about your codebase is a genuinely useful addition to the toolbox, provided you can stomach the API bill.
The bigger story is the pattern DeepSec represents. Multi-agent security pipelines — scan, investigate, revalidate, export — are going to become standard infrastructure for any organization shipping AI-generated code. DeepSec is an early, open-source implementation of that pattern. Whether you use it or build something similar, the writing is on the wall: security review is going agentic.
[Vercel Blog] — "Introducing deepsec: The security harness for finding vulnerabilities in your codebase." Official announcement with architecture details, endorsements, and getting-started guide. https://vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
[GitHub — vercel-labs/deepsec] — Official repository. 5.7k stars, Apache 2.0 license, full documentation including architecture, configuration, and security model. https://github.com/vercel-labs/deepsec
[DevOps.com] — "Vercel's deepsec Brings AI-Powered Security Scanning Into the Development Workflow." Independent analysis of the five-stage pipeline, cost considerations, and positioning in the DevSecOps landscape. https://devops.com/vercels-deepsec-brings-ai-powered-security-scanning-into-the-development-workflow/
[Sébastien Dubois] — "Vercel DeepSec." Detailed technical breakdown of the multi-agent architecture, configuration workflow, and relationship to SCA and existing security practices. https://www.dsebastien.net/vercel-deepsec/
All claims verified against Gold-tier (official Vercel announcement, GitHub repository) and Silver-tier (DevOps.com, dsebastien.net) sources. Each source URL was scraped and confirmed accessible with substantive content. Last verified: July 19, 2026.
