Lagune and Deepsec (v2.2.1) are two defensive answers to the same problem: security in the age of AI-assisted development. Their premise, their beginning, middle, and end, and how each presents itself to a user diverge by design, even where their mechanics overlap.

tip

Is Lagune inspired by Deepsec? No, Lagune is written from scratch and is inspired by Spec-Driven Development and Security Hardening. The two projects were developed independently, and the comparison here is to help users understand their differences.

At a glance

Aspect	Lagune	Deepsec
Kind	A methodology (SDH) with a reference implementation	A product: an agent-powered vulnerability scanner
Center of gravity	A charter and on-demand knowledge drive the agent, grounded in deterministic hooks	A wide regex net feeds a mandatory AI investigation
What it produces	Hardened code, proofs, and a tracked chain of findings	A severity-ranked, triaged findings report
Touches your code	Yes: harden edits your code	No: static analysis only, emits findings and recommendation text
Runtime	Runs on the agent and model you already run, any tier	Runs its own model pipeline, a frontier tier by default
Getting started	One init, then drive it in plain language, no new tool to stand up	Stand up a .deepsec/ workspace, install deps, and add a model key

How it works

Lagune is agent-first: the agent drives, pulls in knowledge on demand for what the code is, and delegates a decidable slice to the deterministic hooks.

Deepsec is deterministic-first: a wide scan flags candidates that point a mandatory model at what to investigate and judge.

Aspect	Lagune	Deepsec
Order	Charter and matched knowledge steer the agent, which delegates to hooks and judges the rest	Matchers flag candidates, the model investigates and judges each
Deterministic role	Multi-language hooks that return a verdict or aim the agent, combined with category knowledge	Matchers that flag candidates for the mandatory model to judge
Development flow	/lagune builds securely inline as you code	It reviews code, it does not write it
Audit flow	charter → detect → plan → harden → verify	scan → process → triage → revalidate → report
The AI's job	Reason from the knowledge, apply the fix, and prove it holds	Investigate every candidate and report the findings

Lifecycle

Lagune works before, during, and after the code is written. Deepsec reviews a repository once the code exists.

Moment	Lagune	Deepsec
Before code exists	charter mints a security policy from stated intent	Starts from existing code: init needs a directory
While building	/lagune builds safe-by-default inline, no artifact left behind	Reviews after building, not during it
On existing code	detect → plan → harden → verify	scan → process, the core flow
Continuous review	Re-run phases per scope, no packaged CI gate	Incremental re-scan, process --diff as a CI exit gate

Detection layer

The two deterministic layers are opposite in kind: one decides, the other flags.

Aspect	Lagune	Deepsec
Grouping	Security groups and hooks per specialization or sub-skill	Matchers per pattern or framework
Output	Literal verdict (finding / review / advisory) plus a classify label	Verdict-less candidate (slug, lines, snippet, matched pattern)
Tuning	Precision: comment-aware, placeholder and window guards	Recall: wide nets, the AI prunes false positives after
Depth	Deeper on shared classes	Broader, less deep on shared classes
False positives	Kept low at the source, then judged in context	Over-generated on purpose, cut back by a revalidate pass

Knowledge and judgment

Both carry security knowledge the regex cannot. They differ in where it lives and who can shape it.

Aspect	Lagune	Deepsec
Form	Editable markdown modules, several backed by a deterministic hook	A short prompt and per-tech highlights, drawing on the model's own knowledge
Selection	Matched to the code, loaded only when its context is present	Injected into every AI batch, plus highlights for the detected tech
Who authors it	The user edits modules and adds new ones with specialize	The maintainer owns the prompt, the user fills an INFO.md
Where judgment sits	The hooks decide their floor, the agent judges the rest from the knowledge	Centralized: one AI processor judges every candidate
Reuse	One module guides both detect and verify	One prompt drives the single process stage

Findings and closure

They diverge most on what a finding becomes once it is resolved.

