Entropa Gate_

Control what your AI can read and send. Prove what it did.

Entropa Gate is an app you install on your own machines, with your own keys. It limits what an AI may read and send, enforces who may use it, and writes every decision to the Entropa Audit Trail, a tamper-evident, post-quantum-signed record that anyone can check without trusting us. The Gate enforces; the Audit Trail proves. We never see your data. For anything specific to your business we offer custom analysis and governance work, after a free fact-finding meeting.

Rust · runs on your side · your keys · no logins

Two parts, one mission

The Gate decides and enforces. The Audit Trail records and proves. Each has its own page, so you can see exactly which part does what.

Entropa GateGate (you are here)
Decides and enforces. It limits what an AI can read, checks what leaves, and asks a person to approve big actions. The primary product.
Status: the parts are built and measured (some fail their own tests, and we say so); the single installable package is in progress.
This page
Records and proves. A tamper-evident, post-quantum-signed record of every decision, with independent witnesses and an offline verifier. The Gate writes to it; it also works on its own for any AI system.
Status: built and running for our own systems.
Open this page →

Our mission: verify, don't trust

AI systems are being trusted with decisions about people's money, health, work and safety, and almost no one outside the vendor can check what they did or why. We think that is dangerous. Entropa exists to make AI and LLM security, and tamper-evident, post-quantum-signed audit trails, free and open for everyone: tools that limit what an AI can read and send, and a signed record of every decision that anyone can verify for themselves, today and after quantum computers. We publish our results, including every failure, because public safety needs proof, not promises. See the results · GitHub

The app: Entropa Gate_

One app that you install on your own Linux machine. It sits between your AI and the people and systems around it, and it keeps a signed record of everything it decides. You keep the keys and the records. We never see your data.

What it does for you
1. Limits what the AI can read. Each person or agent gets only the access their role needs.
2. Checks what leaves. Secrets, personal data and your do-not-send terms are blocked or removed before anything goes to a model or tool.
3. Needs a person for big actions. High-impact actions wait for a signed human approval.
4. Keeps proof. Every decision becomes a tamper-evident, signed record that you or an auditor can check offline, without trusting us.
What you need (we do not provide these)
1. A Linux machine (x86_64, glibc 2.34 or newer). 2. Basic tools: curl, jq and git. 3. Your own AI model: the app does not include, host or support a model; you bring the one you use, running locally or from a provider you already have, and you set it up yourself. 4. Your own keys: you create and keep them. 5. A web browser to view your explorer. Step-by-step setup. Everything is at your own risk, with no warranty (see below). Want us to set it up for you and train your team to use it? Contact us; see custom work.
Platform
Linux only. It is not available for Windows or any other platform. It is one package: the guard, access tiers, audit trail, your own explorer and the verifier install together. That single package is still being assembled; today the pieces below are built and tested separately.

Features, and what is built

