The NexArt Canonical Node
The independent attestation layer for verifiable AI execution. It verifies execution records, signs proof that they happened, and records that proof permanently.
What NexArt is
- NexArt is verifiable execution infrastructure for AI systems. It produces tamper-evident records of what your AI actually ran.
- A lightweight integration captures inputs, outputs, and execution context at runtime and seals them into a single record locally.
- An independent attestation node certifies each record so that no single party controls the proof.
- Certification adds a third-party signature. The record can then be verified by anyone without trusting the operator.
- verify.nexart.io is a public verification surface. Anyone can check a record there with no account, no login, and no dependency on NexArt.
- A Project Bundle groups multiple execution steps into one verifiable artifact, covering entire workflows or agent sessions.
- NexArt proves what executed. It does not prove that the output is correct or that the model behaved well.
The NexArt Canonical Node is the neutral, deterministic, signed ground truth that lets all parties operate without trusting each other. Creators, platforms, buyers, and verifiers each see the same cryptographic evidence.
Without an independent trust layer, every claim about what executed depends on the operator's word. In most systems, verification requires trusting the originating system. The node removes that dependency. After an incident or dispute, there is no neutral record to fall back on unless one was created at execution time.
Four core functions
The node does four jobs. Everything else is a consequence of one of these four.
It runs creative code deterministically
You give it p5.js code; it runs the code in a controlled environment and produces a static image (PNG) and, when applicable, an animated video (MP4). The same code with the same inputs always produces the same output. If your code is broken, the node tells you and refuses to render.
It signs proof that it ran
Every render and every AI execution comes back with a signed receipt and a verification envelope. The receipt says: I, the node, attest that this exact output came from this exact input at this exact time.
It permanently records the proof
Every successful attestation is written to a public proof ledger. Anyone with the certificate hash can look it up, no API key required. The ledger is append-only: proofs cannot be silently rewritten.
It publishes its public key
The node exposes its public key at a well-known URL. Any verifier can pull the key and verify everything the node ever signed without contacting the node again. Verification works even if the node goes offline.
Trust guarantees
These are the guarantees the node makes, and the engineering choices that make them honest. In most systems today, none of these properties exist by default.
One execution, one certificate, forever
Re-running the same job cannot produce a second, conflicting certificate. Eliminates double-certification and re-attribution attacks.
No silent rewrites
Once a certificate is in the ledger, its bundle bytes are frozen. Any attempt to mutate it is rejected, not silently overwritten.
No code fixes
The node never edits your input to make it work. If it ran, your code is exactly what produced the output.
Consistent verification rules
The rules for computing fingerprints are shared between the node and external verifiers. They cannot drift apart. A record verified today will verify the same way in five years.
Offline-verifiable signatures
Cryptographic signatures verified with the node's public key. A verifier needs only the bundle, the signature, and the key. No callbacks, no oracles.
Failed certifications are recorded too
The ledger captures failed rows alongside successes. Disputes can prove that an attempt was made and rejected, not just that no attempt happened.
The trust chain
Every link in this chain is independently verifiable. There is no "trust us" link.
What the node does not do
- Does not issue tokens. We produce the hash you anchor against. Choose any chain.
- Does not custody assets, keys, or wallets. Your keys, your custody.
- Does not host the original output. The proof ledger stores hashes and a redacted bundle, not the full file.
- Does not improve or post-process outputs. The output bytes are exactly what the deterministic renderer produced.
- Does not arbitrate disputes. We give all parties the same cryptographic ground truth; the resolution layer is yours.
Start with a single certified execution
The Canonical Node is one part of the trust chain. See the full 4-stage adoption path. The longer you run without independent attestation, the larger the gap in your evidence history.
See the adoption path →