# Verify Everything, Trust Nothing: an open-source security platform where even the AI has to show its work

> Source: <https://dev.to/nghiadaulau/verify-everything-trust-nothing-an-open-source-security-platform-where-even-the-ai-has-to-show-3a6m>
> Published: 2026-10-04 11:32:14+00:00

**Key takeaway:** Synapse's propose → verify → confirm gate lets an AI agent suggest findings but requires a distinct verifier to seal a verdict over the evidence, keeping the model out of the report path entirely.

Most security tooling asks you to trust it. The SCA scanner *guesses* that a CVE applies. The SAST tool floods your PR with maybes. The shiny new "AI security assistant" confidently tells you something is exploitable — and you have no idea how it decided that.

I kept hitting the same wall: **a pile of findings, no custody, no proof, and an AI I couldn't audit.** So the thing I got excited about building (and now get to share) takes the opposite stance, right there in the tagline:

**Verify Everything. Trust Nothing.**

Meet **[Synapse](https://github.com/KKloudTarus/synapse-ce)** — an open-source (Apache-2.0), Go control plane that runs the *whole* security-assessment lifecycle behind one gate and treats every result as **evidence you can re-check**, not an alert you have to believe.

👉 **Want to just click around first?** There's a live playground — no install, no signup: [synapse-playground.pages.dev](https://synapse-playground.pages.dev/)

Three things broke my trust in the usual stack:

Synapse is basically a long answer to "what if none of that were allowed?"

One platform, every angle — supply chain, code, cloud, offensive, and runtime defense:

Scanning, matching and reporting are pure, reproducible Go. Reports are **templated from stored data**. The output you hand an auditor was computed, not generated.

Every artifact is hash-chained into a tamper-evident custody record (RFC-3161 anchored). **A broken chain blocks the report.** You can prove what was found, from what input, and that nobody edited it in between.

This is my favorite part. Every AI/analysis claim goes through **propose → verify → confirm**. The agent is **propose-only**: it can suggest a reachability result, a SAST finding, a risk narrative — but a *gated* claim is promoted only when a **distinct verifier** seals a verdict over the evidence. The model that made the claim can never confirm its own claim, and it never sits in the report path. AI helps; it doesn't get to lie.

And underneath all of it: **safe by construction** — argv-only tool execution inside a Linux sandbox, server-side scope + authorization enforced *before any tool runs*, secrets that never leave the server, RBAC + tenant isolation (Postgres RLS) through a single authorization chokepoint.

`synapse-cli` is a single static binary that gates a build and emits **SARIF** for code scanning, with CycloneDX/SPDX + PURL, OpenVEX, and KEV/EPSS all native:

```
# Gate a repo in CI — fail the build on high-severity, reachable findings
synapse-cli scan ./path/to/project --fail-on high --sarif > results.sarif
```

Standards in, standards out. No lock-in.

The fastest way to get the feel for it is the browser playground — poke at a scan, see findings tied to evidence, watch the reachability call it:

No signup, nothing to install. Bring a repo in your head and see how the "evidence, not alerts" model reads.

Synapse is open source (Apache-2.0) and built in the open:

If the idea of a security platform that has to *prove* every finding — and keeps even its own AI honest — sounds like your kind of thing, come kick the tires.

**Verify everything. Trust nothing.** 🔐

*Synapse is for authorized security testing only — every engagement enforces an explicit scope and authorization window, server-side, before any tool runs.*
