Capabilities

What Aere does today, and how to check it

Updated 2026-10-18 41 capabilities: 31 live, 6 demonstrated, 4 planned For machines: capabilities.json

Aere builds the trust layer of the digital world. This page lists what of it exists, line by line, in three states: live and verifiable now, demonstrated but not activated, or planned. Every live entry names the evidence that settles it, so you can check it without asking us.

No component on this page has been through a third-party security audit.
One operator, the Aere Foundation, runs every validator of chain 2800, the network under the four lines.

Live, verifiable now31
In production or published, and checkable today by anyone, alone: a claim the public checker runs against the live chain, a published module with its test and the result its README states, or a public service answering a request you can make.
Demonstrated, not activated6
Public code and results you can reproduce, running on the public testnet or in a laboratory, not in production. The entry says where it runs and how to reproduce it.
Planned4
A design or a direction, not delivered. The entry says what is missing and does not say when it will exist.

At a glance
Line	Live	Demonstrated	Planned	Total
Shield	8	0	0	8
Agents	2	2	0	4
Identity	5	0	2	7
Proof	9	0	0	9
Engine	7	4	2	13
All lines	31	6	4	41

Show

Aere Shield

Find every vulnerable key, certificate and protocol in an organization, plan the post-quantum migration, and keep a verifiable report of what changed.

About Aere Shield

Live, verifiable now
Post-quantum readiness of a public hostname
Opens real TLS connections to one public hostname and reports whether its edge offers, and prefers, the hybrid post-quantum key exchange, with its HSTS policy and its certificate.
Evidence
- Servicecloud.aere.network/v1/pq/readiness/aere.network answers HTTP 200, domain = "aere.network".
  curl https://cloud.aere.network/v1/pq/readiness/aere.network
  The measurement of one hostname, as JSON; the form at /quantum-readiness.html runs it for yours.
- Modulereadiness in aere-quantum, with the results its README states:
  6/6 tests
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/readiness node proba-adrese-private.mjs
What it does not do
It measures the public TLS edge of one hostname on port 443; it is not an audit of the systems behind it.
Live, verifiable now
Cryptographic inventory of source code
Reads a source tree in seven programming languages, plus key files and dependency manifests, and lists every use of cryptography, classified by its exposure to a quantum computer and written as a CycloneDX 1.6 cryptographic bill of materials.
Evidence
- Modulecrypto-inventory in aere-quantum, with the results its README states:
  68/68 tests
  35/35 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/crypto-inventory node test/proba.mjs node test/control-negativ.mjs
What it does not do
A static reading: an algorithm chosen at run time, or taken from configuration outside the tree, is reported as unknown, not guessed.
Live, verifiable now
Quantum exposure report for Bitcoin and Ethereum addresses
Classifies addresses by whether their public key is already readable from chain data, names the evidence for each, and writes a dated report bound in a verifiable proof envelope.
Evidence
- Moduleexposure-report in aere-quantum, with the results its README states:
  153 passed, 0 red, 0 broken rows
  Rows: in the public copy; twelve more rows report themselves unmeasured, each with its reason, because they compare against files that are not in that repository.
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/exposure-report npm install --ignore-scripts && node proba-expunere.mjs
What it does not do
It records what was readable on the date of the report; it does not protect, move or recover any coins, and it says nothing about the future.
Live, verifiable now
Post-quantum certificate authority
A private certificate authority that issues ML-DSA X.509 v3 certificates as RFC 9881 specifies, with revocation lists and a strict chain verifier whose verdicts are compared with OpenSSL.
Evidence
- Modulepq-pki in aere-quantum, with the results its README states:
  27/27 tests
  22/22 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/pq-pki node test/proba.mjs node test/control-negativ.mjs