The Audit Trail (its own page) · Built
Every decision the Gate makes is written to the Entropa Audit Trail: a hash-only, post-quantum-signed, independently witnessed record you can verify offline. Built and running for our own systems. Read about the Audit Trail →
Standards guard · Built, measured
A read-only service that gives an AI exact clauses from sealed, versioned standards and refuses when it is not sure. Measured on sealed tests with the failures shown.
Policy gate and approvals · Built
Default-deny rules in code, a closed list of allowed actions, and a person's signed approval for high-impact ones.
Access tiers and signed tokens · Built, measured
Public, staff, agent and build tiers, with narrow, short-lived tokens issued by your own key, default-deny rules, and two-person approval for changes. Attack-tested on our own sealed sets: one real hole was found (a child token accepted without its parent) and fixed; the result is published. No independent review yet.
Egress Guard · In progress, measured
A local check on everything leaving toward a model or tool: it redacts or blocks secrets, personal data and your do-not-send terms, and fails closed. Built and tested in eight sealed rounds. The first design (pattern matching) leaked secrets in every round; the sixth round leaked 45 percent. The redesign checks what is allowed to leave instead of what looks like a secret. In the eighth round it let through none of 315 secret-shaped test texts (random tokens, card, SSN and phone numbers in every odd shape, hyphen and capital-letter tricks) and none of 58 bad structured requests. It still cannot stop a secret written as ordinary words or a short digit code (up to 8 digits can pass, about 27 bits per message), it refuses everything that is not plain English, and on realistic business sentences it wrongly refused 28 percent, above our 25 percent target (dates written with slashes and words like 4th are refused today). All of this is measured and published; a fix for the date forms is planned. The redesign ships in a later release. Included in the app at no extra charge.
Test harness · In progress
Sealed attack sets, fuzz tests and mutation tests are built and used on our own code (they found real bugs). Packaging them so you can re-run the same style of checks on your own setup is still to do.
Your own explorer and dashboard · In progress
A viewer you host yourself, showing your own records. A static explorer that is generated from a ledger and verifies it with a command line tool is built and tested on mock data; it has not been through a real-browser pass or a pilot. No shared explorer, so no one else sees your trail.
Your keys, your machines · In progress
You generate and keep the signing keys and we never hold your data. A client-side binary that holds its own key and has a reproducible build is built; signed release manifests and an offline licence are in progress. No customer has run it yet.
Want us to set it up and train your team? Contact us →

See the measured results, failures included. No claim of certification or compliance: results are "tested against our own sealed sets" and evidence is "mapped to" the standards. No independent review has been done yet.

Custom work, tailored to you

The app does not cover what is specific to your business. That is custom work.

Setup and integration
Getting the Linux host, your AI model, your keys and the app working together on your systems, and fitting it to how you already run things.
Training
Hands-on training for your team: how to run the app, read the records, check them offline, and keep it healthy.
Architecture and infrastructure review
How your AI systems are built and where data flows, with a written tier map and a list of what to change.
Custom analysis of your AI use
Attack tests built from your own data and use case, run on sealed sets, reported with counts and failures included.
LLM and AI governance work, tailored to you
Policies, tiers, approval flows and evidence packs fitted to your standards and your risks, plus scheduled re-tests.

How it starts: a free fact-finding meeting. If there is a fit, we send a written proposal with the scope.

How the Gate fits in

Everything below runs on your Linux machine. The Gate and the Audit Trail are two parts with a clear line between them.

Your Linux machine: your data and your keys never leave it ENTROPA GATE: decides and enforces Your AI appsand agents The Gateaccess tiers + signed tokensEgress Guard (checks what leaves)default-deny policy gateperson approves big actionsstandards retrieval + MCP The AI modelyou bring it ENTROPA AUDIT TRAIL: records and proves Signed recordhash-only, ML-DSA-65 Ledger + checkpointsappend-only Merkle log Explorer + offline verifieranyone can check, trusting no one Independent witnessoptional extra proof every decision is written to the Audit Trail

Your apps send the Gate requests. The Gate decides what is allowed, removes anything that should not leave, asks a person to approve big actions, and passes the rest to the model you bring. Each decision is then written to the Audit Trail, a separate part that stores only hashes and fixed codes, never your data, and lets anyone verify the record offline. A witness is an optional separate service that also signs the ledger's checkpoints. Which parts are built and which are in progress is listed in the features above and in the roadmap. The Audit Trail has its own diagram on its page.

Built, and what is next: Gate and Audit Trail

What runs today, and the planned architecture, labelled honestly.

