Constant / provided by Bravos
Surface
How you and your team drive it.
- Terminal
- Dashboard
- MCP
- CI gate
- Team server
commandssetup doctor config dashboard mcp ci push
Bravos: whitebox pentesting, free to start
From annotation to evidence. One agentic loop.
Point Bravos at a repository. It writes a threat model into your code with GuardLink, attacks a running copy of your app through Cert-X-Gen with real logins, and ends every threat confirmed, refuted or not tested, with the reason.
Uses Claude Code, Codex or Gemini CLI as its agent
Bravos
Describe the test. Approve the plan. Read the verdicts.
Bravos reads your brief and your repository, prints a plan you can argue with, then runs round after round until it can say why it stopped.
pipx install bravosFree, with no account. Python 3.11 or later. Install guide (opens in a new tab)
~/payments-apiExample run, sample data
bravos intake "Pentest ./payments-api, running on http://localhost:8080. Go deep and find chained exploits."
PLAN 20261005-101422-payments-api
derived from your brief
codebase payments-api
target http://localhost:8080
auth seed 2 equal-privilege users, re-login on expiry
lenses unauth → mitigation-audit → stduser → crosstenant → chained
depth deep, up to 20 rounds, 4 dry to converge
What Bravos provides, and what you bring.
Bravos is a continuous SAST and whitebox pentest orchestrator. It is built on two open-source projects: GuardLink, threat model as code through code annotations, and Cert-X-Gen (CXG), pentest as code through executable templates in 12 languages.
Constant / provided by Bravos
Shared context
The state every run reads and writes back.
- GuardLink threat model
- Threat ledger
- Template registry
- Code graph
commandsmodel annotate inspect ledger template graph diff sast
Constant / provided by Bravos
Execution
Where approved probes run.
- Disposable environments
- Authenticated sessions
- CXG pentest engine
- Approved scan plans
commandsintake plan auto run round env replay resume
Changes over time / bring your own
AI models
Bring the coding agent you already use. Bravos calls it only at judgment points: annotation, lab recipes, goals and write-back.
- Claude Code
- Codex
- Gemini CLI
- Your editor’s model
Changes over time / bring your own
Code & targets
Your repository and the running target you are authorised to test.
- Repositories
- Web apps
- APIs
- Docker / local
- GitHub / CI
flags--target --attestation
- Constant
- Changes over time
- Provided by Bravos
- 01AnnotateAn agent writes the GuardLink threat model into your code. No traffic.
annotate - 02PlanA plain-language brief becomes a scan plan you review and approve.
intake · plan - 03PentestCXG runs the probes in disposable environments, with real sessions.
run · auto - 04LedgerEvery result lands in the threat ledger. Stored probes replay after a fix.
ledger · replay - 05Write back and gate CIVerdicts go back into the annotations, the build fails on a policy breach.
ci · diff
Evidence you can read, rerun and gate on.
Not a list of suspicions. Each result says what was attacked, as whom, and what happened.
A ledger of verdicts
Every threat ends confirmed, refuted, mitigation held or not tested, and each verdict carries its reason. A threat Bravos could not reach stays open instead of reading as clean. See a sample ledger
Advisories with the probe
Each confirmed finding becomes an advisory written like a GitHub security advisory, with the exact Cert-X-Gen probe that proved it.
Findings in your code
Confirmed findings become @confirmed annotations beside the vulnerable line, on a bravos/run branch with one commit per phase, so every round can be reviewed or reverted.
A gate for your build
bravos ci judges a run’s ledger against the policy file in your repository: pass, warn or fail. It needs no target and no agent, and it is free.
Nothing found has to mean nothing found.
A tool that folds “we could not reach the target” into “we found nothing” reports a cleaner app than it measured. Bravos keeps the two apart.
A scan that never reached the target is not a clean result.
Only a confirmed or a clean probe moves a verdict. Timeouts, dead sessions and scans that stopped early leave the threat open.
Six attack perspectives, one per round.
Unauthenticated, mitigation audit, standard user, cross-tenant, admin and chained. Each round looks at the code from a different side.
Declared controls get tested too.
A @mitigates annotation hides an exposure from the export. The mitigation-audit lens puts it back and asks whether the control actually holds.
The agent cannot bury a finding.
An agent that writes @accepts halts the run, an unproven @mitigates is recorded as suppressed, and any edit that is not an annotation is reverted.
Logins that refresh themselves.
Bravos signs in with its own headless login and re-authenticates when a session expires. It pauses only when a login needs a person.
It stops for a stated reason.
After several healthy rounds in a row find nothing new, when every lens is retired, or at a budget ceiling. The reason is recorded with the run.
Run once with AI. Replay without it.
A run keeps the probes it fired beside your code, in .bravos/sessions, with no secrets in them. After a fix, bravos replay fires the same probes at the same target. Nothing is generated again, so no AI runs.
The result goes back into the run's ledger. A probe that confirmed before and is refuted now closes the finding. A probe that could not run leaves it open.
# after the fix is merged $ bravos replay <run-id> # fire every stored probe again $ bravos replay <run-id> --threat gl-… # only the threats you just fixed $ bravos ci # judge the updated ledger
Install it in your editor.
The Bravos extension puts the threat map and the verdicts beside your code, in the editor you already use. Free, and the same build everywhere.
Or open the Extensions panel (⌘⇧X on macOS, Ctrl+Shift+X elsewhere), search Bravos, and install. The identifier is bravos.bravos.
The tools underneath.
Bravos drives two open-source tools we build, and the template library they share.
GuardLink holds the threat model. Cert-X-Gen runs the probes. Bravos decides what to test next, as whom, and records what each test proved.
Start free, then bring Bravos to your team.
Bravos Free needs no account. Buy a licence per developer, seats for your team, or an enterprise contract.