Ultrasafe
Full spec (AI-readable): Ultrasafe.md →
Several AI helpers find weak spots before release, fix-and-retry at least three rounds until clean.
Pre-release simulated penetration testing discipline. 8-agent fan-out + ≥3 iteration AND-gate + 3-layer synthesis. Advisory-only v0.2 → blocking v0.3+.
The problem Ultrasafe solves
What Ultrasafe is
Outside users finding security problems first is the worst case. AI helpers acting as different kinds of attackers in parallel change the math.
8-agent parallel fan-out + Synthesizer with BFT quorum + 3-layer report + ≥3 iteration AND-gate + advisory→blocking transition.
The core idea
Central thesis
Don't hope no one finds the weak spots. Have several AI helpers actively look, fix, repeat until two rounds in a row find nothing new.
Attestation by simulated attack. Schneier asymmetry → finite parallelizable workload. 8 agents × axis × ≥3 iterations.
What's in the cut so far (v0.1.0 → v0.2.x)
Cut scope — v0.1.0 spec, v0.2.x runtime
v0.1.0 shipped the design; v0.2.x added 8 skills + 2 hooks + MCP server. Standalone runners and schema files are deliberately not shipped — those roles live in the main agent and the spec contracts.
v0.2.x ships: full spec + 8 skills + 2 hooks + single-file MCP server (5 tools). Not shipped (deliberate): runtime/*.cjs (logical roles), schemas/*.json (contracts live in spec), mcp/tools split. Advisory-only until v0.3+.
Install the Ultrasafe plugin
Two short steps: register the EstreGenesis marketplace once, then install Ultrasafe from it.
Run this once in Claude Code to register the EstreGenesis plugin marketplace. After this, all EstreGenesis modules become installable.
/plugin marketplace add SoliEstre/EstreGenesis
Install the Ultrasafe plugin from the marketplace. This activates the pre-release simulated penetration testing discipline (advisory-only in v0.2.x).
/plugin install ultrasafe@estregenesis-plugins
Example prompts
Copy any prompt below and paste it into Claude Code to try Ultrasafe right away.
Right before you ship, kick off an Ultrasafe pre-release pass — eight attacker-perspective agents fan out, the findings come back ranked. v0.2.x is advisory only (it reports, it does not block); blocking mode is staged for v0.3.
We're about to ship — run an Ultrasafe pre-release security pass. Report findings in advisory mode for now.
When you have just added a new dependency, route it through Ultrasafe's supply-chain attacker perspective — typosquatting, transitive vulnerabilities, signing chain, SBOM mismatch — before it lands on main.
I just added a new dependency. Run an Ultrasafe supply-chain check on it before I merge — typosquat, transitive vulns, signing chain.
When Ultrasafe helps you
How to invoke Ultrasafe
Four common moments when Ultrasafe helps. AI helpers do the looking for you.
Activates via PreToolUse hook on release events or manual /ultrasafe skill. 4 scenarios covering tier × scope matrix.
Quick safety check for a small fix
Tier 1 patch release safety check
When
When
You're about to put out a small fix. Only a little bit of the code changed, and the previous version was already safe.
Right before a patch release (semver Z bump, hotfix, or quick critical patch). Narrow diff, tight schedule, stable prior release, small change footprint.
What happens
How to activate
- When you say 'release this version', Ultrasafe starts on its own.
- 3 or 4 AI helpers look at the new code at the same time, checking it from different angles.
- They repeat 3 to 5 rounds. Each round, they look at more than half the changed code.
- If two rounds in a row find nothing new and everything is improving, the release is OK to go out.
- A short report is saved for you to look at if you want.
- Tag your patch branch:
git tag v2.5.41-patch1 && git push --tags. - The PreToolUse hook auto-fires on
git push --tags, or invoke explicitly:/ultrasafe --tier=1. - Tier 1 dispatches 3-4 agents in parallel, weighted toward static analysis (SAST + linting + dep-advisory scan).
- Iteration loop: min 3, max 5. Per-iter coverage ≥50% over diff scope; skipped equivalence classes recorded in
untested_classes[]. - Clean-signal AND gate: regression-free + monotonic + coverage + 2-iter-consecutive. Pass → release proceeds (v0.1 advisory).
- Output: OSCAL Assessment Result + Hyperbrief IR card written to
reports/ultrasafe-iterations/v2.5.41-patch1/iter-N/.
Takes about 5 to 10 minutes. The AI usage cost is very small (about a dollar or two).
Expected wall-clock: 5-10 min. Token cost: ~$1-2 per run.
Full check for a big new version
Tier 3 major release full fan-out
When
When
You're about to release a big new version to a lot of users. The change list is long, or you need to give your users a written safety promise.
Right before a major release. Breaks backward compat, new public API, long changelog, Tier 3, compliance attestation needed, or RC round.
What happens
How to activate
- When you say 'release this big version', Ultrasafe starts on its own.
- All 8 AI helpers look at the new version at the same time. Each one is a different kind of attacker.
- They repeat at least 5 rounds (up to 10). They have to look at 90% or more of the code, and at least two helpers have to agree on each finding.
- If two rounds in a row find nothing new, the release gets a sealed safety certificate that you can share with your users.
- Ultrasafe also writes down what it learned, so you can turn the lessons into permanent rules later.
- Explicit:
/ultrasafe --tier=3. Or PreToolUse hook ongh release create vX.Y.Z+ semver X-bump. - Full 8-agent fan-out (AI/LLM + Web/API + Supply + Crypto + Social + Method/Comp + TM/Lifecycle + Synthesizer). §4 Finding contract + Synthesizer cross-axis correlation + BFT 2f+1 quorum.
- Tier 3: min 5 max 10 iter. Coverage ≥90%. Cross-axis confirmation ≥0.5. Agent-diversity ≥50% × 3 dims.
- Strict AND-gate: regression-free (3-component) + EWMA monotone + coverage met + 2-iter-consec with ≥50% diversity.
- Pass → OSCAL signed (cosign + Rekor proof + Sigstore TSA). Attestation: e.g. 'coverage 90% under OWASP LLM Top 10 v2025.11 + MITRE ATT&CK v15 as of 2026-06-06'.
- 3-level Greatpractice tree (macro/mezzo/micro) auto-drafted for human curation.
Takes 45 to 90 minutes. AI usage cost is bigger here (about $40-60) — all 8 helpers run for several rounds.
Expected wall-clock: 45-90 min. Token cost: ~$40-60 per run (8 agents × 5-10 iters).
Safety check for an outside-part change
Supply-chain axis focused scan
When
When
You're about to use a new outside part in your project, or change to a different version of one you already use. Want to make sure it's real and safe before bringing it in.
Bumping a transitive-critical dep or adding a new one. SBOM delta, typosquatting risk, maintainer anomaly, reproducible-build verify, Sigstore attestation check needed.
What happens
How to activate
- You change your project to use the new outside part.
- An AI helper specialized in outside parts checks five things at once — like 'is this the real version?' and 'is the maker acting strangely?'
- Two other helpers (encryption + web) double-check the answers.
- Clearly fake or tampered → warns you right away. Maker just looks a little odd → a human reviews. The system never blocks a maker by itself.
- A small lesson is saved, like 'always check the part-name spelling before installing'.
- Update your dep manifest (
package.json/go.mod/Cargo.toml/requirements.txt/Gemfile) to the new pin. - Targeted invocation:
/ultrasafe --axis=supply-chain. Or PreToolUse hook fires on dep-manifest push. - SCS runs 5 parallel checks: build tampering · maintainer compromise · typosquatting · transitive path · reproducibility. Emits PURL + attestation chain + maintainer_anomaly_flag.
- Cross-axis: Crypto verifies Sigstore sig; Web queries OSV/GHSA. Maintainer anomaly → human (§2.1.3) — system never autonomously blocks a maintainer.
- Auto-block on cosign-mismatch / SLSA L0 / OSV CVE exact-match IFF signature-based + FP<1% + fully reversible. Else → Hyperbrief.
- Iter: 3 fixed (scan / SBOM rebuild / supply-chain regression). Coverage ≥75% of 5 SCS classes; skips with reason in
untested_classes[]. - Output: Greatpractice micro-rule candidate. Artefacts at
reports/ultrasafe-iterations/pkg:npm/foo@v2-upgrade-2026-06-06/iter-{1..3}/.
Takes 10 to 15 minutes. AI usage cost is small (about $3-5).
Expected wall-clock: 10-15 min. Token cost: ~$3-5 per run (n=3 agents, 3 iters).
Make sure a fix really worked
Post-fix regression verification round
When
When
Right after you fix a problem Ultrasafe found earlier. 3 things to confirm: (1) original problem really gone, (2) same problem not lurking next door, (3) fix didn't break something else.
Post-fix verification after prior Ultrasafe finding. Verify: (1) PoC no longer triggers, (2) no neighbor exposes same vuln class, (3) no unrelated-invariant regression.
What happens
How to activate
- The next round starts on its own as soon as the fix is in.
- A fresh AI helper tries the original attack one more time. This time it should fail.
- Another helper looks at the nearby code to check for the same kind of weak spot sneaking in from a different direction.
- A third helper checks that the fix didn't accidentally break some other rule that was already protecting you.
- All 3 checks pass → fix confirmed. Any fails → human review requested (recurring problems usually need a deeper change, not another quick fix).
- Iter N+1 auto-fires on fix-commit landing. Baseline pinned to iter N's commit SHA + catalog versions.
- §6.2(a) 3-component: (a) PoC retest MUST fail; (b) neighborhood scan via call-graph 1-2 hop; (c) invariant widening via mutation testing.
- All 3 pass →
regression_check.all_pass = true✓. Strict: no new HIGH-severity from the fix. - Any fail → §6.5 meta-defect oscillation. Hyperbrief IR auto-strips
defer, forcesescalate. - Example: SQL injection → parameterized-query fix; iter 2 PoC blocked + neighbor sites covered + input-validation invariant held; iter 3 no new XSS surface. Clean ✓.
- Output: Greatpractice micro-rule (e.g. 'parameterized-query acceptance test for new endpoints'). Path:
reports/ultrasafe-iterations/<tag>/iter-{N..N+3}/.
Takes 15-20 min per round. Cost already counted in the calling release-tier budget.
Expected wall-clock: 15-20 min per round. Token cost rolls into calling tier's budget.
Where to read more if you want the details
Read the full spec
The full design is on the public code-sharing website GitHub. It is 13 chapters plus 3 short add-on sections (appendices), and it covers everything: how the 8 AI helpers divide up the work, what each helper's report looks like, when 3 or more rounds of checking is actually enough, and what Ultrasafe does NOT cover yet. The 17 research areas that fed into the design are published too — about 14,000 lines of text across 17 research notes, 17 pattern-summary files, and 3 overall summary files.
Ultrasafe.md = v0.1.0 design body + v0.2.x runtime §14-§19. reports/2026-06-05-ultrasafe-research/ = research backing (~14000 lines).