Use CAIN-42 free today

CAIN-42 is a Byzantine trust fabric for AI agents and AI-written code. It checks what an agent may do before it acts, proves what actually happened, and lets anyone verify that proof without trusting us.

Three open-source tools: FALSEWORK (finds AI slop), the PROOFLOOP community edition (finds security bugs in Python and proves them in a sandbox) and proofloop-verify (checks signed PROOFLOOP records offline).

Yes. The three tools are free under the Apache-2.0 licence, for personal and commercial use. No account, no card, no trial period.

Since 10 November 2026, when FIRME AI CORPORATION released the first three packages under Apache-2.0.

Apache License 2.0. You can use, change and redistribute the code, including in commercial products. The names CAIN-42, PROOFLOOP and FALSEWORK are trademarks and are not licensed.

FIRME AI CORPORATION, a California corporation based in San Francisco.

Open https://cainstudio.online/open-source/try.html and press 'Load an example'. All three tools run in your browser in a few seconds, with nothing to install.

No. The open-source tools need no account and no key. Keys are only for the hosted CAIN Studio services, which have a free plan.

No. FALSEWORK and PROOFLOOP's verdicts are deterministic: the same code always gets the same answer, and no model decides anything.

Code that looks finished but fakes the hard part: a 'measurement' that is a random number, a security check that returns True when it crashes, a benchmark that prints PASSED no matter what.

A system where no single component is trusted on its own word. CAIN-42's evidence is co-signed by four independent validators in four US regions, and three must agree, so one faulty or dishonest node cannot change the record.

Most scanners say 'this might be a bug'. PROOFLOOP runs the attack against your own function in a sandbox and reports CONFIRMED only when the payload actually reaches the dangerous call.

pip install https://cainstudio.online/open-source/falsework-0.1.0-py3-none-any.whl then run: falsework scan .

pip install https://cainstudio.online/open-source/proofloop-0.1.0-py3-none-any.whl then run: proofloop scan .

pip install https://cainstudio.online/open-source/proofloop_verify-0.1.0-py3-none-any.whl then run, for example: proofloop-verify-pure record.json

Python 3.9 or newer.

FALSEWORK, PROOFLOOP and proofloop-verify-pure use only the Python standard library. The other proofloop-verify commands use the 'cryptography' package (pip install cryptography).

FALSEWORK, proofloop-verify and 'proofloop scan' work anywhere Python runs. Proving exploits with 'proofloop scan --prove' needs Linux with bubblewrap (WSL2 on Windows should work).

Bubblewrap (bwrap) is a small Linux sandbox. PROOFLOOP uses it to run the attack against your function with no network and a read-only system, so nothing real is ever executed. Install it with: sudo apt install bubblewrap

Yes. Source archives (tar.gz and zip) for all three packages are at https://cainstudio.online/open-source/ .

Every file's SHA-256 is published in https://cainstudio.online/open-source/SHA256SUMS . Run: sha256sum -c SHA256SUMS. Each archive is the exact commit recorded on 10 November 2026.

Not yet. Install directly from the cainstudio.online URLs above; they are the official release files.

The GitHub repositories are being set up. Until then the official source is https://cainstudio.online/open-source/ .

Yes. Once installed, all three tools run without any network connection.

Run 'falsework scan .' in the project folder. It skips vendored and hidden folders such as node_modules, .git and virtual environments.

Python, JavaScript and TypeScript.

STUB: at least one critical finding (something reports a result it never computed). PARTIAL: high or medium findings. REAL: none of the checks fired, which is not proof the code is correct. UNKNOWN: nothing could be analysed, and it is never reported as REAL.

0: nothing at or above --fail-on (default HIGH). 1: findings. 2: usage error. 3: nothing could be analysed.

Use --json for JSON, or --sarif out.sarif to write SARIF 2.1.0 for GitHub code scanning and other tools.

Fakes and random data are normal in tests, so test files are skipped. Files under examples/ or docs/ are reported but not counted.

It is heuristic, so review each finding. Seeded simulations or deliberate test doubles can trigger it. Please send us the false alarm; every one we receive improves the rules.

Yes. It exits 1 when a finding at or above --fail-on is found. Use --fail-on CRITICAL to block only on critical findings, or --fail-on NEVER to only report.