Signed Merkle ledger · BuiltAudit Trail
Append-only log with ML-DSA-65 signed checkpoints, inclusion and consistency proofs.
Cedar policy gate and approvals · BuiltGate
Agents act inside a written policy; hard actions need a person's signed approval.
Read-only MCP server and command guard · BuiltGate
AI agents can query the ledger read-only; a guard blocks destructive commands for the build agents.
Serverless ingest and node CLI · BuiltAudit Trail
Stateless ingest, one signing writer. Deployed and verified on Cloud Run (private, scales to zero), or run as a single binary on-prem.
Keyless contact service · Built
The Rust service behind the contact form: no address on any page, no key file (it signs with its own cloud identity), spam limits.
Witness · BuiltAudit Trail
An independent service co-signs the ledger's checkpoints only when a consistency proof links them to the last one it saw. Forks and rollbacks are refused and logged. It runs on a different cloud from the ledger (Azure now, temporary and credit-funded), its statements travel in the bundle, and the browser verifier checks them.
In-browser verifier · BuiltAudit Trail
Both explorers verify every signature, hash, Merkle root and witness statement in your own browser, with a self-contained script and only the public key.
Managed-key signing (Google Cloud KMS) · BuiltAudit Trail
The cloud node signs every event and checkpoint with a managed ML-DSA-65 key in Google Cloud KMS. No key file is stored anywhere; the public key is published.
Multi-cloud witnesses · BuiltAudit Trail
Two independent witnesses, one on Azure (temporary, credit-funded) and one on AWS Lambda (signing with an AWS KMS key), co-sign the AI-decision ledger's checkpoints, and the browser verifier checks both. The ledger itself signs on Google Cloud, so three providers are involved. Limit: the three ledgers share one signing key and a witness can follow one log per key, so only the AI ledger is witnessed today; separate keys are next.
Per-module pipelines · BuiltAudit Trail
Each module has its own format, lint and test run and its own signed receipt in the evidence ledger; only changed modules run, and one failing module is recorded without hiding the others (a failure and the fix are both on the ledger). It runs locally and as a path-filtered CI workflow; deploys of each service record signed receipts. Not yet running on a hosted CI runner.
Controls-evidence event types · BuiltAudit Trail
Signed, hash-only events for control checks, access decisions, changes and policy events, each carrying a closed control code. New labels for a crypto inventory and a log-integrity check are written and tested locally; they reach the live node only after review.
Self-assessment of our own estate · BuiltAudit Trail
A control-by-control assessment of our own sites and services against clauses we read in the primary texts: a machine-checked register, a read-only crypto inventory (CycloneDX), a tamper demonstration, and a report that lists our gaps. Results are published as measured, gaps included: read the self-assessment.
Standards retrieval in Rust, with an MCP server for our agents · In progressGate
A versioned, sealed corpus of the standards, queried by our agents as a source of truth. Every retrieval is a signed record, and our guardrails cite the clause and version they came from. Enforcement stays in code.
Client-installed binary with client-held keys · In progressGate
One binary you run yourself, with your own signing key and your own dashboard. Hash-only records; we never hold or see your data. The first client-side binary and its reproducible build exist; next are a private pilot, independent review, then a public offer.

Why Rust, and where we use other languages

Everything that makes a security decision or signs a record is written in Rust: the ledger, the signing and verifying, the policy gate, the Egress Guard, the access tokens, the standards retrieval and the servers. Rust is the key to the whole project. Other languages play supporting roles only.

Memory safety, by construction
Most serious vulnerabilities in systems code are memory bugs (buffer overflows, use-after-free). Rust rules out that whole class in safe code, which matters most in software whose job is to be trusted.
One small static program
Rust builds a single, self-contained Linux binary with no runtime to install and few dependencies, and we rebuild it reproducibly so you can check that what you run matches the source.
The compiler as a reviewer
Strict types, explicit error handling and no hidden null values push whole categories of mistakes to compile time, and make "fail closed" the natural way to write a guard.
Fast and predictable
No garbage-collector pauses, so checks on every request stay quick and steady, and the same code can run on a small machine you own.
Supporting languages
Python for test runners and analysis scripts, shell for build and packaging, and a little JavaScript for the in-browser verifier. None of them sign records or make decisions. By GitHub's count about 84 percent of the repository is Rust.
What Rust does not do for us
Safe Rust does not remove logic errors, bad design or weak cryptography choices, and the project is a research prototype with no independent review yet. Our own sealed tests still find real bugs, and we publish them.

Use at your own risk

Everything here is provided as is, with no warranties or guarantees, express or implied. You run it and use it at your own risk and your own skill, and the author accepts no liability to the maximum extent the law allows. Our test results describe our own tests on a given day, not how it will behave on your systems, and nothing here is legal, security or compliance advice. See the terms of use.

Free and open source

The app is free and open source under Apache-2.0. We do custom work on top of it.

The application source under Apache-2.0: the ledger, verifier, policy gate, Egress Guard, access tokens and tiers, the try-the-gate server, the standards retrieval, the sealed test runners, and every plan and measurement. Published as a research prototype: nothing has had an independent review.
Only the early crates published to crates.io (entropa-core and entropa-node), kept for the package registry. All current code, the Gate and the audit trail, is in entropa-gate.

The source is published: you can read, run and check all of it yourself. Licence: Apache-2.0 for the code (use it, change it, sell it, with an explicit patent grant; you keep our copyright notice and credit) and CC-BY-4.0 for the documentation. The name "Entropa" stays ours, and standards texts that are licensed to us are never included. The code is published at github.com/aimozart/entropa-gate. We earn our living from custom work, so the code is a full giveaway. If you want help fitting it to your systems, custom work starts with a free fact-finding meeting and a written proposal.

Frequently asked questions

About the Gate. Questions about the signed record (blockchain, tamper-evidence, what is stored) are on the Audit Trail page.

What is Entropa Gate?

Entropa Gate is an app you install on your own machines, with your own keys. It limits what an AI may read and send, enforces who may use it, and keeps a tamper-evident, post-quantum-signed record of every decision that anyone can verify without trusting us. The audit trail is part of the app.

Is it open source?

Yes. The code is open source under Apache-2.0 and the documentation under CC-BY-4.0, published at https://github.com/aimozart/entropa-gate. It is a full giveaway: use it, change it, sell it, keep the copyright notice. Provided as is, no warranty.

What do I need to run it?

You need a Linux machine (x86_64), your own AI model, and your own signing keys. The app does not include or provide a model: you bring the one you already use, running locally or from a provider.

Does it run on Windows?

No. The app is Linux only. It is not available for Windows or any other platform.

What is built today, and what is not?

Built and running for our own systems: the signed, witnessed audit ledger with an offline verifier, the policy gate with approvals, and a standards guard measured on sealed tests. Also built and attack-tested on our own sealed sets: signed access tokens and tiers with two-person change control. In progress: Egress Guard (it still leaks secrets in our own sealed tests; the numbers are published), the test harness, your own explorer and dashboard, and the client-installed package with your own keys. No customer has used it yet and no independent review has been done.

What do I get with the app, and what is custom work?

The app gives you all of its features. Custom work is anything specific to your business: an architecture and infrastructure review, custom analysis and attack tests built from your own data and use case, and AI governance work tailored to you. It starts with a free fact-finding meeting, then a written proposal.

Is Entropa a cryptocurrency or a blockchain?

No. There is no token, no mining and nothing to speculate on. It is a signed, hash-chained audit log with independent witnesses, which is what auditors need: tamper-evident, not a coin.

Do you ever see our data?

No. The app runs on your side and records hashes, closed codes and counts, never the underlying text or personal data. Independent witnesses store only fingerprints of the log.

Does it make our AI secure or compliant?

No tool does that alone, and we do not claim it. The app limits what the AI can read and send and proves what happened. Our results are 'tested against our own sealed sets', with the failures published, and evidence is 'mapped to' standards, never certified.

Is it free?

The app is free and open source (Apache-2.0, published on GitHub). Custom work, such as architecture review, custom attack tests and governance work for your setup, starts with a free fact-finding meeting and a written proposal.

Can I run it on my own infrastructure?

That is the design: you run it on your own machines or cloud and keep the keys and the data. The client-installed package is still being built; today a node runs as a single Rust binary or container.

Which standards is the evidence mapped to?

We hold verified texts for DORA RTS, PCI DSS 4.0.1, NIST SP 800-53, the EU AI Act and HIPAA 164.312 and mapped 17 controls on our own estate: 1 met, 11 partial, 5 gaps, gaps listed first. It has not been independently assessed or certified.