What it does not do
It issues pure ML-DSA certificates, not composite hybrid ones, which are still IETF drafts; the CA key is protected by a passphrase on disk, not by an HSM.
Live, verifiable now
Hybrid key management service
A key service in which every key is hybrid: X25519 with ML-KEM-768 for encryption and Ed25519 with ML-DSA-65 for signatures, both halves required, with versions, rotation, rewrapping and a chained audit log.
Evidence
- Modulepq-kms in aere-quantum, with the results its README states:
  62/62 tests
  16/16 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/pq-kms node test/proba.mjs node test/control-negativ.mjs
What it does not do
It is not an HSM itself; its root key can be sealed by an HSM through PKCS#11, which has been tested with a software HSM and not yet with a physical one.
Live, verifiable now
Secrets service with request-bound authorization
Named secrets with versions, each under its own data key in the hybrid key service; every request is authorized by an identity presentation signed for that exact request and by a per-secret policy, never by the network or a bearer token, and every operation, allowed or refused, is recorded as a signed proof envelope.
Evidence
- Modulepq-secrets in aere-quantum, with the results its README states:
  43/43 tests
  43/43 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/pq-secrets AERE_VERIFY_PROOF=<verify-proof.mjs> node test/proba-secrete.mjs node test/control-negativ-secrete.mjs
What it does not do
It is not zero trust towards its own host, has no HSM of its own, and does not detect a data directory put back to an older state.
Live, verifiable now
TLS 1.3 gateway with hybrid key exchange
A terminating proxy that puts the X25519MLKEM768 key exchange in front of any HTTP service; in hybrid-only mode a classical client is refused at the handshake, in hybrid-preferred mode it keeps working.
Evidence
- Modulepq-gateway in aere-quantum, with the results its README states:
  33/33 tests
  33/33 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/pq-gateway node proba-pq-gateway.mjs bash proba-pq-gateway-control-negativ.sh
What it does not do
It protects the key exchange; the server is still authenticated by a classical certificate unless an ML-DSA chain is served, and many browsers cannot verify ML-DSA certificates yet.
Live, verifiable now
Migration plan, execution and remediation
Turns the inventory and the scan into a prioritized plan, carries out each action through the gateway, the key service and the certificate authority with consent per action and a measurement afterwards, and gives configuration recipes for the servers those products do not touch, judged by a rescan.
Evidence
- Modulecontrol-plane in aere-quantum, with the results its README states:
  execution 30/30 on real products started locally
  remediation 33/33 on real TLS servers
  console 8/8
  remediation 7/7 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/control-plane node proba-executa-migrare.mjs node proba-remediere.mjs node proba-consola.mjs node control-negativ-remediere.mjs
What it does not do
It does not change your DNS, ports or firewall, does not issue public WebPKI certificates and does not delete keys; a public WebPKI certificate cannot be reissued post-quantum today.

Aere Agents

A post-quantum identity, bounded permissions, payments and a record anyone can check, for AI agents and machines.

About Aere Agents

Live, verifiable now
Agent identity, policy and signed record
An ML-DSA-65 identity for each agent, a policy for spending, tools, recipients and the actions that need a person's approval, and a signed ledger of every action that a verifier re-judges against the policy without trusting the agent.
Evidence
- Moduleagents in aere-quantum, with the results its README states:
  27/27 policy
  54/54 ledger
  39/39 approval and revocation
  26/26 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/agents AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-agent-policy.mjs node proba-agent-ledger.mjs node proba-agent-aprobare.mjs node control-negativ-aprobare.mjs
What it does not do
A ledger says what the agent did and whether its policy allowed it; it does not score, rank or vouch for the agent.
Live, verifiable now
Trust record of an AI result
Joins the agent's identity, the attestation of the model artifact, the host's runtime record, the policy and ledger and the provenance envelope of the action into one bundle, and checks the links between them.
Evidence
- Moduleai-trust in aere-quantum, with the results its README states:
  16/16 tests
  11/11 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/ai-trust AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-lant-de-incredere.mjs node proba-lant-de-incredere.mjs --control-negativ