Aspect	Lagune	Deepsec
Severity	A CVSS v4.0 score, adjusted for exposure and stakes	An AI severity, plus a P0 / P1 / P2 triage of exploitability and impact
Verdicts	Risk closed, not closed, or cannot tell from the code	true-positive, false-positive, fixed, uncertain, accepted-risk, duplicate
Persistence	Working chain reconciles, closed findings distilled to a history	Append-only per-file records, nothing removed
End state	Closable: a proven finding stands down, the chain can rest	Every finding is kept for good, hidden from views once resolved
History detail	A compact summary of what the risk was	The full verdict trail, including how it was fixed

Cost

Aspect	Lagune	Deepsec
Deterministic floor	Free: hooks run with no AI, no key, no network, already emitting verdicts	Free: scan runs with no AI, but emits no verdicts on its own
Typical bill	Folded into an agent you already run, down to $0 on a local model, the plan price you already use, or per iteration for API-based usage	Roughly $25 to $1,200 per run for 100 to 2,000 files, more at scale
Cheapest path	Any model, including a free local one, closes the cycle	Cheaper paid tiers exist, but findings need the paid AI stage

Extensibility and governance

Each opens the layer the other keeps closed.

Aspect	Lagune	Deepsec
What you extend	Edit modules, or add new via specialize	Add matchers, agents, notifiers, and ownership
Policy layer	The charter governs every phase and is versioned	Config is operational (matchers, models, paths)
Override by name	A refined module shadows the built-in	A matcher slug collision, your matcher wins

Interfaces

Deepsec emits deliverables for a security organization. Lagune renders a live view for whoever runs it.

Aspect	Lagune	Deepsec
Human surface	A live local dashboard of the whole chain, in plain language	Report, export, metrics, and PR-comment files, plus a docs site
Accountability	Surfaces files and the sub-skills that applied	Routes a suggested assignee: on-call, manager, or committer
Reproducible proof	prove writes runnable tests and a disclosure advisory	Stays static by design, it never executes the target
Tool self-defense	Hardens a local write API on the dashboard	Hardens its own AI execution against untrusted target code

Scale and deployment

Aspect	Lagune	Deepsec
Install	Scaffolds files into the repo, no separate runtime	A .deepsec/ workspace with its own package and dependencies
Scale direction	Scopes to any slice, a context, one file to the whole project	Sweeps whole repositories, up to large monorepos
Distribution	Local only, the one server binds to loopback	Optional fan-out across Vercel Sandbox worker VMs
Portability	Renders commands to dozens of agent formats, adapters as data	Drives a small set of agent SDKs, plugin-extensible

User experience

How each meets the person running it: what the first run takes, and how the operator aims it.

Onboarding

Lagune runs through the agent already open. Deepsec provisions its own workspace and model access first.

Aspect	Lagune	Deepsec
First command	npx -y lagune@latest init, then /lagune.* in the agent	npx deepsec init, then cd .deepsec, pnpm install, scan, process
Credentials to run	No separate key, it uses your current agent	A model key (e.g., AI Gateway, a 12-hour Vercel OIDC token, or an Anthropic token)

Driving it

Both take direction. Lagune reads the shape of the input per phase. Deepsec narrows the file set the same investigation runs over.

Aspect	Lagune	Deepsec
Whole project	A phase with no input scans the whole scope	scan and process sweep the repository
A slice	Any phase scopes to given files or directories	--files, --files-from, or --diff narrow the run
A concern	A phase scopes to a described worry	The investigation prompt is fixed
A priority band	harden and verify scope to Critical, High, Medium, or Low	Findings are labeled after the run
A single value	A hook scores one snippet, pattern, or URL directly (-p, -u)	The unit of work is a file

Frequently Asked Questions

Lagune is agent-first and works before, during, and after the code is written: it sets policy before code, hardens inline while building, and audits, hardens, and verifies code already written. Deepsec is deterministic-first: a wide regex scan feeds a mandatory frontier-model investigation that reviews existing code and reports findings, without changing it.

Lagune's whole flow can run at $0 on a free local model, and its deterministic hooks emit verdicts with no AI at all. Deepsec's scan is free but emits no verdicts, so any finding requires its paid AI stage.

Lagune does: harden applies fixes to your code. Deepsec does not: it is static analysis only, emitting findings and recommendation text that a person or agent applies separately.