Getting Started with NexArt

Quick Implementation Flow

Four steps. Each has a single responsibility. Following them in order produces a record anyone can verify without trusting your infrastructure.

Minimal working example

One execution, one CER, one certification, one verification. This is the canonical example reused across the docs.

import {
  certifyAndAttestDecision,
  verifyAiCerBundleDetailed,
} from "@nexart/ai-execution";

// Steps 1-3: capture execution, seal the CER, attest via the node.
// certifyAndAttestDecision is async because it contacts the attestation node.
const { bundle, receipt } = await certifyAndAttestDecision(
  {
    provider:   "openai",
    model:      "gpt-4o-mini",
    prompt:     "Should this refund be approved?",
    input:      { messages: [{ role: "user", content: "Should this refund be approved?" }] },
    parameters: { temperature: 0, maxTokens: 1024, topP: null, seed: null },
    output:     { decision: "approve", reason: "policy_passed" },
  },
  {
    nodeUrl: process.env.NEXART_NODE_ENDPOINT!,
    apiKey:  process.env.NEXART_API_KEY!,
  },
);

const certificateHash = bundle.certificateHash;
const verificationUrl = `https://verify.nexart.io/c/${certificateHash}`;

console.log(certificateHash);         // sha256:...
console.log(receipt.attestationId);   // node-issued id
console.log(verificationUrl);         // https://verify.nexart.io/c/sha256:...

// Step 4: independent verification. No trust in your infrastructure required.
const report = await verifyAiCerBundleDetailed(bundle);
// report.checks.bundleIntegrity    -> PASS  (Layer 1)
// report.checks.nodeSignature      -> PASS  (Layer 2)
// report.checks.receiptConsistency -> PASS  (Layer 3)

import { certifyDecision, verifyAiCerBundleDetailed } from "@nexart/ai-execution";

// certifyDecision is synchronous and deterministic.
// It produces a sealed CER bundle and certificateHash WITHOUT contacting the node.
// There is no receipt, no envelope, and no public verificationUrl in this flow.
const bundle = certifyDecision({
  provider:   "openai",
  model:      "gpt-4o-mini",
  prompt:     "Should this refund be approved?",
  input:      { messages: [{ role: "user", content: "Should this refund be approved?" }] },
  parameters: { temperature: 0, maxTokens: 1024, topP: null, seed: null },
  output:     { decision: "approve", reason: "policy_passed" },
});

const certificateHash = bundle.certificateHash;
console.log(certificateHash);   // sha256:...

// Local verification: Layer 1 PASS, Layers 2 & 3 SKIPPED.
const report = await verifyAiCerBundleDetailed(bundle);

// To obtain a signed receipt, attest the bundle. Public lookup is a separate publication step.
// via certifyAndAttestDecision(...) or attest(bundle, options).

What NexArt Does

NexArt is the AI Evidence Layer: verifiable execution infrastructure that produces cryptographic evidence about what was executed. NexArt creates Certified Execution Records (CERs), cryptographically bound records of AI or deterministic execution that can be independently verified.

Every CER carries a certificateHash, computed with the canonicalization profile bound to its protocolVersion (for example jcs-v1 for AI Execution V2). That hash is the canonical identity of the record. Optional node attestation produces a signed receipt so anyone can verify the record without trusting your infrastructure.

Multi-step or multi-agent workflow? Follow Path A first, then see Path B: Project Bundle.

Step 1 of 4: Install the SDK

npm install @nexart/ai-execution

Current version: @nexart/ai-execution@1.4.0. See AI Execution V2 for the full V2 schema reference.

Steps 2 and 3 of 4: Seal and verify locally, then attest (Path A, V2)

The primary happy path. One execution produces one verifiable V2 record. Sealing is fully offline (no API key, no network call); attestation is a single call to the node. Every V2 record declares an executionRole ('advisory' | 'operative' | 'unspecified'), and, when an instruction is present, a matching instructionKind ('system' | 'derived' | 'label'). Both are producer-declared; NexArt never infers them.