That is not its job. It finds fabricated results and checks that cannot fail. For security bugs such as injection, use PROOFLOOP.

Each check came from a real defect found in CAIN-42's own codebase. We run FALSEWORK on our own code continuously.

Security bugs in Python where outside input reaches a dangerous call: command injection (CWE-78), code injection (CWE-94), SQL injection (CWE-89), path traversal (CWE-22) and unsafe deserialization (CWE-502).

An HTTP route parameter, a request object, an MCP tool argument, or model output that reaches the dangerous call.

BIG: a bug an attacker can trigger from outside input, or a guard that says yes without checking. HARDENING: worth fixing, not urgent. REVIEW: a person should look.

With --prove, PROOFLOOP ran the attack against your function in a sandbox and the payload reached the shell, eval, the SQL text, the file path or the unsafe loader on the exact line it reported.

The attack did not reach the dangerous call when the function was called on its own, or the function could not be called in the sandbox. The reason is always shown, and it is never upgraded to CONFIRMED.

Yes. Every dangerous call (shell, eval, SQL, file operations) is replaced with a recorder before your function runs, inside a sandbox with no network. Nothing real is executed.

No. Missing packages are replaced with inert stand-ins, so some real bugs come back NOT_CONFIRMED.

Detection is heuristic. On fresh, untuned Python repositories, about half of the BIG findings were real bugs in our own evaluation. That is why the sandbox proof exists: it separates a guess from a bug.

PROOFLOOP recognises shapes that are usually not real bugs, for example test fixtures, input validated before use, or tools whose job is to run a command. The reason is shown with the finding.

0: nothing at or above --fail-on (default BIG). 1: findings. 2: usage error. 3: no Python files found.

Yes: proofloop scan . --sarif out.sarif

No, Python only. The hosted PROOFLOOP adds JavaScript/TypeScript, Go, Java, Rust and C/C++.

The community edition finds and proves. Fixes proved by an independent test are part of the hosted service.

If the free 'falsework' package is installed, PROOFLOOP includes its findings in the same scan.

Yes: https://cainstudio.online/proofloop/live runs curated samples live in our sandbox.

It checks signed PROOFLOOP records on your own machine: that they were signed by the pinned key, have not changed by a single byte, and that their numbers follow from their own data.

proofloop-verify-pure. It implements Ed25519 in pure Python and runs on minimal containers, Termux on Android, anywhere Python 3 runs.

That the record was signed by the holder of the pinned key and has not been altered. It does not prove the finding is important or that a third party audited PROOFLOOP.

Save the DSSE envelope from the PR comment as envelope.json and run: proofloop-verify-pr envelope.json --commit <head sha>

curl -fsSLO https://cainstudio.online/verify_proofloop.py && python3 -I verify_proofloop.py It downloads our public proof from three mirrors and runs seven checks, including that a one-byte change is rejected.

It is built into every verifier with its fingerprint. Compare the fingerprint with the one published on cainstudio.online, or pass --public-key with a key you obtained another way.

Proof that 3 of the 4 CAIN-42 validators committed a record's hash at a given sequence. Consensus co-signs a result; it never changes or authorizes one.

Yes: open https://cainstudio.online/open-source/try.html, choose proofloop-verify and paste the record.

Yes. The PROOFLOOP source includes action.yml: it installs the tool, runs the scan (and the proof, if enabled) on your own runner, and uploads SARIF to GitHub code scanning.

You do, on your own runner. The free tools never run on our servers in CI, so there are no quotas.

Install it with pip and run 'falsework scan . --sarif falsework.sarif'. A non-zero exit fails the job.

In the repository's Security tab, under code scanning, when you upload the SARIF file.

Yes, that is the default: proofloop scan . --fail-on BIG

It is coming next: it will comment on every pull request with findings, sandbox proofs and a signed record co-signed by the CAIN-42 quorum, with no CI setup. Early access: email firmeai2026@gmail.com. Until then, use the free GitHub Action.

It loads Python compiled to WebAssembly (Pyodide) and runs the same published wheels, after checking each one against its SHA-256.

No. Everything on https://cainstudio.online/open-source/try.html runs in your browser. Nothing is sent to us.