What it does not do
It checks that the links hold; it does not judge whether the model's output is correct.
Demonstrated, not activatedRuns on: The public testnet, chain 28001
The chain as witness of an agent's ledger
The head of an agent's ledger is notarized and read back under a post-quantum certified anchor, which bounds the time of every entry from below, so a backdated entry is caught.
Evidence
- Moduleagents in aere-quantum, with the results its README states:
  7/7 on the public testnet
  26/26 without a network
  11/11 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/agents AERE_TESTNET_KEY_FILE=<funded testnet key> node proba-agent-ancora-testnet.mjs node proba-agent-ancora.mjs node control-negativ-ancora.mjs
What it does not do
The published measurement is on the public testnet only.
Demonstrated, not activatedRuns on: The public testnet, chain 28001, through a facilitator settling a test dollar
Machine payments over HTTP 402
An agent wallet that pays over x402 only what the agent's ledger records and its policy allows, either holding the payment key for the owner or co-signing from a 2-of-2 contract wallet that neither the agent nor the owner can spend alone.
Evidence
- Servicetestnet-rpc.aere.network/x402/supported answers HTTP 200, kinds.0.network = "eip155:28001".
  curl https://testnet-rpc.aere.network/x402/supported
  The testnet facilitator names its network.
- Moduleagents/x402 in aere-quantum, with the results its README states:
  9/9 on the public testnet, wallet key
  13/13 on the public testnet, 2-of-2 wallet
  25/25 without a network
  30/30 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/agents/x402 AERE_TESTNET_KEY_FILE=<funded testnet key> node proba-x402-testnet.mjs AERE_TESTNET_KEY_FILE=<funded testnet key> node proba-cosign-testnet.mjs node proba-wallet.mjs node control-negativ-wallet.mjs
What it does not do
No machine-payment service runs on chain 2800.

Aere Identity

Prove who you are, what you are allowed to do or that a fact about you holds, without handing over your data; verifiable offline, on open standards.

About Aere Identity

Live, verifiable now
Post-quantum credentials with selective disclosure
An issuer signs claims with a hybrid Ed25519 and ML-DSA-65 key, both required; the holder shows only the claims a verifier needs, bound to that verifier; delegation to a device, an agent or a short-lived session key, revocation and an issuer status list, all checked offline.
Evidence
- Moduleidentity in aere-quantum, with the results its README states:
  52/52 tests
  57/57 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/identity AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-identity.mjs node control-negativ-identity.mjs
What it does not do
It is not a zero-knowledge proof: a claim that is shown is shown whole, so a birth date shows the date.
Live, verifiable now
Standard SD-JWT and SD-JWT VC
The same keys issue and verify standard SD-JWT as RFC 9901 specifies, presented with a key-binding JWT, and the SD-JWT VC profile with a token status list judged offline; interoperability is measured in both directions with an independent open-source implementation.
Evidence
- Moduleidentity in aere-quantum, with the results its README states:
  SD-JWT 25/25
  SD-JWT VC 10/10
  SD-JWT 31/31 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/identity node proba-sdjwt.mjs node proba-sdjwt-vc.mjs node control-negativ-sdjwt.mjs
What it does not do
The SD-JWT VC profile follows an IETF draft that can still change, and no European digital identity wallet has been tested against it.
Live, verifiable now
Travel Rule messages between virtual asset service providers
Originator and beneficiary data in the IVMS101 format, sealed for the receiving provider with hybrid X25519 and ML-KEM-768 key encapsulation, signed, bound to the transfer and acknowledged.
Evidence
- Moduleidentity in aere-quantum, with the results its README states:
  Travel Rule 20/20 tests
  Travel Rule 20/20 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/identity node proba-travel-rule.mjs node control-negativ-travel-rule.mjs
What it does not do
A message format and its verification, not a network: it does not validate the IVMS101 schema, and no provider exchanges these messages through Aere today.
Live, verifiable now
Compliance check without personal data
A verifier's policy, such as trusted issuers and required claims, judged on a presentation and recorded as a verifiable envelope that carries no personal data.
Evidence
- Moduleidentity in aere-quantum, with the results its README states:
  compliance 18/18 tests
  compliance 17/17 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/identity node proba-conformitate.mjs node control-negativ-conformitate.mjs
What it does not do
It records that a policy was met, not who the person is; it is not a sanctions screening or an identity verification service.
Live, verifiable now
Identity of devices
A chain of signed statements about a machine (who made it, which firmware it runs, who owns it, what it may do, whether it is still in service, and a fresh attestation) judged offline by one verifier that names every rule that refused.
Evidence
- Moduledevice-identity in aere-quantum, with the results its README states:
  372/372 tests
  220/220 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/device-identity AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-device.mjs node control-negativ-device.mjs
What it does not do
The device key is a software key: no TPM, secure element or trusted execution environment is used or checked.
Planned
Interoperation with European digital identity wallets
Credentials exchanged with the wallets of the European Digital Identity framework, including the ISO/IEC 18013-5 mobile document format.
Not yet
Not built and not tested with any wallet; the SD-JWT VC profile above is the part that exists.
Planned
Device keys held in hardware
Device identities whose keys live in a TPM, a secure element or a trusted execution environment, with the hardware's own attestation checked.
Not yet
Not built; device keys are software keys today.

Aere Proof

A proof of what was signed and when, for any document, dataset, model output or software release, verifiable offline by anyone.

About Aere Proof

Live, verifiable now
One proof format and its reference verifier (AIP-23)
An envelope with a statement, its hash, an ML-DSA signature and, when it claims one, a notarization, checked by one public verifier in levels (form, integrity, signature, finality, witness) that names every reason it refuses.
Evidence
- Public toolFetched from this site and run as published:
  curl \ -O https://aere.network/tools/verify-proof.mjs \ -O https://aere.network/tools/martor-notar-verifica.mjs \ -O https://aere.network/tools/sample-witness.json \ -O https://aere.network/tools/verify-anchor.mjs \ -O https://aere.network/tools/mpt.mjs \ -O https://aere.network/tools/falcon512.mjs \ -O https://aere.network/tools/registry-v3.mjs \ -O https://aere.network/tools/package.json npm install node verify-proof.mjs sample-witness.json --live
  Prints VERDICT: VALID for the sample envelope served beside the verifier.
- Sourceaips/AIP-23.md in aere-research.
- Moduleproof-kinds in aere-quantum, with the results its README states:
  28/28 tests
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/proof-kinds AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-proof-kinds.mjs
What it does not do
A proof says which bytes were signed, by which key and when; it does not say that the content is true.
Live, verifiable now
The same verifier in your browser, offline
A browser build of the reference verifier checks an envelope's form, integrity and post-quantum signature on your device and sends nothing anywhere.
Evidence
- Serviceaere.network/verify.html answers HTTP 200.Open it, load the sample proof, and verify it with the network switched off.
What it does not do
The levels that need the chain or Bitcoin are reported as unmeasured in the browser, never as passed.
Live, verifiable now
Notarization on chain 2800
A document's hash is recorded on chain 2800 through the AereNotary contract, under a post-quantum certified anchor; the document itself never leaves your hands.
Evidence
- JSON-RPCeth_getLogs on rpc.aere.network returns result.0.address = 0x4ab392c4aca7d9d4c16c0b60a9514c5025bd58c7, result.0.blockNumber = 0x1223162.
  curl -s https://rpc.aere.network -H 'content-type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"address":"0x4aB392c4Aca7D9D4C16c0b60a9514c5025bd58c7","fromBlock":"0x1223162","toBlock":"0x1223162"}]}'
  A notarization recorded by AereNotary in block 19,018,082.
- Serviceaere.network/notary-check.html answers HTTP 200.Check a notarization by its hash.
What it does not do
It is not a proof that the time recorded on chain 2800 is the true time; the Bitcoin witness below bounds it independently, from above.
Live, verifiable now
A Bitcoin witness for every notarization
Notarizations are gathered into Merkle lots whose roots are timestamped in Bitcoin through OpenTimestamps, so each one can be shown to have existed by the time of a Bitcoin block, a witness that does not depend on Aere.
Evidence
- Public toolFetched from this site and run as published:
  node verify-proof.mjs sample-witness.json --live
  With the files fetched as for the proof verifier above; the witness level reads PASSED, with the Bitcoin block it names confirmed by two public block explorers.