import { certifyDecisionV2, attest, verifyCerV2 } from "@nexart/ai-execution";

// certifyDecisionV2 is synchronous. No network call.
const bundle = certifyDecisionV2({
  provider:       "openai",
  model:          "gpt-4o-mini",
  instruction:    "Answer the user's arithmetic question.",
  instructionKind: "system",
  input:          { messages: [{ role: "user", content: "What is 2 + 2?" }] },
  parameters:     { temperature: 0, maxTokens: 1024, topP: null, seed: null },
  output:         { text: "4" },
  executionRole:  "advisory",
});

const certificateHash = bundle.certificateHash;
console.log(certificateHash);

// Local verification, no node call. Re-derives protectedSet and re-checks hashes.
const local = verifyCerV2(bundle);
// local.code === "OK", local.verdict === "VERIFIED"

// Attest to the node. The certificateHash already exists; attest() never
// creates or replaces it.
const attestation = await attest(bundle, {
  nodeUrl: process.env.NEXART_NODE_ENDPOINT!,
  apiKey:  process.env.NEXART_API_KEY!,
});
// attestation.ok === true

The certificateHash is the canonical identity of the record and does not change between sealing and attestation. attest() POSTs the already-sealed bundle to the node's /api/attest route, which dispatches on bundleType and accepts both cer.ai.execution.v1 and cer.ai.execution.v2.

Note: executionId is not a unique artifact identifier. Always look up records by certificateHash.

import { certifyDecision, verifyAiCerBundleDetailed } from "@nexart/ai-execution";

// certifyDecision (V1, from @nexart/ai-execution) is synchronous. No network call.
const bundle = certifyDecision({
  provider:   "openai",
  model:      "gpt-4o-mini",
  prompt:     "What is 2 + 2?",
  input:      { messages: [{ role: "user", content: "What is 2 + 2?" }] },
  parameters: { temperature: 0, maxTokens: 1024, topP: null, seed: null },
  output:     { text: "4" },
});

const certificateHash = bundle.certificateHash;

const report = await verifyAiCerBundleDetailed(bundle);
// report.checks.bundleIntegrity    === "PASS"
// report.checks.nodeSignature      === "SKIPPED"  (no node attestation yet)
// report.checks.receiptConsistency === "SKIPPED"  (no envelope yet)

Path B: Workflow with a Project Bundle

For multi-step or multi-agent workflows, certify each step as its own CER and group them into a Project Bundle. The bundle has its own projectHash covering all step certificateHash values.

import { startWorkflow } from "@nexart/agent-kit";

const workflow = startWorkflow({ projectTitle: "Contract review" });

const clauses = await workflow.step("Extract clauses", async () => {
  return await llm.call("Extract key clauses...");
});

const risks = await workflow.step("Summarize risks", async () => {
  return await llm.call("Summarize risks from: " + clauses);
});

const bundle = workflow.finish();
// bundle.integrity.projectHash is the verifiable hash

For public verification on verify.nexart.io, the bundle must be registered on the node. See End-to-End Verification for the full registration flow.

Step 4 of 4: Verify the record

Verification can be performed independently. Open https://verify.nexart.io and paste the certificateHash, or open the URL directly:

https://verify.nexart.io/c/{certificateHash}

Official Example Repos

Common mistakes

What happens if it fails

Next Steps

• Quickstart: the shortest path through both paths
• AI Execution V2: full V2 schema, executionRole, instructionKind, decisionRefs
• Migration: V1 to V2 and V1/V2 Compatibility
• Glossary and AIEF: precise terminology and claim boundaries
• Project Bundles: how multi-step workflows are grouped and verified
• End-to-End Verification: node registration and public verification
• LangChain and n8n: framework integrations
• CLI: create and verify CERs from the command line