Payments, finance, files, receipts and decisions made by superintelligence (SI) agents stay private on your own systems. Their fingerprints are anchored on a post quantum network and can be proven to any court or regulator.
Regulators in the European Union, the United Kingdom, the United States, Japan, Korea, Singapore and Hong Kong require automated systems to keep records that are traceable, retained and protected against alteration. Qstamp gives every agent action a private fingerprint that can be verified independently of the company that made it, and that remains valid after quantum computers break classical signatures.
Live on the Quantova Virtual Machine. Integrates with SI models and agents today.
npm install @quantovainc/qstampQstamp is a post quantum evidence toolkit for superintelligence (SI) agents that keeps every record private. SI, short for superintelligence, is the term Quantova uses for the systems commonly called AI. Its SDK fingerprints each agent action and decision on the company's own systems and anchors only a salted cryptographic commitment on the Quantova network. Organisations in banking, government, healthcare and finance can then prove to courts, auditors and regulators exactly what their agents did and when, without disclosing the records themselves. The evidence cannot be forged by a quantum computer.
Where agent logs, audit trails and smart contracts are signed today, they are signed with ECDSA over secp256k1 or P 256, EdDSA over Ed25519 or RSA. Shor's algorithm breaks all three, after which a forged record cannot be told apart from a genuine one.
Accounts, transactions, contract code attestation and finality certificates on Quantova are signed with ML DSA as specified in FIPS 204. The protocol accepts no classical signature at any layer.
The records, their fingerprints and their receipts stay with the company. Only a salted commitment is anchored, which anyone can verify and no one can read. A receipt remains verifiable for the full retention period that the law requires.
Public record means that anyone can check that a record existed and has not been altered. It does not mean that anyone can read it. Prompts, agent inputs and outputs, personal data and payment details never leave the systems of the company that runs the agent.
Each record is fingerprinted on the company's own systems with SHA3 256 and a fresh 256 bit random salt before anything is sent. The fingerprint is one way. It cannot be turned back into the record, and the salt prevents anyone from confirming a guess, even for a short or predictable prompt. A record is disclosed only when its owner chooses to produce it, for example to a court or a regulator, together with its receipt.
Energy use is now a reporting duty for data centres and for the organisations that rely on them. Qstamp proves what SI agents did without new hardware, new storage or mining. The SDK runs inside the systems a company already operates, and a single anchoring transaction covers up to a million records.
The SDK runs on the servers a company already uses. It needs no GPU, no model training and no separate storage cluster, because records are never copied to Quantova.
A record is fingerprinted with SHA3 256 in microseconds on an ordinary processor. In our benchmark, 65,536 records were fingerprinted and combined into one hash tree in under one second.
Up to 1,048,576 records share one anchoring transaction with a fixed fee, so the network work for each record falls towards zero as batches grow.
The Quantova network finalises each block with committee signatures under ML DSA 65, not by proof of work, so anchoring consumes no mining energy.
Organisations that report energy and emissions, for example under the EU Energy Efficiency Directive or sustainability reporting rules, can add tamper evident records of their SI agents without adding new infrastructure to that report.
SI systems now write code, design experiments, tune models and increasingly contribute to the research that improves SI itself. As capability grows with less human involvement in each step, the actions and decisions of these systems become harder to observe. Today there is no common, tamper evident record of what autonomous and superintelligence agents actually did. Qstamp is built to provide that record, so that the growth of these systems remains accountable to the people and institutions they serve.
Qstamp fingerprints each agent action, model change and decision as it happens and anchors one salted commitment for each batch on chain. Operators, auditors and regulators can later recall exactly what an agent did and confirm that it acted within its mandate.
The fingerprints are anchored on Quantova, which signs every account, transaction, contract and finality certificate with post quantum signatures from its first block. No classical signature scheme is inherited anywhere in its accounts, contracts, stored commitments or consensus.
Each anchoring transaction can be checked on QVMScan, the Quantova explorer, which shows when a batch was fixed and by which account. The explorer never shows the content of a record, because the content never leaves its owner.
Most agent records sit in a database controlled by the party being audited and are protected by signatures that quantum computers will break. Qstamp moves the proof outside that boundary. Each record is reduced to a fingerprint and anchored with post quantum signatures, and anyone can check it without seeing its content.
Across the largest economies, the law now requires operators of automated and AI systems to record what those systems do, to retain the records and to protect them against alteration. Qstamp produces evidence that supports those duties and remains verifiable after classical cryptography is broken.
High risk AI systems must technically allow the automatic recording of events over their lifetime, and providers must keep those logs for at least six months.
Each logged event is anchored, so its integrity can be shown for the full retention period.
Personal data must be processed with appropriate security, including protection against unauthorised processing and accidental loss or damage. Regulated firms must keep orderly records sufficient for the regulator to monitor compliance.
Tamper evident proof that records are complete and unaltered, without publishing their content.
Electronic records must be kept with measures that ensure their authenticity, such as time stamps or a history of corrections and deletions. The AI Promotion Act makes transparency in the development and use of AI a basic principle.
Integrity and time evidence for every record, complementing accredited time stamps and correction histories.
Operators of high impact AI must establish risk management, explanation and user protection measures and keep documents that show them. Records of access to personal information must be kept and protected against forgery and alteration.
Tamper evident records of decisions and access that a regulator can verify independently.
Data users must take all practicable steps to protect personal data against unauthorised or accidental access, processing, erasure, loss or use. Authorised institutions must manage technology risk, including the integrity of their systems and of the records those systems hold.
Verifiable fingerprints of agent records and SI output, so that their integrity can be demonstrated to the HKMA, the Privacy Commissioner or a court.
Broker dealer records must be kept in a non rewriteable, non erasable form or with a complete time stamped audit trail. Federal systems must migrate to post quantum key establishment and signatures.
A time stamped, tamper evident audit trail signed with post quantum cryptography from the start.
Qstamp supplies evidence that supports these obligations. Each organisation remains responsible for meeting the full requirements of the laws that apply to it. Full mapping by jurisdiction
Qstamp anchors the mandate that authorised the agent, the payment it intended, the control decision that approved it and the settlement that followed. Each record is linked to the one before it, so a bank, a supervisor or a court can verify the whole chain from authority to settlement.
The mandate and the intended payment are anchored before any instruction is sent, so the record of what was permitted and what was intended cannot be changed later.
The sanctions, limit and anti money laundering checks, any human approval and the settlement confirmation are anchored and linked to the intent.
Every link is verified independently, and a missing, altered or reordered record is detected, for the full ten year retention period that payment rules now require.
Thirteen steps in four phases, namely set up, integrate, operate and prove. Every value shown is taken from a real deployment of Qstamp on the Quantova Virtual Machine, and any company that integrates Qstamp follows the same procedure.
The SI company adds the open source Qstamp SDK to the service that runs its agents. It has one dependency, QCore, for post quantum signing.
$ npm install @quantovainc/qstamp added 2 packages $ npx @quantovainc/qstamp --version 0.1.4
A signing key is created on the operator's own server or hardware security module. Its account is funded and registered once on the Quantova network.
$ openssl rand -hex 32 > signer.key && chmod 600 signer.key $ node account.js address Q1NUR6ETECQXEVE77TJ9YPZ6WAWYMT45WCJANV5J43X93SF79DWE0S0D572X status registered, ready to stamp
The company stamps through the official Qstamp contract, or deploys its own issuer contract from the Quanta templates. Its own contract is compiled in QIDE at qdock.io by the attested Quanta compiler and deployed with the QMask wallet.
When a model is approved for use, its passport is stamped with the record kind ai_model. Every later decision can then be linked to the exact model that made it.
{
"evaluation": {"approved_by": "Model Risk Committee", "auc": 0.871},
"model": "risk-model 3.2.1",
"time": "2026-10-09T09:39:27.273Z",
"training_data": "dataset manifest 2026-09-30",
"weights_sha3": "f01483b8e6269760c5c2e2025875b6e5d1b16402443e9a98d73e0a43156bf17b"
}The agent runtime writes every tool call and decision as a canonical record, keeps it in the company's own log and anchors the batch every minute. The receipts are stored beside the actions.
const qstamp = require('@quantovainc/qstamp');
const batch = [];
agent.on('action', (action) => {
const bytes = Buffer.from(canonicalJson(action));
log.write(bytes);
batch.push({ digest: qstamp.digestBytes(bytes) });
});
setInterval(async () => {
const records = batch.splice(0);
if (records.length === 0) return;
const receipts = await qstamp.stamp({
seed, index: 0, kind: 'ai_agent_action', records,
onPending: savePending,
});
receipts.forEach(storeBesideAction);
}, 60000);A credit decision agent at a bank approves a loan. Its action is written as a canonical JSON record with the agent, model, policy, tool, decision and time.
{
"agent": "credit-decision-agent-07",
"amount_usd": 125000,
"applicant": "APP-54a49c823275",
"decision": "approve",
"human_review": false,
"model": "risk-model 3.2.1",
"operator": "Example Bank plc",
"policy": "retail-lending-policy 2026-10",
"reasons": ["score_above_threshold"],
"risk_score": 645,
"time": "2026-10-09T09:39:25.132Z",
"tool": "credit_bureau.lookup"
}On the operator's own systems, the SDK computes the SHA3 256 bit fingerprint of the record. The record itself never leaves the bank.
$ npx @quantovainc/qstamp hash action-04.json action-04.json
The fingerprint is bound to a fresh random salt and placed in a hash tree with the other actions of the batch. Six actions share one tree root.
The root is bound to the chain, the official contract, the signing account, the record kind and the batch size. The result is one 32 byte commitment.
The SDK sends one transaction that calls the Qstamp Quanta contract on the Quantova Virtual Machine. It is signed with ML DSA 65, a post quantum signature.
Validators finalise the block with post quantum signatures. The contract records the commitment in a Stamped event. The stamp became final in under one second.
Anyone can open the transaction on QVMScan, the public Quantova explorer, and read the commitment, the signer, the record kind and the block.
The bank produces the record and its receipt. The verifier recomputes the fingerprint, the tree root and the commitment, and finds the same commitment on chain. Changing a single digit makes the check fail.
$ npx @quantovainc/qstamp verify action-04.json.qstamp.json --file action-04.json pass format · pass contract · pass content · pass inclusion pass chain · pass transaction · pass event · pass block VALID stamped no later than 2026-10-09T09:39:25Z in block 2011753 $ npx @quantovainc/qstamp verify action-04.json.qstamp.json --file altered.json FAIL content the content does not match the fingerprint in the receipt INVALID
The SDK reduces each record to a 256 bit digest and binds it to a fresh random salt. Content never leaves the operator, and nothing about it can be inferred from what is published.
Up to 1048576 records form a single RFC 9162 hash tree. Its root, the batch size, the chain, the contract, the signer and the record kind are bound into one 32 byte commitment.
Each record carries a receipt. Verification recomputes every link from the record to the finalised block, so trust in Quantova Inc or in the record holder is never required.
Every tool call, decision and output an agent produces can be stamped in batches and verified later by the client, the insurer or the regulator. The record proves what was done, by which system and under which model, and the latest time by which it was done.
Evidence is only as durable as the infrastructure that witnesses it. Quantova has used post quantum signatures for every account, every transaction and every finality certificate since its first block, so the history behind a Qstamp receipt has never depended on a primitive that a quantum computer is known to break.
Accounts, transactions and validator certificates are signed with ML DSA 65. Infrastructure that migrates later keeps its earlier history under breakable keys.
The QVM admits only contract code signed by the attested Quanta compiler, so the stamping contract cannot be swapped for altered code.
The committee that finalises each block is independent of the party that produced the record, so evidence does not rest on self reporting.
Everything an engineering or audit team needs to evaluate Qstamp is public and one click away.
Full source code, the published construction and the release history, open for independent security review.
git clone https://github.com/Quantova/QStamp.gitCommand line tool and library for Node 20 or later, with one dependency, QCore, for post quantum signing.
npm install @quantovainc/qstampOpen, issuer and council Quanta smart contracts. An independent third party audit is required before production deployment.
git clone https://github.com/Quantova/Qstamp-Quanta-Smart-contract-example-.gitPublic endpoint for the Quantova test network. Claim free TQTOV test units to pay the anchoring fee.
https://rpc-testnet.quantova.orgInstall the SDK, fingerprint a file, anchor it and verify the receipt. Open source under the Apache License 2.0 or the MIT licence.
Ask how Qstamp works, how to install it, how to connect it to an SI agent or how it supports regulatory requirements.
Qstamp is a post quantum evidence toolkit for superintelligence (SI) agents that keeps every record private. SI, short for superintelligence, is the term Quantova uses for the systems commonly called AI. Its SDK fingerprints each agent action and decision on the company's own systems and anchors only a salted cryptographic commitment on the Quantova network. Organisations in banking, government, healthcare and finance can then prove to courts, auditors and regulators exactly what their agents did and when, without disclosing the records themselves. The evidence cannot be forged by a quantum computer.
Agent records today rely on classical signatures, namely ECDSA over secp256k1 or P 256, EdDSA over Ed25519 or RSA, all of which are broken by Shor's algorithm. Quantova signs accounts, transactions, contract code and finality with ML DSA and accepts no classical signature in its protocol.
For each record, Qstamp computes a fingerprint on your own systems, combines many fingerprints into one 32 byte commitment and anchors that commitment through a Quanta smart contract on the Quantova Virtual Machine.
Each record then receives a receipt. With the record and its receipt, anyone can later prove that the record existed in exactly that form no later than the anchoring time, without trusting Quantova Inc or the holder of the record.
A valid receipt proves three facts.
A receipt does not prove that the content is true, lawful or approved, and it does not identify a person. It is not a qualified electronic time stamp under eIDAS 2 unless it is issued by a certified qualified trust service provider.
No. Public record means public proof, not public data. Anyone can check that a record existed and has not been altered, but no one can read it.
Prompts, agent inputs and outputs, reasoning, tool calls, personal data, payment details, files and model weights never leave your systems. Each record is fingerprinted locally with SHA3 256 and a fresh 256 bit random salt, and only a 32 byte commitment computed from those fingerprints is published, together with the block, the time, the signing account, the contract and the record kind.
The fingerprint cannot be turned back into the record, and the salt prevents anyone from confirming a guess, even for a short or predictable prompt. A record is disclosed only when you choose to produce it, for example to a court or a regulator, together with its receipt.
Very little. The SDK runs on the servers a company already operates and needs no GPU, no model training and no separate storage, because records are never copied to Quantova. A record is fingerprinted with SHA3 256 in microseconds on an ordinary processor, and in our benchmark 65,536 records were fingerprinted and combined into one hash tree in under one second.
Up to 1,048,576 records share one anchoring transaction, and the Quantova network finalises blocks with committee signatures under ML DSA 65 rather than proof of work, so anchoring consumes no mining energy.
Qstamp is published on npm and on GitHub under the Apache License 2.0 or the MIT licence. Node 20 or later is required.
npm install @quantovainc/qstamp
To review or build from source, clone the repository.
git clone https://github.com/Quantova/QStamp.git cd QStamp npm ci
openssl rand -hex 32 > signer.key chmod 600 signer.key
const fs = require('fs');
const { Client, core } = require('@quantovainc/qcore');
const seed = Uint8Array.from(Buffer.from(fs.readFileSync('signer.key', 'utf8').trim(), 'hex'));
const client = new Client('https://rpc-testnet.quantova.org', { expectedChainId: 'Q-test-net-1' });
const address = core.address(seed, 0);
client.account(address).then(async (account) => {
console.log('address ' + address);
console.log('balance ' + account.balance + ' quon');
if (account.has_key) return console.log('status registered, ready to stamp');
if (account.balance === '0') return console.log('status claim test TQTOV at the faucet');
const { outcome } = await client.register(seed, 0, '100000');
console.log('status registration ' + outcome.verdict);
});npx qstamp stamp report.pdf --seed-file ./signer.key --index 0 --kind record npx qstamp verify report.pdf.qstamp.json --file report.pdf
Each anchoring transaction costs 0.005 TQTOV on the test network, whatever the number of files. Keep signer.key secret and backed up. Anyone who holds it can sign as your account.
Record each action the agent takes, then anchor the actions in batches.
const qstamp = require('@quantovainc/qstamp');
const batch = [];
function recordAction(action) {
const bytes = Buffer.from(JSON.stringify(action));
batch.push({ digest: qstamp.digestBytes(bytes) });
}
async function anchorBatch(seed) {
if (batch.length === 0) return [];
const records = batch.splice(0);
return qstamp.stamp({
seed,
index: 0,
kind: 'ai_agent_action',
records,
onPending: (pending) => savePending(pending),
});
}The seed is passed as a Uint8Array of 32 bytes and is wiped by the SDK after signing. Model files and datasets can be stamped the same way with the kinds ai_model and ai_dataset.
The record kind is stored on the chain with each commitment, so a verifier can see what class of record was anchored. The named kinds are listed below. Other values are available for private schemes.
0 record 1 file 2 document 3 software_release 4 ai_model 5 ai_dataset 6 ai_agent_action 7 ai_output 8 wallet_binding 9 financial_record 10 public_record
Most users never deploy a contract. The open Qstamp contract is already live and the SDK uses it by default. An institution deploys its own contract only when it needs an authorised issuer or multi party approval.
The templates are examples. An independent third party security audit is required before any production deployment. Receipts from your own contract are verified by passing its address with the option trustCustomContract set to true.
Qstamp supplies evidence. Each organisation remains responsible for meeting the other requirements of the laws that apply to it.
Yes. Qstamp records what an agent did, whatever its capability. The same SDK, record kinds and receipts apply to a narrow assistant and to the most capable autonomous systems.
SI systems increasingly contribute to the research that improves SI itself, with less human involvement in each step. Qstamp places a fingerprint of every action, model change and decision on chain as it happens, on a network that is post quantum from its first block, so that each step can later be recalled and checked against what the agent was permitted to do. Every anchoring transaction is visible on QVMScan, the Quantova explorer.
As agents become more capable and act with less human review, independent evidence of each action becomes more important. A receipt lets an operator, an auditor or a regulator confirm what was recorded without trusting the agent or its operator.
No. Fingerprints are computed on your own systems. The only value published for each batch is a salted 32 byte commitment from which no content can be derived.
A receipt contains no part of the record, but it does contain the record digest and salt. Handle receipts with the same care as the records they describe.
On the test network, each anchoring transaction costs 0.005 TQTOV whatever the batch size, up to 1048576 records. TQTOV test units have no monetary value and are free from the faucet.
Production use will take place on the Quantova main network, under its published fee schedule, once it launches.
No. Test network receipts carry no evidential weight. Use the test network to build and test your integration. Production use will take place on the Quantova main network once it launches.
The verifier needs the record and its receipt.
npx qstamp verify receipt.qstamp.json --file record.pdf
The result is valid, invalid or indeterminate. Indeterminate means that the network could not be consulted. An indeterminate result is never reported as valid. The first four checks run entirely on the verifier's own machine. An independent verifier can also rebuild every check from the published construction on the Mathematics page.
Fingerprints and hash trees use SHA3 with a 256 bit output, as specified in FIPS 202, which gives 128 bit security against quantum preimage search. Every transaction and every finality certificate on the Quantova network is signed with ML DSA 65, as specified in FIPS 204.
Email [email protected]. To report a security vulnerability, follow the Security and Disclosure policy.