BranchesTags

Repository files navigation

deepsec

deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing large-scale repos.

deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.

For large codebases, work fans out across worker machines in parallel. Commands are idempotent — interrupt a job, restart it, and deepsec picks up where it left off.

Get started

Navigate to the root of the repository that you want to scan, then:

npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output

Now have your coding agent bootstrap your installation. Open the agent of choice and prompt:

Read .deepsec/node_modules/deepsec/SKILL.md to understand the tool. Then read .deepsec/data/<id>/SETUP.md and follow it: skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful of representative code files, then replace each section of .deepsec/data/<id>/INFO.md.

Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per section, not exhaustive enumeration. Name primitives (auth helpers, middleware) but no line numbers. Skip generic CWE categories — built-in matchers cover those. Cover only what's project-specific. INFO.md is injected into every scan batch; verbose context dilutes signal.

Then scan from inside .deepsec/:

pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings

If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.

Docs

AI provider

When running locally, deepsec attempts to use your existing subscriptions when invoking claude or codex.

For scaled usage on large code bases we recommend using Vercel AI Gateway or provider API keys. The AI Gateway has default quotas suitable for highly concurrent research.

AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See docs/vercel-setup.md for getting a key and for the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN

  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values always win over the AI_GATEWAY_API_KEY expansion.

Distributed execution (optional)

Large monorepos can fan work across Vercel Sandbox microVMs:

pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4

Needs a Vercel account. The local working tree is tarballed and uploaded; .git is excluded. Both OIDC tokens (local) and access tokens (CI) are supported — see docs/vercel-setup.md.

Security model of deepsec itself

Treat deepsec like a coding agent with full shell access on the enviroment that it is running on. It is designed to run on trusted inputs (your source code) but you may still be concerned about prompt injection due to external dependencies or vendored code.

Running on a sandbox (see above) does limit the potential exposure substantially:

  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)

Workflow reference

CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs

License

Apache 2.0. See LICENSE and NOTICE.

About

Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents

vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base

Resources

Readme
License

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
deepsec
deepsec an agent-powered vulnerability scanner that you can run in your own infrastructure, optimized to perform on-demand review of all code in existing
large-scale repos.
deepsec is designed to surface hard-to-find issues that have been lurking in applications for a long time. It is configured to use the best models at maximum thinking levels, meaning scans can cost thousands or even tens-of-thousands of dollars for large codebases. Our customers have found the cost worth it for how quickly they were able to patch vulnerabilities that would have otherwise gone unfixed.
For large codebases, work fans out across worker machines in parallel.
Commands are idempotent — interrupt a job, restart it, and deepsec picks up
where it left off.
Get started
Navigate to the root of the repository that you want to scan, then:
npx deepsec init # creates .deepsec/ with this repo as the first projectcd .deepsec
pnpm install # installs deepsec from npm# Proceed as instructed by `init` output
Now have your coding agent bootstrap your installation. Open the agent of choice
and prompt:
Read .deepsec/node_modules/deepsec/SKILL.md to understand the
tool. Then read .deepsec/data/<id>/SETUP.md and follow it:
skim this repo's README, any AGENTS.md/CLAUDE.md, and a handful
of representative code files, then replace each section of
.deepsec/data/<id>/INFO.md.
Keep it SHORT — target 50–100 lines total. Pick 3–5 examples per
section, not exhaustive enumeration. Name primitives (auth helpers,
middleware) but no line numbers. Skip generic CWE categories —
built-in matchers cover those. Cover only what's project-specific.
INFO.md is injected into every scan batch; verbose context dilutes
signal.
Then scan from inside .deepsec/:
pnpm deepsec scan
pnpm deepsec process pnpm deepsec revalidate # optional, cuts FP rate
pnpm deepsec export --format md-dir --out ./findings
If you feel like the deepsec should look at more parts of the code, give it the writing matchers doc to find more valuable starting points in your code base.
Docs
AI provider
When running locally, deepsec attempts to use your existing subscriptions
when invoking claude or codex.
For scaled usage on large code bases we recommend using Vercel AI Gateway or
provider API keys. The AI Gateway has default quotas suitable for highly
concurrent research.
AI_GATEWAY_API_KEY=vck_...

That single key covers both Claude and Codex. See
docs/vercel-setup.md for getting a key and for
the Vercel Sandbox setup. To bypass the gateway, set ANTHROPIC_AUTH_TOKEN
  • ANTHROPIC_BASE_URL (or the OpenAI pair) explicitly. Explicit values
always win over the AI_GATEWAY_API_KEY expansion.
Distributed execution (optional)
Large monorepos can fan work across Vercel Sandbox microVMs:
pnpm deepsec sandbox process --project-id my-app --sandboxes 10 --concurrency 4
Needs a Vercel account. The local working tree is tarballed and
uploaded; .git is excluded. Both OIDC tokens (local) and access
tokens (CI) are supported — see
docs/vercel-setup.md.
Security model of deepsec itself
Treat deepsec like a coding agent with full shell access on the enviroment that it is
running on. It is designed to run on trusted inputs (your source code) but you may still
be concerned about prompt injection due to external dependencies or vendored code.
Running on a sandbox (see above) does limit the potential exposure substantially:
  • The API keys for the coding agents are injected outside of the sandbox and hence cannot be exfiltrated
  • For the worker sandboxes, network egress from the sandbox is limited to coding agent hosts (Egress is allowed during the bootstrap process, but this does not run the coding agent)
Workflow reference
CommandWhat it does
scanFind candidate sites with regex matchers (fast, no AI)
processAI investigation; emits findings + recommendation
triageLightweight P0/P1/P2 classification (cheaper model)
revalidateRe-check existing findings; checks git history for fixes
enrichAdd git committer info + (with a plugin) ownership data
reportMarkdown + JSON summary for one project
exportPer-finding JSON or directory of markdown files
metricsCross-project counts: severities, vulns by type, TPs
statusSnapshot of the project mirror
sandbox <cmd>Run any of the above on Vercel Sandbox microVMs
License
Apache 2.0. See LICENSE and NOTICE.
About
Deepsec is a security harness for finding vulnerabilities in your codebase powered by coding agents
vercel.com/blog/introducing-deepsec-find-and-fix-vulnerabilities-in-your-code-base
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages