Governed runtime for production AI
Every action.
On the record.
Wrap any AI call in veynit.run(). Get back the result and a tamper-evident signed receipt, independently verifiable with no call to Veynit.
How it works
Three checkpoints. One proof.
Governance is not a dashboard you check after the fact. It runs inline, on the action, before it executes.
Intercept
Every AI action passes a runtime checkpoint before execution. No action runs uninspected. The checkpoint records the action, the caller, and any policy constraints.
Sign
An Ed25519-signed receipt is issued for the outcome: action, result, cost, and timestamp. Canonical bytes, hash-chained. The signing key never leaves the runtime.
Return
Your function receives both the result and the receipt. The proof travels with the output, not behind it. Verify offline with the public key: no account, no network call.
The receipt
This is what proof looks like.
Every Veynit receipt is a JSON document signed with Ed25519. Anyone holding the public key can verify it offline. No network call, no Veynit account.
- 01
Canonical hash
SHA-256SHA-256 of the canonical payload: every field, sorted, no whitespace. Rewrite a single byte and the hash fails.
- 02
Ed25519 signature
ED25519A signature over the canonical bytes. Requires the private key to forge; requires only the public key to verify.
- 03
Asymmetric, not HMAC
ASYMMETRICAlways ed25519. You verify without ever seeing the private key. No shared secret, no Veynit account.
- 04
Tamper-evident
INTEGRITYThe hash covers every byte of the signed payload. Alter any field, the action, the cost, the outcome, and verification fails.
- 05
Independently verifiable
OFFLINEAnyone holding the public key can verify any receipt, offline, without contacting Veynit. No API call, no trust relationship.
- 06
No account required
PORTABLEVerification is a one-liner and a public key. Not a dashboard, not a login. The proof belongs to the receipt holder.
SDK
Three lines to governed AI.
from veynit import Veynit
veynit = Veynit(key=os.environ["VEYNIT_KEY"])
result, receipt = veynit.run(
action="voice.call.completed",
fn=lambda: client.calls.create(
to="+17025550198",
from_="+18449803424",
),
)
assert receipt.hash_valid and receipt.sig_valid
# receipt.id == "veynit_rec_94b8b2d499ad4959"Zero dependencies
Pure node:crypto and the Python standard library. No vendored crypto: the runtime handles signing.
Fails closed
If the control path fails, execution blocks. If observation fails, fn() still runs and the receipt carries unreceipted: true.
WebCrypto verify
Browser and Deno verification ship with the SDK. The same Ed25519 proof, any runtime.
Lifecycle
From call to countersigned.
Intercept
The call is caught at the runtime boundary.
Checkpoint
Policy and limits are evaluated before execution.
Sign
Canonical bytes are hashed and Ed25519-signed.
Verify
hash_valid and sig_valid resolve, offline.
Who it's for
A log can be rewritten. A signed receipt cannot.
Developers
Three lines to a governed call. Drop the SDK in, wrap the function, ship with proof attached.
CTOs
A verifiable action trail across every AI system you run, without building crypto infrastructure yourself.
Compliance
Receipts an auditor can verify independently. No dashboard access, no trust in our logs required.
Regulated industries
Tamper-evident evidence that an AI action happened, what it cost, and what it produced. On the record.
Book a demo
Put your AI on the record.
Talk to us about governed runtimes for your stack. We work with developers, CTOs, and compliance teams who need verifiable AI action trails.
hello@gentic.pro