# https://nexart.io/

**Verifiable AI Execution for Agents & Workflows | NexArt**

Prove what your AI actually ran. NexArt seals every execution into a Certified Execution Record. Tamper-evident, cryptographically signed, independently verifiable. Group multi-step workflows into a Project Bundle with a single Project Hash.

Your AI made a decision. Can you prove it?

NexArt is verifiable execution infrastructure for AI systems. Every run produces a Certified Execution Record: a tamper-evident, cryptographically signed artifact that anyone can verify independently.

Free to create. Paid to certify. Public to verify.

One function call. No infrastructure change. Start certifying in under an hour.

Start with NexArt (https://nexart.io/adopt) · See exactly how it works (https://nexart.io/how-it-works)

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.

Execution → Record → Proof

Execute: Your AI runs. Inputs, outputs, and context are captured.

Seal: SHA-256 binds everything into a tamper-evident CER.

Verify: Anyone confirms independently. No account needed.

Try it in your browser (https://nexart.io/demos/ai-execution)

Logs describe. They do not prove.

Today, most AI executions leave no independently verifiable record. Logs can be edited, deleted, or fabricated after the fact. Inputs and outputs are rarely bound together. When something goes wrong, there is no verifiable link between what was requested and what was returned. Without execution-level evidence, trust depends entirely on the operator. Auditors, partners, and regulators have nothing to verify independently.

Most teams discover this gap during an audit or after a client dispute. By then, the executions they need to prove are already gone.

Verifiable execution evidence for every AI workflow

Every execution produces a Certified Execution Record (CER) that binds inputs, parameters, and outputs into a single tamper-evident artifact. Independent attestation nodes verify integrity and issue signed receipts. Recompute the hash. Check the signature. No API key, no account, no dependency on NexArt.

What NexArt is, and what it is not

NexArt proves what executed. It does not claim the output is correct. Verification is about integrity of the record, not the quality of the model. This is not observability. It is verifiable execution evidence.

NexArt is

An execution evidence layer for AI systems

A cryptographic proof system (SHA-256 + Ed25519)

Independent verification infrastructure

A record format anyone can verify without an account

NexArt is not

A logging or observability tool

A monitoring or analytics dashboard

A model provider or evaluation framework

A correctness or quality guarantee

Execution is certified. Context explains the decision.

Inputs, outputs, and parameters are sealed into the Certified Execution Record. Optional execution context, such as routing, retrieval, or tool signals, attaches to the same record as an explanation layer. When included, context is bound to the seal. The record proves not just what ran, but how the decision was reached.

Built for how you work

Builders: Integrate verifiable execution into your AI stack. Free tier, SDK, CLI, and full API access.

Compliance & Risk: Audit-grade execution evidence aligned with ISO 42001, SOC 2, NIST AI RMF, and the EU AI Act.

Enterprise & Regulated Workflows: Private attestation nodes, SLAs, retention policies, and architecture walkthroughs for regulated environments.

From execution to proof in four steps

Capture: Inputs, outputs, and execution context recorded at runtime.

Seal: SHA-256 hash binds all protected fields into a tamper-evident record.

Attest: Independent node signs the record with an Ed25519 receipt.

Verify: Verify a single CER or an entire Project Bundle. Anyone confirms independently.

What actually gets verified

In most systems, inputs and outputs are logged separately, if at all. A Certified Execution Record binds the parts of a run that matter for proof. Everything else stays available for review, without being part of the seal.

Sealed in the proof: Inputs, outputs, and parameters are bound together by a single cryptographic hash. Change any one of them and the record no longer verifies.

Recorded as context: Execution context like model, version, timestamp, and environment is captured alongside the seal so reviewers can see exactly what ran.

Available as evidence: Optional signals and supporting data attach to the record for review. They may not always be part of the sealed proof, but they remain inspectable.

One workflow. Many executions. A single verifiable artifact.

Real systems aren't a single call. Agents plan, retrieve, decide, and act across many steps. NexArt groups those steps into a Project Bundle.

Each step gets its own Certified Execution Record. The Project Bundle ties them into one independently verifiable artifact for the whole workflow, with a single Project Hash that verifies the entire run.

See a Project Bundle (https://nexart.io/demos/ai-execution)

Anyone can verify. No login required.

Verification doesn't depend on NexArt's word, on internal logs, or on operator access. Records are independently checkable on a public surface.

Open to anyone: Share a link. Auditors, partners, and regulators verify directly at verify.nexart.io with no account.

Privacy-safe by default: Public records can be redacted so sensitive content isn't exposed, while the cryptographic proof stays intact.

Still cryptographically verifiable: Even when redacted, the hash and signature still verify. Integrity is preserved without revealing what's inside.

Open verify.nexart.io (https://verify.nexart.io)

Proof you can hand to anyone who asks

As AI systems move into production, the question shifts from "does it work?" to "can you prove what it did?" The teams that answer that question now set the standard. The rest explain gaps later.

AI auditability: Show exactly what ran, when, and with what inputs and outputs. The record can be validated independently, even outside your system.

Compliance evidence: Audit-grade records aligned with ISO 42001, SOC 2, and the EU AI Act.

Debugging with proof: Reproduce failed runs from a tamper-evident record, not a log file. No stitching together data from multiple systems.

Trustworthy agents: Multi-step agent workflows with verifiable decision trails end-to-end.

For systems where proof matters

AI agents & tool-calling workflows: Verifiable decision trails for autonomous tool calls, chain-of-thought workflows, and multi-step pipelines.

Approvals & policy enforcement: Prove that a decision followed the right inputs, parameters, and policy constraints with cryptographic evidence.

Compliance & audit readiness: Audit-grade execution records for regulated industries. Reproducible, independently verifiable, retention-ready.

Go deeper

What are Certified Execution Records (https://nexart.io/certified-execution-records)

AI execution integrity specification (https://nexart.io/protocol/ai-execution-integrity)

Security architecture (https://nexart.io/security)

How NexArt works (https://nexart.io/how-it-works)

From the blog

How to Add Verifiable Execution to an AI Agent in Under 30 Minutes (https://nexart.io/blog/how-to-add-verifiable-execution-to-ai-agent)

Why We Built verify.nexart.io (https://nexart.io/blog/why-we-built-verify-nexart-io)

View all articles (https://nexart.io/blog)

Walk through a real workflow with our team

See how NexArt fits your architecture, compliance requirements, and execution environment. No sales pitch. Just a technical walkthrough on your use case.

Book a Proof Walkthrough (https://nexart.io/contact?intent=walkthrough) · See pricing and plans (https://nexart.io/pricing)

verify.nexart.io (https://verify.nexart.io) · docs.nexart.io (https://docs.nexart.io) · status.nexart.io (https://status.nexart.io)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/how-it-works

**How NexArt Works | NexArt**

NexArt creates verifiable records of AI execution that can be independently checked. Five steps from execution to proof.

How NexArt Works

NexArt creates verifiable records of AI execution that can be independently checked.

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.

Five steps from execution to proof

Execution happens. Your AI system runs a model call, tool call, or automated decision. NexArt does not change how your system works.

A Certified Execution Record is created. Inputs, outputs, and execution context are captured and sealed into a single tamper-evident record. This happens locally, inside your system.

Optional: an independent node certifies the record. An attestation node signs the record. This adds a third-party signature. Certification is separate from local sealing.

Verification checks the record independently. Anyone can verify the record at verify.nexart.io. No account, no login, no API key.

Project Bundles group multiple executions. When a workflow involves multiple steps, individual records are grouped into a single Project Bundle. One artifact covers the entire session.

What to know before you start

The SDK is not the Node. The SDK runs locally and creates records. The Node is an independent service that certifies them.

Local sealing is not certification. Sealing proves a record has not been tampered with. Certification adds independent third-party attestation.

Verification is not a dashboard. verify.nexart.io checks whether a specific record is intact. It does not display analytics or system health.

NexArt proves execution integrity, not correctness. A verified record proves specific inputs produced specific outputs. It does not prove the output was correct.

Start certifying executions (https://nexart.io/adopt) · Product Stack (https://nexart.io/product-stack) · Certified Execution Records (https://nexart.io/certified-execution-records) · verify.nexart.io (https://verify.nexart.io)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/pricing

**Pricing: Certification Plans and API Access | NexArt**

Running AI is easy. Defending it later is the hard part. NexArt pricing gives you independently verifiable execution evidence. Compare Free, Pro, and Enterprise plans for certified AI runs.

Pricing: Certification Plans and API Access

Running AI is easy. Defending it later is the hard part. NexArt pricing gives you independently verifiable execution evidence. Execution is free; independent certification is what you pay for.

What changes when a run is independently certified

An uncertified run is a log entry. A certified run is a tamper-evident artifact: inputs, outputs, parameters, and context bound by SHA-256 and countersigned by an independent attestation node. The Certified Execution Record can be verified by anyone, with no account, at verify.nexart.io.

What you are paying for

You pay for certified runs against the canonical attestation node, key management, retention, and audit-ready evidence. The SDK, CLI, local CER generation, and independent verification are always free.

Plans

Free, $0

100 certified runs per month. Up to 2 active API keys. Shared attestation node. Intended for evaluation and CI.

Pro, $6,000 per year ($600 per month)

5,000 certified runs per month. Up to 5 active API keys. Commercial CodeMode usage. Priority attestation node access. Email support.

Pro+ / Team, $18,000 per year ($1,800 per month)

50,000 certified runs per month. Up to 10 active API keys. Multiple environments. Priority queue.

Enterprise, from $50,000 per year

Custom limits by contract. Private or dedicated attestation node option. Audit retention. Independent key governance and version guarantees. SLAs.

Account-level enforcement

Quota is enforced at the account level, not per API key. API keys exist for environment separation and rotation. You can rotate, revoke, and provision keys without affecting your monthly certified-run allowance.

What we never charge for

SDK

CLI

Local execution

Local CER generation

Independent verification at verify.nexart.io

Not sure which plan fits?

Book a focused technical walkthrough. We will look at your workflow, your audit needs, and the volume of certified runs you actually require.

Book a Proof Walkthrough (https://nexart.io/contact?intent=walkthrough) · Quickstart (https://nexart.io/builders/quickstart) · What is a CER (https://nexart.io/certified-execution-records)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/protocol

**NexArt Protocol: Open Execution Verification Standard**

The NexArt Protocol defines how AI executions are captured, sealed, and independently verified. An open standard for deterministic and tamper-evident execution records across two surfaces.

NexArt Protocol

The NexArt Protocol is an open execution and verification standard for deterministic and integrity-bound systems. It defines how executions are captured, sealed with cryptographic hashes, and independently verified, across two distinct execution surfaces under one versioned trust model.

Two Execution Surfaces

Code Mode provides deterministic, reproducible execution where the same inputs always produce the same output. AI Execution produces tamper-evident records of AI and LLM calls: integrity evidence that anyone can verify independently. Both surfaces share the same canonical hashing rules and attestation model.

Why Verifiable Execution Matters

Logs can describe what happened. They cannot prove it. Execution drift creates silent risk in AI agent decision workflows, compliance-sensitive pipelines, financial simulations, and model evaluation systems. Verifiable execution closes the gap between operator claims and independently checkable evidence.

Protocol-Level Guarantees

Canonical execution semantics defined by the protocol specification

Version-pinned guarantees across time and environments

SHA-256 cryptographic binding of protected fields

Independent Ed25519-signed attestation receipts

Zero-trust verification with no account or API key required

How Verification Works

Capture: inputs, parameters, outputs, and context recorded at runtime

Seal: fields canonicalized and bound with a SHA-256 hash

Attest: independent node issues an Ed25519-signed receipt

Verify: anyone recomputes the hash and confirms independently

Protocol Architecture

The protocol separates the canonical specification (what must be true for a record to verify) from reference implementations (how to produce conforming records). This keeps results portable across SDK versions, runtimes, and attestation nodes that conform to the same protocol version.

Applicable Domains

AI agents: verifiable decision trails for autonomous tool calls

Multi-step pipelines: certify every stage with independently verifiable evidence and group them into a Project Bundle

Regulated workflows: audit-grade execution records for compliance-sensitive operations

Financial simulation: reproducible outcomes for auditable models

Generative systems: canonical, verifiable outputs across environments

Protocol Status

The current protocol version is v1.2.0 for Code Mode and ai.execution.v1 for AI Execution snapshots. Versioned guarantees are documented in the public specification at docs.nexart.io.

Certified Execution Records (https://nexart.io/certified-execution-records) · AI Execution Integrity (https://nexart.io/protocol/ai-execution-integrity) · Get started with the SDK (https://nexart.io/builders/quickstart)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/security

**Security Architecture: Runtime Isolation, Hashing, and Audit Controls | NexArt**

How NexArt enforces isolated, deterministic, and auditable AI execution. Runtime sandboxing, SHA-256 hashing, minimal retention, signed attestation, and SOC 2-aligned security controls.

Security Architecture

Isolated execution. Deterministic integrity. Minimal retention. NexArt's security architecture is designed around three principles: every execution runs in an isolated sandbox, deterministic integrity ensures identical inputs produce identical outputs, and minimal retention means execution payloads are not persisted beyond what is required for verification.

Overview

NexArt is execution integrity infrastructure, not a data warehouse. The security model is built around producing evidence that anyone can independently verify, without trusting NexArt to retain or reveal the underlying payload.

Isolation and Sandboxing

Every execution runs in an ephemeral, sandboxed environment with no network access, no filesystem persistence, and no shared state between executions. This applies both to Code Mode runtime and to attestation node verification work.

Deterministic Integrity

Determinism is not just a feature, it is a security guarantee. Identical inputs always produce identical certificate hashes, enabling independent verification without trusting the original operator or NexArt.

Data Retention and Storage Boundaries

NexArt stores certification metadata and the canonical CER bundle required for verification. Raw execution payloads from integrating systems are the customer's responsibility. See the CER Retention Policy for retention windows and lifecycle states.

Authentication and Access Control

API key authentication with hashed credentials at rest. Account-level quota enforcement. No shared API key pools. Keys can be rotated and revoked from the developer console without affecting outstanding records.

Audit Evidence and Verification

Every certified record can be independently verified at verify.nexart.io with no account, no API key, and no dependency on NexArt being online. Verification recomputes the SHA-256 certificate hash and checks the Ed25519 attestation signature against the issuing node's public key.

Threat Model

NexArt explicitly models threats including record tampering, execution replay attacks, key compromise, node impersonation, and downstream payload manipulation. The integrity guarantee is bound to the certificate hash returned by the attestation node and is not recomputed or overridden by storage.

Standards Alignment

The architecture is designed to support evidence requirements under ISO/IEC 42001, SOC 2 Trust Service Criteria, NIST AI RMF, and EU AI Act high-risk obligations.

What NexArt Does Not Do

NexArt does not validate semantic correctness, score outputs, or guarantee that an AI decision is right. Verification proves integrity of the recorded execution, not correctness of the underlying judgment.

Protocol Overview (https://nexart.io/protocol) · Standards Alignment (https://nexart.io/reference/standards) · CER Retention Policy (https://nexart.io/legal/cer-retention-policy) · Non-Goals (https://nexart.io/non-goals)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/certified-execution-records

**Certified Execution Records (CERs): What They Are and How They Work | NexArt**

CERs replace opaque AI logs with tamper-evident, cryptographically sealed proof of execution. Inputs, outputs, and context bound into a single independently verifiable artifact.

Certified Execution Records

The core artifact of verifiable AI execution. Tamper-evident, independently verifiable proof of what an AI system actually executed. CERs replace opaque AI logs with cryptographically sealed evidence.

The problem with traditional AI logs

Logs are mutable, incomplete, and unverifiable. They can be edited, deleted, or fabricated after the fact. Inputs and outputs are rarely bound together, and there is no cryptographic guarantee that what you see now is what actually happened.

How Certified Execution Records solve this

A CER captures inputs, outputs, parameters, and execution context in a canonical bundle. A SHA-256 certificate hash binds the protected fields. An independent attestation node countersigns the record with an Ed25519 signature. The result is a single artifact that anyone can verify offline, without trusting the operator.

What a CER looks like

Bundle type: cer.ai.execution.v1 (or other versioned types)

Snapshot: inputs, parameters, outputs, model identifier, timestamp

Context: optional execution trace, environment, retrieval and tool calls

Certificate hash: SHA-256 over the canonicalized protected fields

Attestation receipt: Ed25519 signature from an independent node

Logs vs CERs at a glance

Logs describe behavior. CERs prove execution. Logs are observability. CERs are evidence. The two are complementary, but only one holds up under independent audit.

Integrity guarantees

SHA-256 certificate hash over canonicalized fields

Ed25519-signed attestation receipts

Full execution context binding when context is included

Offline verification with no API key or account required

When verifiable execution matters

Regulated workflows, governed decisions, AI agents, financial services, evaluation pipelines, and any system where an AI output may later be challenged.

Who uses CERs

Builders, compliance teams, auditors, and end customers. The same record serves all of them because it can be verified by anyone, with no shared infrastructure dependency.

Getting started

Quickstart (https://nexart.io/builders/quickstart) · AI Execution Integrity (https://nexart.io/protocol/ai-execution-integrity) · What Is a CER (https://nexart.io/blog/what-is-a-certified-execution-record) · Try the demo (https://nexart.io/demos/ai-execution)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/determinism

**Deterministic Execution Records: Canonicalization and Hash Guarantees | NexArt**

How NexArt produces deterministic execution records. Canonical field ordering, stable SHA-256 certificate hashes, and versioned guarantees ensure identical inputs always produce identical proof.

Deterministic Execution Records

Same inputs produce the same certificate hash. Always. This page defines what NexArt guarantees and what it does not.

What we guarantee

For a given protocol version, a canonicalized input set always produces the same SHA-256 certificate hash across runtimes and environments that conform to the specification. Anyone can recompute the hash and confirm the record.

What we do not guarantee

We do not guarantee that the same prompt sent to a non-deterministic model returns the same output. We guarantee that whatever was actually returned is sealed and verifiable. Determinism applies to the record, not to the underlying model behavior.

Best-effort reproducibility

Where the underlying execution is deterministic (Code Mode), reproducibility is exact. Where the underlying execution is best-effort (LLM calls), the record still verifies, even though replaying the call may produce a different output.

Versioning

Canonicalization rules and protocol semantics are version-pinned. Records produced under v1 verify under v1 forever, regardless of later protocol changes.

Breaking changes

Breaking changes happen at major version boundaries only and are documented in the public specification at docs.nexart.io.

Protocol (https://nexart.io/protocol) · Security Architecture (https://nexart.io/security) · Execution Drift (https://nexart.io/blog/execution-drift-in-ai-systems)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/modes

**Modes: Protocol Execution Surfaces | NexArt**

NexArt modes are protocol surfaces for authoring deterministic generative systems. SoundArt, Code Mode, Shapes, and Noise are protocol-enforced and executed via the Code Mode runtime.

Modes: Protocol Execution Surfaces

NexArt supports multiple modes. A mode is a protocol surface for authoring a generative system, with defined inputs, execution semantics, and determinism guarantees. Protocol-enforced modes are executed through the Code Mode runtime and produce canonical units.

SoundArt

SoundArt enables audio-reactive generative systems. Audio input drives output through deterministic parameter mapping. Audio features are normalized into a frozen SoundSnapshot, injected into the Code Mode runtime as read-only parameters, and rendered using seeded randomness and deterministic noise functions. Identical audio input and seed always produce identical output.

Code Mode

Code Mode allows direct specification of execution logic through code. Execution is deterministic. The protocol enforces seeded randomness and controlled noise functions, and disallows non-deterministic operations. Code Mode is the shared execution environment for all protocol-enforced modes.

Shapes

Shapes provides geometric primitives for composition. Systems are built from circles, rectangles, lines, and other basic forms. Shape definitions are processed by the Code Mode runtime using standardized primitive definitions and rasterization rules.

Noise

Noise generates textures and patterns using procedural noise functions such as Perlin, Simplex, and Worley. The same algorithm, parameters, and seed produce identical output across conforming implementations.

Enforcement Status

  ModeEnforcementExecution

    SoundArtHARDCode Mode runtime
    Code ModeHARDProtocol v1.2.0
    ShapesHARDCode Mode runtime
    NoiseHARDCode Mode runtime

Protocol (https://nexart.io/protocol) · Quickstart (https://nexart.io/builders/quickstart)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/reference/standards

**Auditable AI Execution: Standards Alignment for ISO 42001, SOC 2, NIST | NexArt**

How Certified Execution Records and signed attestation receipts map to evidence requirements for ISO/IEC 42001, SOC 2, and NIST AI RMF. Audit-ready evidence from tamper-evident AI execution records.

Auditable AI Execution: Standards Alignment

Certified Execution Records and signed attestation receipts provide structured, tamper-evident evidence that maps to requirements across ISO/IEC 42001, SOC 2, NIST AI RMF, and the EU AI Act.

What NexArt provides

For each certified run, NexArt produces a canonical CER bundle, a SHA-256 certificate hash over the protected fields, and an Ed25519-signed attestation receipt issued by an independent node. The bundle is independently verifiable and exportable for long-term audit storage.

Control outcomes

The evidence supports three control outcomes that auditors typically look for: integrity of the recorded execution, attribution to a specific signing node at a specific time, and reproducibility of the verification result.

Typical audit workflow

Auditor receives a CER ID or bundle from the audited party

Auditor opens the record at verify.nexart.io or recomputes locally with the published verification rules

Hash recomputation and signature check produce a PASS or FAIL result

Result is captured as evidence in the auditor's working papers

What you can claim when verification PASSes

That the captured inputs, outputs, parameters, and context have not been altered since the record was sealed, and that an independent node attested the record at the recorded timestamp.

SOC 2 mapping

Deterministic execution, sandboxed isolation, hashed credentials, and cryptographic binding align with Security, Availability, Processing Integrity, Confidentiality, and Privacy criteria. Certified records provide processing-integrity evidence specifically for AI workflows.

NIST AI RMF mapping

Verifiable execution records support the Govern, Map, Measure, and Manage functions of the NIST AI Risk Management Framework, particularly for documentation, traceability, and post-deployment monitoring.

ISO/IEC 42001 mapping

CERs provide the execution evidence layer required for AI lifecycle documentation, risk management, operational controls, and audit readiness under ISO/IEC 42001 AI Management Systems.

EU AI Act

For high-risk AI systems with obligations effective August 2026, CERs provide the traceability and record-keeping evidence required by Articles 12 and 19, in a form that auditors and notified bodies can independently verify.

What NexArt does not cover

NexArt does not produce policy documentation, run conformity assessments, or provide legal opinions. It produces the verifiable execution evidence layer that those processes consume.

Certified Execution Records (https://nexart.io/certified-execution-records) · Security Architecture (https://nexart.io/security) · Regulated Workflows (https://nexart.io/use-cases/regulated-workflows)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/glossary

**Glossary: NexArt Protocol and CER Terminology | NexArt**

Definitions for Certified Execution Records (CER), certificateHash, attestation nodes, deterministic execution, context signals, and all key terms in the NexArt protocol.

NexArt Glossary

Definitions for key terms used throughout the NexArt protocol documentation. Each term defines how the word is used in NexArt, even if it differs from common usage elsewhere.

System

An execution surface that produces outputs from inputs under defined semantics.

Canonical Unit

A single self-contained execution that can be sealed into a CER.

CER / Certified Execution Record

A tamper-evident bundle binding inputs, outputs, parameters, and context with a SHA-256 certificate hash and an Ed25519 attestation receipt.

certificateHash

The SHA-256 hash over the canonicalized protected fields of a CER bundle. The integrity anchor for the record.

Attestation Node

An independent signing node that issues Ed25519-signed receipts for CERs, attesting that it observed the bundle at a specific time.

Signed Receipt

An Ed25519 signature over the certificate hash issued by an attestation node. Verifiable against the node's published public key.

bundleType

The protocol-versioned identifier for a CER bundle, such as cer.ai.execution.v1.

Project Bundle

A grouping of multiple certified executions into a single verifiable artifact with one Project Hash, used for multi-step or agentic workflows.

Context Signals

Structured signals describing the execution environment, optionally bound into the CER and protected by the certificate hash.

Deterministic Execution

Execution where identical inputs always produce identical outputs. Code Mode is deterministic; AI Execution is best-effort with deterministic record sealing.

Certified Execution Records (https://nexart.io/certified-execution-records) · Protocol (https://nexart.io/protocol) · FAQ (https://nexart.io/faq)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/comparisons/logs-vs-certified-execution-records

**Logs vs Certified Execution Records | NexArt**

Logs track what happened. Certified Execution Records prove it. A comparison of observability logs and cryptographically verifiable execution evidence.

Logs vs Certified Execution Records

Logs track what happened. Certified Execution Records prove it. This comparison explains the difference between observability and verifiable execution evidence.

Certified Execution Records (https://nexart.io/certified-execution-records) · How to Verify AI Execution (https://nexart.io/blog/how-to-verify-ai-execution)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/comparisons/audit-trails-vs-verifiable-execution

**Audit Trails vs Verifiable Execution | NexArt**

Audit trails track access and changes. Verifiable execution proves what AI systems produced. A comparison for compliance and risk teams.

Audit Trails vs Verifiable Execution

Audit trails record who accessed what and when. Verifiable execution records prove what AI systems actually produced. For compliance-sensitive AI, both are necessary.

Certified Execution Records (https://nexart.io/certified-execution-records) · Standards Alignment (https://nexart.io/reference/standards)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/use-cases/ai-agents

**Execution Integrity for AI Agents | NexArt**

AI agents make decisions and invoke tools autonomously. NexArt provides tamper-evident, independently verifiable execution records for every agent step.

Execution Integrity for AI Agents

AI agents act autonomously. When they invoke tools, manage memory, and trigger workflows, every step needs verifiable evidence, not just logs.

Agent Execution (https://nexart.io/agent-execution) · Certified Execution Records (https://nexart.io/certified-execution-records) · Quickstart (https://nexart.io/builders/quickstart)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/use-cases/regulated-workflows

**Execution Evidence for Regulated AI Workflows | NexArt**

Regulated industries need tamper-evident execution evidence. NexArt produces Certified Execution Records that satisfy audit, compliance, and governance requirements.

Execution Evidence for Regulated AI Workflows

When regulators ask 'prove what your AI system did,' logs are not a defensible answer. Certified Execution Records provide audit-grade execution evidence.

Standards Alignment (https://nexart.io/reference/standards) · Certified Execution Records (https://nexart.io/certified-execution-records) · Pricing (https://nexart.io/pricing)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/use-cases/governed-decisions

**Verifiable Evidence for Governed AI Decisions | NexArt**

Governance defines what AI systems should do. NexArt proves what they actually did. Certified Execution Records provide the evidence layer governance platforms cannot.

Verifiable Evidence for Governed AI Decisions

Governance defines what should happen. Execution evidence proves what actually happened. NexArt provides the proof layer that governance platforms cannot.

Certified Decisions (https://nexart.io/certified-decisions) · Certified Execution Records (https://nexart.io/certified-execution-records) · Contact (https://nexart.io/contact)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/use-cases/financial-services

**Financial Services: Verifiable AI for Regulated Finance | NexArt**

Verifiable AI execution for financial services: model decisions, credit assessments, fraud signals, and trading workflows with audit-grade Certified Execution Records.

Financial Services: Verifiable AI for Regulated Finance

Verifiable AI execution for financial services: model decisions, credit assessments, fraud signals, and trading workflows. NexArt produces audit-grade Certified Execution Records aligned with model risk management and supervisory expectations.

Regulated Workflows (https://nexart.io/use-cases/regulated-workflows) · Standards Alignment (https://nexart.io/reference/standards) · Contact Enterprise (https://nexart.io/contact?intent=enterprise)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/use-cases/ai-evaluation

**AI Evaluation: Verifiable Eval Pipelines | NexArt**

Verifiable execution for AI evaluation pipelines. Reproducible eval runs with tamper-evident Certified Execution Records for benchmarks, regressions, and red-team tests.

AI Evaluation: Verifiable Eval Pipelines

Verifiable execution for AI evaluation pipelines. Reproducible eval runs with tamper-evident Certified Execution Records for benchmarks, regressions, red-team tests, and model comparisons. Eval results that hold up to independent audit.

Determinism (https://nexart.io/determinism) · Certified Execution Records (https://nexart.io/certified-execution-records) · Quickstart (https://nexart.io/builders/quickstart)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/builders/quickstart

**Quickstart: NexArt SDK & CLI | NexArt**

Get your first certified run in under 5 minutes. Install the CLI, authenticate, run a sketch, and verify the snapshot.

Quickstart: NexArt SDK & CLI

Get your first certified run in under 5 minutes. Install the CLI, create an API key, run a sketch, and verify the snapshot.

1. Install the CLI

No installation required. Run directly via npx:

npx --yes @nexart/cli@0.4.0 --help

2. Get an API Key

Create an API key in the NexArt dashboard. API keys are used for authentication and environment separation only. Quota is enforced at the account level.

3. Run a Certified Example

Set your environment variables and execute a sketch:

export NEXART_API_KEY=your-api-key
npx @nexart/cli run examples/hello.js --seed 42

This produces a PNG output and a snapshot file containing the Certified Execution Record.

4. Verify the Snapshot

Confirm the execution is deterministic and untampered:

npx @nexart/cli verify out.snapshot.json

Verification recomputes the certificate hash locally and compares it to the recorded value. No network call required.

Builders Overview (https://nexart.io/builders) · CLI Reference (https://nexart.io/builders/cli) · API Documentation (https://nexart.io/docs/api/overview)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/builders/cli

**CLI Reference: NexArt Builders**

NexArt CLI reference for command-line certification, verification, and execution record management.

NexArt CLI Reference

Command-line tools for certification, verification, and Certified Execution Record management. Install via npm, authenticate with your API key, and generate CERs from any environment.

Builders (https://nexart.io/builders) · Quickstart (https://nexart.io/builders/quickstart) · API Overview (https://nexart.io/docs/api/overview)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/builders/certification

**Builder Certification: NexArt**

Certification path for builders integrating NexArt verifiable execution into AI systems and workflows.

Builder Certification

The certification path for builders integrating NexArt verifiable execution into AI systems and workflows. Validate integrations, demonstrate protocol compliance, and earn builder credentials.

Builders (https://nexart.io/builders) · Quickstart (https://nexart.io/builders/quickstart) · Protocol Compliance (https://nexart.io/protocol-compliance)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/docs/api/overview

**API Overview: NexArt**

Overview of the NexArt API for programmatic CER creation and certification. REST endpoints for AI execution certification.

API Overview: NexArt

The NexArt API enables programmatic creation and certification of execution records.

Endpoints

POST /v1/cer/ai/create: Submit an AI execution snapshot for CER generation

POST /v1/cer/ai/certify: Request canonical node certification of a CER

Authentication

API access requires a project-scoped API key, provisioned from the NexArt dashboard.

Rate Limits & Usage

Rate limits and usage quotas are defined per plan tier.

AI CER Creation Endpoint (https://nexart.io/docs/api/ai-cer-creation) · Quickstart (https://nexart.io/builders/quickstart) · Pricing (https://nexart.io/pricing)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/docs/api/certification

**Certification API: NexArt Docs**

REST API reference for the NexArt certification endpoint. Submit execution evidence and receive a signed Certified Execution Record.

Certification API

REST API reference for the NexArt certification endpoint. Submit execution evidence and receive a signed Certified Execution Record with attestation receipt.

API Overview (https://nexart.io/docs/api/overview) · AI CER Creation (https://nexart.io/docs/api/ai-cer-creation) · Quickstart (https://nexart.io/builders/quickstart)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/docs/api/ai-cer-creation

**AI CER Creation Endpoint: NexArt**

REST endpoint for programmatic AI CER creation. Submit execution snapshots and receive tamper-evident Certified Execution Records.

AI CER Creation Endpoint

Submit an AI execution snapshot to produce a Certified Execution Record.

Request

{
  "provider": "openai",
  "model": "gpt-4o",
  "prompt": "Classify sentiment.",
  "input": "The product is excellent.",
  "output": "positive",
  "parameters": { "temperature": 0.7 },
  "app_id": "your-app-id"
}

Response

{
  "cer_id": "...",
  "certificate_hash": "sha256:...",
  "execution_id": "...",
  "status": "created"
}

Request and response schemas are preliminary and subject to change before release.

API Overview (https://nexart.io/docs/api/overview) · Quickstart (https://nexart.io/builders/quickstart) · Pricing (https://nexart.io/pricing)

  How to adopt NexArt (https://nexart.io/adopt)
  Product Stack (https://nexart.io/product-stack)
  Protocol (https://nexart.io/protocol)
  Certified Execution Records (https://nexart.io/certified-execution-records)
  Security (https://nexart.io/security)
  Trust Center (https://nexart.io/trust)
  Pricing (https://nexart.io/pricing)
  Buyer FAQ (https://nexart.io/buyer-faq)
  Canonical Node (https://nexart.io/canonical-node)
  LangChain (https://nexart.io/integrations/langchain)
  n8n (https://nexart.io/integrations/n8n)
  Blog (https://nexart.io/blog)
  Glossary (https://nexart.io/glossary)
  Contact (https://nexart.io/contact)
  Verify a Record (https://verify.nexart.io)

---

# https://nexart.io/blog/execution-evidence-layer-where-nexart-fits

**The Execution Evidence Layer: Where NexArt Fits in the AI Stack**

Published: 2026-04-30

Where does NexArt fit in the AI stack? This guide explains the execution evidence layer and why Certified Execution Records are different from models, orchestration, observability, and policy tools.

---

# https://nexart.io/blog/client-challenges-ai-output-logs-not-enough

**When a Client Challenges Your AI Output, Will Logs Be Enough?**

Published: 2026-04-26

For small AI companies, the real pressure is not only regulation. It is what happens when a client says your system got it wrong and asks you to prove what executed. Why logs support reconstruction, but stronger execution evidence supports defense.

---

# https://nexart.io/blog/opentelemetry-vs-verifiable-execution

**OpenTelemetry vs Verifiable Execution: Why Logs and Traces Aren’t Enough for AI Systems**

Published: 2026-04-22

OpenTelemetry vs verifiable execution: what logs, traces, and telemetry solve, where they stop, and why AI systems increasingly need a stronger execution evidence layer.

---

# https://nexart.io/blog/verifiable-execution-infrastructure

**The Missing Proof Layer in AI: Verifiable Execution Infrastructure**

Published: 2026-04-15

What is verifiable execution infrastructure? A Medium-ready guide to the emerging AI infrastructure layer focused on structured execution artifacts, independent verification, and why logs are no longer enough for reviewable AI systems.

---

# https://nexart.io/blog/prove-workflow-that-produced-it

**Your AI Made a Decision. Can You Prove the Workflow That Produced It?**

Published: 2026-04-07

A Medium-optimised deep dive on why AI logs are not enough for multi-step workflows, and how NexArt extends Certified Execution Records with Project Bundles and agent-kit to support workflow-level evidence.

---

# https://nexart.io/blog/how-nexart-protects-execution-evidence

**How NexArt Protects AI Execution Evidence From Tampering**

Published: 2026-04-03

Learn how NexArt's Certified Execution Records create tamper-evident, independently verifiable AI execution evidence, and how hardware-backed attestation extends trust for high-assurance enterprise environments.

---

# https://nexart.io/blog/verifiable-execution-langchain-n8n

**How to Add Verifiable Execution to LangChain and n8n Workflows (with NexArt)**

Published: 2026-04-02

Most AI workflow tooling helps you run chains, agents, and automations. Very little helps you prove what actually ran later. This article walks through adding Certified Execution Records to LangChain and n8n workflows.

---

# https://nexart.io/blog/what-is-aief

**What Is the AI Execution Integrity Framework (AIEF) — And Why AI Systems Need It Now**

Published: 2026-03-31

There is no widely adopted standard that defines what verifiable AI execution means in practice. The AI Execution Integrity Framework (AIEF) proposes a structured approach to making AI decision records complete, tamper-evident, and independently verifiable.

---

# https://nexart.io/blog/high-risk-ai-businesses-eu-ai-act

**What to Build in 2026: High-Risk AI Businesses That Win Under the EU AI Act**

Published: 2026-03-30

The EU AI Act creates a new category of compliance-native AI businesses. This article explores the high-risk SaaS opportunities emerging in finance, hiring, insurance, and education — and why verifiable execution infrastructure is the foundation.

---

# https://nexart.io/blog/eu-ai-act-2026-checklist

**EU AI Act 2026 Checklist: Are Your High-Risk AI Systems Actually Audit-Ready?**

Published: 2026-03-28

With the EU AI Act high-risk obligations taking effect in August 2026, many teams are discovering that traditional logs may fall short for traceability and record-keeping. Use this practical checklist to assess whether your AI systems are actually audit-ready.

---

# https://nexart.io/blog/how-to-add-verifiable-execution-to-ai-agent

**How to Add Verifiable Execution to an AI Agent in Under 30 Minutes**

Published: 2026-03-27

Most agent systems rely on logs for accountability, but logs are not proof. This guide walks through adding Certified Execution Records to an AI agent workflow using the NexArt SDK — in under 30 minutes.

---

# https://nexart.io/blog/why-we-built-verify-nexart-io

**Why We Built verify.nexart.io**

Published: 2026-03-26

Most AI systems do not provide a clean way to independently verify what actually ran. verify.nexart.io is a public verification surface for Certified Execution Records — where execution evidence becomes independently checkable.

---

# https://nexart.io/blog/verifiable-ai-execution-vs-zkml

**Verifiable AI Execution vs zkML: What NexArt Proves, What It Doesn't, and How Privacy Works in Practice**

Published: 2026-03-24

NexArt and zkML both fall under 'verifiable AI,' but they solve different trust problems. This article clarifies the distinction between execution evidence and computation proofs, and outlines NexArt's practical privacy model.

---

# https://nexart.io/blog/ai-auditability-eu-ai-act

**AI Auditability and the EU AI Act: Why Execution Evidence Matters**

Published: 2026-03-24

The EU AI Act requires auditable AI systems, but most are built for observability, not auditability. This article explains why execution evidence — not logs — is the foundation of real AI auditability.

---

# https://nexart.io/blog/ai-audit-trails-vs-verifiable-execution

**AI Audit Trails vs Verifiable Execution**

Published: 2026-03-23

Audit trails provide visibility, but visibility is not proof. This article explores the gap between tracking behavior and proving execution, and why verifiable execution is emerging as a new standard for AI auditability.

---

# https://nexart.io/blog/execution-drift-in-ai-systems

**Execution Drift in AI Systems (and Why It Matters More Than You Think)**

Published: 2026-03-20

Two executions with the same inputs can produce different results. Execution drift is not a bug; it is a property of modern AI systems. The challenge is making it visible, explainable, and verifiable.

---

# https://nexart.io/blog/what-is-a-certified-execution-record

**What Is a Certified Execution Record (CER)?**

Published: 2026-03-19

Most AI systems produce logs, but logs are not proof. A Certified Execution Record is a cryptographically verifiable artifact that turns execution into independently validatable evidence.

---

# https://nexart.io/blog/how-to-verify-ai-execution

**How to Verify AI Execution (and Why Logs Are Not Enough)**

Published: 2026-03-18

Most AI systems rely on logs for accountability, but logs are not proof. This article explores why verification requires a different model, and how Certified Execution Records turn execution into independently verifiable evidence.

---

# https://nexart.io/blog/verifiable-ai-execution

**The Missing Layer in AI Systems: Verifiable Execution**

Published: 2026-03-14

Most AI systems produce logs that are mutable, incomplete, or opaque. Certified Execution Records replace them with tamper-evident, cryptographically sealed proof of what actually happened.

---