What it does not do
A new notarization is witnessed hours after it is made, not at once; offline, the witness can be judged only against a Bitcoin block header you bring.
Live, verifiable now
Conformance suite for proof verifiers
One verdict form over the published verifiers: rules read from their code, vectors derived from the producers, each invalid vector one change away from a valid one, and a runner that scores any implementation given as a command, in any language.
Evidence
- Moduleconformance in aere-quantum, with the results its README states:
  11/11 tests from a fresh clone
  the published verifiers pass 626/626 vectors
  322/322 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/conformance AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-conformance.mjs --online AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-conformance.mjs --control-negativ --online
What it does not do
It is not a certification and not an audit.
Live, verifiable now
Proof of Software
An attestation of a software release made from the committed bytes, so that a stranger can rebuild the artifact and compare it byte for byte, with software bills of materials derived from the committed lock files.
Evidence
- Moduletools/proof-of-software in aere-proof-of-software, with the results its README states:
  16/16 attestation and verification
  git clone https://git.aere.network/aere-network/aere-proof-of-software cd aere-proof-of-software cd sdk-pq-sign && npm ci --ignore-scripts && cd .. && node tools/proof-of-software/test/pos.test.mjs
- Modulesdk-pq-sign in aere-proof-of-software, with the results its README states:
  34/34 hybrid signature library
  git clone https://git.aere.network/aere-network/aere-proof-of-software cd aere-proof-of-software node sdk-pq-sign/test/pq-sign.test.mjs
What it does not do
It shows what was built from which commit and by whose key; it does not review the code for defects.
Live, verifiable now
Proof of AI
The provenance of an AI agent's action (model, version, weights digest, prompt, input, output, tools, agent and requester) recorded as digests in an envelope that the same reference verifier checks.
Evidence
- Moduleproof-of-ai in aere-quantum, with the results its README states:
  6/6 tests
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/proof-of-ai AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-proof-of-ai.mjs
What it does not do
It is not deepfake detection: it proves which output was recorded, not that it is true.
Live, verifiable now
Signed audit log for any deployment
Entries are proof envelopes in a hash chain and in a Merkle tree with inclusion and consistency proofs; the runtime adapter records every running container without any secret value, and the head can be signed by the operator and notarized on chain 2800.
Evidence
- Moduleverify-layer in aere-quantum, with the results its README states:
  45/45 tests
  20/20 Merkle tree
  37/37 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/verify-layer AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-sidecar.mjs node proba-arbore.mjs node control-negativ-sidecar.mjs
What it does not do
It proves the history before a published head; it does not prove that the host told the truth.
Live, verifiable now
Verifiable datasets
A dataset whose answers are checked against a short commitment: equality and range queries proven correct and complete, selective disclosure of fields, and versions committed append-only.
Evidence
- Moduleverifiable-data in aere-quantum, with the results its README states:
  23/23 tests
  5/5 negative control
  git clone https://git.aere.network/aere-network/aere-quantum cd aere-quantum/verifiable-data AERE_VERIFY_PROOF=<verify-proof.mjs> node proba-verifiable-data.mjs node proba-verifiable-data.mjs --control-negativ
What it does not do
It is not zero knowledge: a proven answer reveals the records it returns.

The engine: chain 2800

The public network under the four lines, with post-quantum certificates under its blocks. It is not sold; it is the notary the proofs rely on, and anyone can measure it.

The network for developers

Live, verifiable now
A public network with single-slot finality
Chain 2800 runs QBFT with ten validators: a block is final once a quorum of seven has committed to it, a new block comes in under a second, and anyone can read it over JSON-RPC.
Evidence
- Claimschain-identity (section 1), block-interval (section 2), qbft-validator-set-from-header (section 3) in verifiable-claims.json, run against the live chain by the claims checker:
  curl -O https://aere.network/verifiable-claims-check.py && python3 verifiable-claims-check.py