That box sends your code to our server to scan it. It is scanned, never run, and not stored. For full privacy, use try.html or the command-line tools.

Your browser downloads Python once (about 10 MB). After that it is cached.

No. Proving needs a real sandbox, so run 'proofloop scan . --prove' on Linux, or use the GitHub Action.

Yes: huggingface.co/spaces/vicentenoriega/CAIN-42 has the same tools, ready to use.

No. These sites set no tracking or advertising cookies and load no third-party analytics.

No. They make no network calls (except proofloop-verify-sample, which downloads the public sample you ask it to).

Privately, via https://cainstudio.online/security#report . Please do not open a public issue for a vulnerability.

Yes: $1,000 if you make our offline verifier accept a PROOFLOOP record we never signed. Rules: https://cainstudio.online/proofloop-bounty.html (open until 28 February 2027).

Not yet, and we say so publicly. When an independent audit or SOC 2 report exists, it will be linked from the trust centre.

On the claims vs evidence page: each claim is marked live, built or not yet, with a link to its proof.

Yes. FALSEWORK only reads code; it never imports or runs it.

Free and open source: FALSEWORK, PROOFLOOP community (Python, five bug classes, local proof) and proofloop-verify. Free hosted: the CAIN Studio free plan, whole decision path included. Paid: bigger hosted plans ($19.75 and $49.75 a month), MCP security assessments ($500), AI fixes proved by an independent test ($500 each) and MCPGate pilots in your own infrastructure. Coming next: a hosted PROOFLOOP GitHub App.

Yes. Released versions are Apache-2.0 forever; a licence cannot be taken back from code you already have.

A review of one MCP server or agent (up to 20 tools) in three business days: findings reviewed by a person, a per-tool allow / approve / deny policy and a signed evidence bundle.

We write the fix, re-run the same exploit against it, and give you a signed record that it holds. It is $500 per proven fix, with a full refund if we cannot prove it.

Free: $0, no card, 10,000 decisions a month. Professional: $19.75/month. Enterprise: $49.75/month. Every plan gets the whole decision path; plans differ by scale. Details: https://cainstudio.online/pricing

Yes, under the Apache-2.0 terms: keep the licence and NOTICE files, and do not use our trademarks as your product name.

Community support by email. Paid customers get direct support and service levels.

Install bubblewrap (sudo apt install bubblewrap on Debian/Ubuntu) or run without --prove to scan only.

The path has no .py files, or they are all inside skipped folders such as .venv or node_modules. Point it at your source folder.

Nothing could be analysed: for example only test files, or files that are not valid Python or JavaScript. UNKNOWN is never a pass.

Check your connection, or download the wheel from https://cainstudio.online/open-source/ and run: pip install <file>.whl

Please send us the file or a small reproduction. Line numbers come from Python's own syntax tree, so a mismatch is a bug we want to fix.

Reload the page. If it persists, do not use the tools from that page, and tell us: it means the file you received is not the one we published.

Scan the folders you care about, for example 'falsework scan src', and skip generated code.

Send fixes, new checks or false-alarm reports. Every commit needs a Developer Certificate of Origin sign-off (git commit -s).

Deterministic, no model and no network, with a test that fires on fabricated or vulnerable code and stays quiet on honest code.

Yes. Import falsework.engine and call scan_source({filename: source}); it returns the grade and findings as plain data.

Yes, Apache-2.0 allows forks. Please give your fork its own name; CAIN-42, PROOFLOOP and FALSEWORK are our trademarks.

Email firmeai2026@gmail.com or call 1-844-CAIN420.

Email firmeai2026@gmail.com with the subject 'CAIN-42 demo'.

The API reference is at https://cainstudio.online/docs, the open-source page at https://cainstudio.online/open-source/, and each package has its own README.

See the live status page and the green dot in every footer; the trust bar on the homepage shows the live validator quorum.

An optional 150-question exam on how CAIN-42 works. Master the 28 learning bubbles on the homepage to get your key; pass with 90% for a certificate.

1) Try it in your browser at https://cainstudio.online/open-source/try.html. 2) pip install FALSEWORK and run it on your code. 3) Run 'proofloop scan . --prove' on a Linux machine. 4) Add the GitHub Action.