Compare / deepsec
deepsec and Stackurity: use them together
deepsec finds security bugs in your own code. Stackurity keeps a continuous inventory of what you run, checked every hour, and tracks the fixes over time. Stackurity can now import deepsec's findings and keep them next to the rest.
In short. deepsec is a free, open-source scanner that uses AI coding agents to review a repository's source code for vulnerabilities[1]. You run it when you choose: on the whole repository, or on the files a pull request changes[2].
Stackurity does a different job. It keeps one inventory of your servers, deployed applications, repositories and container images, and checks it every hour for known vulnerabilities and end of life. With stackurity import code-findings, deepsec's report lands on the repository's page in Stackurity, with the same alerts, history and access rules as everything else.
What each one does
deepsec
deepsec is an agent-powered vulnerability scanner, published as open source by Vercel under the Apache-2.0 licence[1][4]. You run it in your own infrastructure, with the AI model you pick[1]. It works in passes[1][3]:
- Scan. Regex matchers find candidate sites in the code. This pass is fast and free, with no AI.
- Process. An AI agent investigates the candidates and writes findings, each with a recommendation.
- Revalidate. An optional pass re-checks each finding, including git history for fixes, and gives a verdict: true positive, false positive, fixed or uncertain.
- Triage. A lighter pass sorts findings into P0, P1 and P2 with a cheaper model.
For pull requests, deepsec process --diff looks only at the files a change touches. It exits with code 1 when the run finds something new, so it can fail a CI job, and findings that were already there do not count[2].
Stackurity
Stackurity is open-source vulnerability and end-of-life management. It keeps one inventory of the software on your servers, deployed applications, repositories and container images. It matches that inventory against new advisories and the CISA KEV catalogue every hour and against end-of-life dates every day. It also lists leaked keys and risky settings. After a fix it checks again and records whether the issue is really gone, and it can produce a compliance evidence pack for an audit period.
Stackurity does not scan your source code for bugs. That is where deepsec comes in.
What Stackurity does with deepsec's report
You run deepsec, export its findings as JSON, and import the file into Stackurity. The repository must already be in Stackurity (through stackurity scan, the scan action or a repository integration). An import adds findings to that repository; it never creates a new asset.
- One finding, however often you import. A finding is matched by the rule, the file and its title, not by line numbers. When its lines move, it is updated, not duplicated.
- Gone when deepsec drops it. A complete import marks as gone the open deepsec findings that the new report no longer has. deepsec's export leaves out findings it has revalidated as fixed or false positives, so those close on the next import. Use
--partialfor a filtered report, for example one made with--only-true-positive; then nothing is closed. - deepsec's verdict is kept. Stackurity stores the revalidation verdict and its reasoning. A finding marked false positive, fixed, accepted risk or duplicate is stored as resolved and never alerts. If a later report opens it again, it opens again.
- Alerts only for critical and high. Open critical and high security findings raise one incident per repository: P1 when one is critical, P2 otherwise. It goes where your new issues already go and closes itself when none is open. Medium and lower findings, and deepsec's bug findings, are listed but never alert.
- Several scanners side by side. Each source replaces only its own findings. Importing deepsec's report does not close what a SARIF scanner such as Semgrep or CodeQL found.
- Dismiss with a note. Someone with the security role can dismiss a finding. It stays dismissed whatever later imports say, and can be undone.
Findings show under Fixes → Code findings and on the Code findings tab of each repository or application. They are also in the API (GET /code-findings), and AI assistants connected to Stackurity can read them with the list_code_findings MCP tool. Code findings are part of every edition, including the free Community edition. The Code findings guide has the import options, how severities map and when an incident is raised.
How deepsec's severities map
| deepsec | Stackurity severity | Category |
|---|---|---|
CRITICAL | critical | security |
HIGH | high | security |
MEDIUM | medium | security |
LOW | low | security |
HIGH_BUG | low | bug |
BUG | info | bug |
Run deepsec, then import
From the .deepsec folder that npx deepsec init creates[1], run the passes, export JSON, and send it to Stackurity:
cd .deepsec
pnpm deepsec scan
pnpm deepsec process
pnpm deepsec revalidate
pnpm deepsec export --format json --project-id shop --out deepsec.json
stackurity import code-findings deepsec.json --format deepsec --asset https://github.com/acme/shop
--asset is the repository's asset id or its URL as stackurity scan reports it. deepsec's export does not record which AI model it used; add --model to keep that with each finding. The file is checked on your machine first, so a wrong format or a broken file fails before anything is uploaded.
Any scanner that writes SARIF 2.1.0 works the same way:
stackurity import code-findings results.sarif --format sarif --asset 12
When to use which
| You want to | Use |
|---|---|
| Find security bugs in your own code, such as injection or missing authorisation checks | deepsec |
| Review only the files a pull request changes, and fail the job on new findings | deepsec (process --diff) |
| Know what software runs on your servers, apps, repositories and images, checked every hour | Stackurity |
| Find known vulnerabilities and end-of-life versions in what you run, most urgent first | Stackurity |
| Find leaked keys and risky settings, and check that fixes really landed | Stackurity |
| Keep code findings next to dependency, server and image findings, with alerts and history | Both: deepsec finds them, Stackurity keeps them |
What the import does not do
- Stackurity does not run deepsec or any other code scanner. It imports their reports.
- Code findings are not mapped to CVEs or packages. The fix is a change to your code.
- Only
deepsec export --format jsonis read. The Markdown export and deepsec's own data folder are not. - deepsec's export can name people (owners, on-call, committers, with email addresses). Stackurity does not read or store any of them.
- A report is treated as untrusted input: at most 16 MB and 5,000 findings, shown as plain text, and nothing in it is run, fetched or followed.
Questions
Does Stackurity run deepsec?
No. You run deepsec yourself, on your machine or in CI. Stackurity imports the JSON report that deepsec export --format json writes.
Is Stackurity a replacement for deepsec?
No. They do different jobs. deepsec reads your source code and reports security bugs in it. Stackurity does not scan source code for bugs; it keeps a continuous inventory of what you run, checked every hour, and keeps deepsec's findings next to the rest.
What happens to findings deepsec marks as false positives or fixed?
Stackurity keeps deepsec's verdict with its reasoning. A finding whose verdict says there is nothing to do (false positive, fixed, accepted risk or duplicate) is stored as resolved and never alerts. deepsec's export leaves out findings it has revalidated as fixed or false positives, so they resolve on the next complete import.
Can Stackurity import other code scanners?
Yes, any scanner that writes SARIF 2.1.0, such as Semgrep or CodeQL, with --format sarif. Each scanner replaces only its own findings, so importing deepsec's report does not resolve what another scanner found.
Does Stackurity keep the people named in deepsec's export?
No. deepsec's export can name people, such as owners, on-call and committers, with email addresses. Stackurity does not read or store any of them. It keeps the finding's own description, recommendation and revalidation.
Which Stackurity plans include code findings?
Every edition, including the free self-hosted Community edition.
Try Stackurity with your deepsec results
Start a 30-day free trial of Stackurity Cloud, no card needed, or download the free Community edition and run it on your own server.
Sources
Details of deepsec were checked on 21 Nov 2026 against its README, documentation and project page, listed below. Projects change; follow the links for the current details. Details of Stackurity come from its documentation and pricing. Product names are trademarks of their owners and are used here only to refer to their products.