What it does not do
One operator, the Aere Foundation, runs all ten validators: the number of independent parties that would have to agree to stop the network is one.
Live, verifiable now
Two independent client implementations
Of the ten validators, nine run a client derived from Hyperledger Besu and one runs an independent client derived from Nethermind, written in another language on another codebase; both propose blocks on the live chain.
Evidence
- JSON-RPCRead the headers yourself:
  curl -s https://rpc.aere.network -H 'content-type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_getBlockByNumber","params":["latest",false]}'
  Repeat for 60 consecutive blocks and read item 0 of the RLP list in extraData: blocks from the Besu-derived client carry the client's version string, which begins with the bytes 62657375 (besu), and the blocks of one validator carry 32 zero bytes in its place; anchor blocks carry a digest there instead.
- Sourcesrc/Nethermind/Nethermind.AerePqc in aere-client2.
What it does not do
With nine of the ten seats on one client, a fault in that client would still stop the chain; the public repository of the second client holds its validation code, not yet its block-producing engine.
Live, verifiable now
A post-quantum certificate under the block hash
Every 32nd block carries a certificate of Falcon-512 signatures by at least seven of the ten validators, and every 128th block SLH-DSA-SHA2-128s signatures as well, bound under the block's own hash; each signature checks against a key the validator bound to itself with its consensus key.
Evidence
- Claimpq-certificate-under-block-hash (by the procedure it states) in verifiable-claims.json.
- Public toolFetched from this site and run as published:
  curl \ -O https://aere.network/tools/verify-anchor.mjs \ -O https://aere.network/tools/mpt.mjs \ -O https://aere.network/tools/falcon512.mjs \ -O https://aere.network/tools/registry-v3.mjs \ -O https://aere.network/tools/package.json npm install ANCHORS=3 node verify-anchor.mjs
  The three newest anchors, every seal verified against the published keys; the last line begins VERIFIED.
What it does not do
Blocks between anchors are finalized by classical ECDSA signatures; a certificate shows that those validators signed the parent block, not by itself that it was decided.
Live, verifiable now
Post-quantum validator identity (AIP-22 stage 3)
Since block 20,836,228 the validator set in every block header names each validator by an id derived from its post-quantum keys, bound to them by a published registry, instead of by an ECDSA address.
Evidence
- Claimqbft-validator-set-from-header (section 3) in verifiable-claims.json, run against the live chain by the claims checker:
  curl -O https://aere.network/verifiable-claims-check.py && python3 verifiable-claims-check.py
- Public toolFetched from this site and run as published:
  ANCHORS=3 node verify-anchor.mjs
  With the files fetched as for the certificate above; the tool prints the line identity: from block 20836228 the validator set holds post-quantum ids.
What it does not do
Node-to-node transport between the validators is still authenticated with classical secp256k1 keys.
Live, verifiable now
Post-quantum seals on consensus messages
Consensus messages carry post-quantum seals of their authors next to the classical signature; the commit seals are what the anchor certificates carry, so anyone can verify them there.
Evidence
- Public toolFetched from this site and run as published:
  ANCHORS=3 node verify-anchor.mjs
  With the files fetched as for the certificate above; every seal of the three newest certificates is valid and from a distinct validator.
What it does not do
The refusal of unsealed messages happens inside the validator set and cannot be observed from outside it: the Besu-derived client, on nine of the ten seats, refuses any unsealed proposal, prepare, commit or round-change message; the second client refuses an unsealed commit and applies the rule to the other three types only from AIP-22 stage 4, which is not active on chain 2800.
Live, verifiable now
Post-quantum signature verification inside the EVM
Five precompiled contracts, at addresses 0x0AE1 to 0x0AE5 since block 9,189,161, verify Falcon-512, Falcon-1024, ML-DSA-44 and SLH-DSA-SHA2-128s signatures and compute SHAKE256 natively, at precompile cost.
Evidence
- Claimspqc-precompiles-declared (section 4), shake256-nist-kat (section 5), pqc-precompiles-execute (section 6) in verifiable-claims.json, run against the live chain by the claims checker:
  curl -O https://aere.network/verifiable-claims-check.py && python3 verifiable-claims-check.py
