Read this before you trust it.
The install is one command. Everything after that is about knowing exactly what the tool does, what it refuses to do, and what to do when it is wrong.
Install
One static binary. No runtime, no container, no account, no configuration you did not write yourself. Download the archive for your platform, unpack it, run it. The signed corpus bundle is inside the archive, so the first command works with no further setup.
~$ curl -fsSLO https://clearancedev.vercel.app/dl/clearance_0.1.0-rc.2_linux_amd64.tar.gz ~$ tar -xzf clearance_0.1.0-rc.2_linux_amd64.tar.gz ~$ ./clearance version clearance 0.1.0-rc.2 (build ebef425, release) corpus: 2026.09.2 signed: yes 12 licences, 39 obligations, 12 traps, 82 citations ~$
On macOS use darwin in place of linux. On Windows, call curl.exe rather than curl — PowerShell aliases curl to Invoke-WebRequest, which rejects these flags — and run the lines one at a time, because && is a syntax error before PowerShell 7:
PS> curl.exe -fsSLO https://clearancedev.vercel.app/dl/clearance_0.1.0-rc.2_windows_amd64.zip PS> Expand-Archive clearance_0.1.0-rc.2_windows_amd64.zip -DestinationPath . PS> .\clearance.exe version
| Platform | Architecture | Artifact |
|---|---|---|
| Linux | amd64 · arm64 | clearance_0.1.0-rc.2_linux_amd64.tar.gz |
| macOS | amd64 · arm64 | clearance_0.1.0-rc.2_darwin_arm64.tar.gz |
| Windows | amd64 · arm64 | clearance_0.1.0-rc.2_windows_amd64.zip |
Every archive is listed in checksums.txt. Verify yours before you run it — name your own file, because the list also covers the five archives you did not download:
~$ grep -F clearance_0.1.0-rc.2_linux_amd64.tar.gz checksums.txt | sha256sum -c - clearance_0.1.0-rc.2_linux_amd64.tar.gz: OK
The step-by-step guide — which archive to pick, verifying the download, putting clearance on your PATH on Windows, macOS or Linux, and what to do when the command is not found — is in docs/install.md.
These archives are built and published by this site; there is no package registry entry and no installer script. If you would rather build it yourself, the source is at K1ngBronxo/Clearance-dev and it needs only Go 1.25.13 or later:
~$ git clone https://github.com/K1ngBronxo/Clearance-dev ~$ cd Clearance-dev ~$ make build ~$ ./clearance version
Your first verdict
~$ cd ~/dev/my-saas ~$ clearance doctor ~$ clearance check . CLEARANCE VERDICT — my-saas ======================================== SHIP: UNDETERMINED REASON: 3 items could not be classified ~$
That UNDETERMINED is the honest first answer for most projects. It is not an error and it is not a failure — it means the tool read your tree and found three things it cannot classify without a fact only you have. Run clearance explain <code> on any of them to see exactly which fact it needs.
Nothing writes your config for you. Clearance reads clearance.config.yml from the project root, and if it is absent the run stops with E-CFG-001 and exit 2 rather than assuming your intent. Start from the example in the source tree and edit it.
Configuring intent
Without declared intent, most obligations are conditional and unanswerable. So all six use.* fields are required — and an omitted field evaluates to UNKNOWN, never to a default.
The project name is the only thing Clearance infers for you, and only to label the verdict header. Everything that can change a verdict is a field you write yourself.
Run clearance check --help for the full field list, or use the intent editor.
The four verdicts
| Verdict | Meaning | CI behaviour |
|---|---|---|
| Ship | No blocking obligation found for the declared intent | exit 0 |
| Ship conditional | Shippable if the stated conditions are met | exit 0 by default |
| Do not ship | At least one obligation contradicts the declared intent | exit 1 |
| Undetermined | Insufficient information to verdict | exit 0 · 5 with --strict |
UNDETERMINED is a first-class verdict, not an error state. A tool that guesses when it does not know is worse than no tool.
The decision is four ordered rules — any HIGH-confidence blocker, then any undetermined, then any condition, then ship. The decision layer is pure: no I/O, no clock, no randomness, so the verdict is byte-reproducible. See the verdict algebra.
Confidence
Clause interpretation ranges from unambiguous to genuinely ambiguous. Every finding carries a level, and the interface never presents a MEDIUM as certain.
Confidence propagates through the predicate. If an input is UNKNOWN, the result is UNKNOWN — and the verdict becomes UNDETERMINED rather than a pass.
The clause corpus
The corpus is the product's actual asset. All judgement lives in it, so a wrong interpretation is fixed by editing YAML and re-signing — never by shipping a new binary. A fork can copy the code; a fork cannot sign the corpus.
| Property | Value |
|---|---|
| Version | 2026.09.2, schema 1 |
| Contents | 12 licences · 39 obligations · 12 traps · 6 platform sets · 4 territories · 82 citations |
| Signature | Ed25519, verified before load |
| Licence | CC-BY-4.0 — quote it, mirror it, cite it |
| Staleness | Every entry carries last_verified and stale_after |
| Changelog | Published, generated, append-only |
An invalid signature is fatal and refuses to verdict. A confidence level may never rise without a correction block — without one, the entry will not load (E-CORPUS-006).
Weights are code
A model weight file is a dependency with a licence. Treating it as an afterthought is the single most common AI-era trap, and it is the one no existing tool models.
Weight files are identified by magic bytes, not by extension. Their licences are resolved from GGUF metadata, config.json, model-card frontmatter, or a sibling LICENSE. Where the weights licence disagrees with the code licence, Clearance reports the divergence.
The clause-by-clause version of this — every weights licence in the corpus, what it permits, and which of those citations have been verified against the source — is on Which model weights can I ship?
CI and the Action
The Action contains no judgement of its own: it downloads a checksum-verified binary, runs it and exposes the verdict and the exit code. All decisions live in the binary, so the Action can never drift from the CLI.
It does not upload SARIF and it does not post a comment — --format md emits the PR-comment form and --format sarif the code-scanning form, and you hand those to GitHub yourself. The Action is not published yet, so until it is, build the binary in CI and run it directly. See the CI page for a workflow that works today.
SBOM and SARIF
Clearance emits CycloneDX and SPDX SBOMs so it can sit beside tooling you already run, and SARIF 2.1.0 for GitHub code scanning. Every SARIF output is validated against the official schema in CI — a schema violation fails the build rather than producing a subtly broken annotation.
The MCP server
clearance mcp serve exposes the same engine to agents over stdio. Four tools, all read-only and idempotent.
| Tool | Input | Output |
|---|---|---|
| clearance_check | { path, intent } | the full verdict JSON |
| clearance_explain | { citation_id } | clause text + citation |
| clearance_corpus_info | {} | version + signature status |
| clearance_license_lookup | { spdx_id } | obligations and traps |
The server declares exactly one capability, fs.read, scoped to the requested path. It never writes, never executes, never makes an outbound call, and refuses a path outside the declared workspace root.
When we are wrong
Every verdict is challengeable, and there is a published process for it. This is not a support page — it is a commitment about how fast the corpus changes and how visibly.
Privacy
The scanner reads files. Nothing else. This is not a policy — it is an invariant with a runtime tripwire.
This build cannot make an outbound call at all — clearance version reports network: disabled. If an egress were ever attempted it is blocked and reported as E-NET-006. That code exists so the promise has a runtime failure mode instead of being a claim in a README.
If it ever fires in the wild, the privacy promise is broken — and it is treated as a bug of the highest severity, not a warning.
Licence
The Functional Source License, ALv2 Future License. Source-available, never AGPL — and not open source either. The source is published in full and you can read, build and run it; it is simply not an OSI-approved licence, and this page will not call it one.
The corpus data wants to be quoted, cited and mirrored. The entry id and version are the citation, and the corpus is a data artefact you can carry to another tool.
The paid boundary is drawn at the service, never at a feature. Nothing a self-hoster can already do is paywalled. What is paid for is freshness, scale, accountability and a signature.
Not legal advice
Clearance produces informational findings based on the licence text as published on the dates recorded in the corpus. It is not legal advice and it is not a legal opinion. Ambiguous clauses are flagged as ambiguous and carry a confidence level. Important decisions must be reviewed by a qualified professional.
The disclaimer is not buried in a footer — it is rendered into every human and Markdown output, and a test asserts it is present. If a run ever omitted it, the build would fail before the release existed.
FAQ
Why not just read the LICENSE file?
Because the answer is not in one file. It is in the code licence, the weights licence, the platform terms, the trademark notice, and the territorial clause — and the one that blocks you is usually not the one you opened. Reading five documents per dependency is not a build step.
Why not FOSSA or Snyk?
They are good tools built for a different buyer. They produce a report for a legal team, priced for an enterprise, and they read one of the five layers. They also do not model model weights at all. If you have a legal team and an enterprise budget, they are the right answer — and you can still run Clearance in CI for the two layers they miss.
Does it phone home?
No. Zero telemetry, and --offline makes zero outbound calls. This build cannot reach the network at all, so the tool works on a plane. There is a runtime tripwire (E-NET-006) that blocks and reports any unexpected egress.
What if a dependency's licence is not in the corpus?
It becomes UNDETERMINED (E-POLICY-001) — never a guess, and never silently dropped. You can contribute an entry, and the contribution process is a pull request against the corpus with a citation.
Can I use it commercially for free?
You can build it and run it, including at work. It is not free in the open-source sense — the CLI is source-available under FSL-1.1-ALv2, which permits use and forbids building a competing product from it. Nothing here is a hosted service you have to buy.
What does it do about vulnerabilities?
Nothing, deliberately. Clearance is about permission, not exploits. That boundary is what keeps the scope small enough for one person to build and maintain honestly.