- Sourceprecompiles in aere-node.
What it does not do
A post-quantum verifier called from a transaction that is itself authorized by an ECDSA key does not make that transaction post-quantum: the outer signature remains the weak link.
Live, verifiable now
Native post-quantum transactions (AIP-20)
Transaction type 0x50 is authorized by an ML-DSA signature instead of ECDSA; every node has accepted the type since block 19,900,000, and a transaction of this type is in block 19,900,028.
Evidence
- JSON-RPCeth_getTransactionByHash on rpc.aere.network returns result.type = 0x50, result.blockNumber = 0x12fa67c.
  curl -s https://rpc.aere.network -H 'content-type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionByHash","params":["0x7cb5bdaceb475a6fee881c6a68aadf69734e78c1fd5648865c4fdde243d602e5"]}'
  The transaction is of type 0x50, in block 19,900,028.
- JSON-RPCeth_getTransactionReceipt on rpc.aere.network returns result.status = 0x1.
  curl -s https://rpc.aere.network -H 'content-type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionReceipt","params":["0x7cb5bdaceb475a6fee881c6a68aadf69734e78c1fd5648865c4fdde243d602e5"]}'
  And it succeeded.
- Sourceaips/AIP-20.md in aere-research.
- Sourcepatches/0006-aere-pq-transactions.patch in aere-node.
What it does not do
Existing accounts keep their ECDSA keys until their holders move to a post-quantum one; AIP-20 is a draft, not yet ratified through the signed acceptance its process asks for.
Demonstrated, not activatedRuns on: The public testnet, chain 28001, since block 6,157,024
Round-bound commit seals (AIP-22 stage R)
Each post-quantum commit seal names the consensus round in which it was given, and the anchor certificate states that round, so a certificate carrying a quorum of seals shows that the parent block was decided.
Evidence
- Public toolFetched from this site and run as published:
  CHAIN_ID=28001 \ RPC=https://testnet-rpc.aere.network \ MANIFESTS=https://testnet-rpc.aere.network/pq/manifests \ ANCHORS=3 node verify-anchor.mjs
  With the files fetched as for the certificate above, against the public testnet; each anchor line reads PARENT DECIDED IN ROUND.
- Sourcepatches/0010-aere-pq-round-bound-commit-seal.patch in aere-node.
- Sourceaips/AIP-22.md in aere-research.
What it does not do
Not active on chain 2800; activating it there is a coordinated fork of every node, and no height is set.
Demonstrated, not activatedRuns on: The public testnet, chain 28001, since block 3,117,000
Post-quantum finality (AIP-22 stage 4)
A consensus message counts as a vote only through its verified post-quantum seal, and ECDSA signatures stop being a validity rule for votes and commit seals.
Evidence
- Sourceaips/AIP-22.md in aere-research.
- Sourceaips/aip22-conformance/VECTORS.json in aere-research.
- Sourcepatches/0008-aere-pq-aip22.patch in aere-node.
How to reproduce
The conformance vectors of AIP-22 are real blocks of the public testnet with the verdict each of the two clients reached; the stage records in AIP-22 give the measurements of the crossing.
What it does not do
Not active on chain 2800; activating it there is a coordinated fork of every node, and no height is set.
Demonstrated, not activatedRuns on: The public testnet, chain 28001, since block 3,131,000
Post-quantum block headers (AIP-22 stage 5)
Block headers no longer carry ECDSA commit seals; each carries the proposer's Falcon-512 seal instead, checkable against the published registry.
Evidence
- Public toolFetched from this site and run as published:
  CHAIN_ID=28001 \ RPC=https://testnet-rpc.aere.network \ MANIFESTS=https://testnet-rpc.aere.network/pq/manifests \ ANCHORS=3 node verify-anchor.mjs
  The same run as for stage R; the proposer seal of every recent header verifies.
- Sourcepatches/0008-aere-pq-aip22.patch in aere-node.
What it does not do
Not active on chain 2800; activating it there is a coordinated fork of every node, and no height is set.
Demonstrated, not activatedRuns on: A laboratory build, not a node of any network
Parallel transaction execution (Block-STM)
An executor that runs a batch of transactions on many cores with optimistic concurrency and commits the same state root as sequential execution.
Evidence
- Sourceparallel-executor/README.md in aere-research.
- Sourceparallel-executor/src/parallel.rs in aere-research.
How to reproduce
cd aere-research/parallel-executor && cargo test --release
What it does not do
Chain 2800 executes transactions sequentially, and no laboratory throughput figure is a performance figure of the chain.
Planned
A zero-knowledge proof of every block
A succinct proof, for each block, that its execution was correct, checkable without re-executing it.
Not yet
Research only: the cost of proving every block, and what happens when a proof is late, are not established.
Planned
Validators run by independent operators
Validator seats held by organizations other than the Aere Foundation, so that stopping the network takes more than one party.
Where it stands
- Serviceaere.network/decentralization.html answers HTTP 200.The network's own statement of where it stands today.
Not yet
Today one operator runs all ten validators; a seat added by that operator adds no independence.

How to check this page yourself

Every entry on this page is also in capabilities.json, with the same state and the same evidence in a form a program can read.

A live entry is published only if its evidence passed when this page was built: the claim is in verifiable-claims.json and its section of the claims checker passes against the live chain; the module is at that path in the public repository and the result shown is the one its README states; the public service answers the request shown with the response shown; the public tool, fetched from this site, prints the line shown. If any of them fails, the build refuses and the page is not rewritten.

Where a command reads AERE_VERIFY_PROOF=<verify-proof.mjs>, the placeholder is the path of the reference verifier fetched from /tools/ with the files of the anchor verifier beside it, as the entry for the proof format shows; without it those tests report themselves skipped and exit with code 2. Where it reads <funded testnet key>, the test sends transactions on the public testnet and needs a key holding test coins.

Each of those checks is something you can run yourself, with the command written under the entry. Run them; where your result differs from ours, the page is wrong, and that is the finding.

What Aere does today, and how to check it

Aere Shield

Post-quantum readiness of a public hostname

Cryptographic inventory of source code

Quantum exposure report for Bitcoin and Ethereum addresses

Post-quantum certificate authority

Hybrid key management service

Secrets service with request-bound authorization

TLS 1.3 gateway with hybrid key exchange

Migration plan, execution and remediation

Aere Agents

Agent identity, policy and signed record

Trust record of an AI result

The chain as witness of an agent's ledger

Machine payments over HTTP 402

Aere Identity

Post-quantum credentials with selective disclosure

Standard SD-JWT and SD-JWT VC

Travel Rule messages between virtual asset service providers

Compliance check without personal data

Identity of devices

Interoperation with European digital identity wallets

Device keys held in hardware

Aere Proof

One proof format and its reference verifier (AIP-23)

The same verifier in your browser, offline

Notarization on chain 2800

A Bitcoin witness for every notarization

Conformance suite for proof verifiers

Proof of Software

Proof of AI

Signed audit log for any deployment

Verifiable datasets

The engine: chain 2800

A public network with single-slot finality

Two independent client implementations

A post-quantum certificate under the block hash

Post-quantum validator identity (AIP-22 stage 3)

Post-quantum seals on consensus messages

Post-quantum signature verification inside the EVM

Native post-quantum transactions (AIP-20)

Round-bound commit seals (AIP-22 stage R)

Post-quantum finality (AIP-22 stage 4)

Post-quantum block headers (AIP-22 stage 5)

Parallel transaction execution (Block-STM)

A zero-knowledge proof of every block

Validators run by independent operators

How to check this page yourself