nexart.iodocs

    Getting Started

    Pick the path that matches your use case: a single execution CER, or a multi-step Project Bundle.

    What NexArt Does

    NexArt creates Certified Execution Records (CERs), cryptographically bound records of AI or deterministic execution that can be independently verified.

    Every CER produces a deterministic certificateHash. 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.

    Two Integration Paths

    NexArt supports both single-execution certification and multi-step workflow certification. Pick the one that matches your use case. You do not need Project Bundles for every integration.

    Path A - Single CER
    One execution, one verifiable record.
    • Run the execution
    • Create a CER (@nexart/ai-execution)
    • Optional: verify locally
    • Optional: attest via node and share /c/{certificateHash}
    Path B - Project Bundle
    Multi-step or multi-agent workflows verified as a unit.
    • Create a CER per step
    • Assemble a Project Bundle
    • Register the bundle on the node
    • Verify publicly at verify.nexart.io

    Install the SDK

    npm install @nexart/ai-execution

    Current version: @nexart/ai-execution@0.15.0.

    Path A: Create a Single CER

    The simplest integration. One execution produces one verifiable record.

    Single CER
    import { createLangChainCer } from "@nexart/ai-execution";

const { certificateHash } = createLangChainCer({
  provider: "openai",
  model: "gpt-4o-mini",
  input: {
    messages: [{ role: "user", content: "What is 2 + 2?" }]
  },
  output: {
    text: "4"
  }
});

console.log(certificateHash);

    The certificateHash is the canonical identity of the record. Verify the CER locally with the SDK, or share the public URL https://verify.nexart.io/c/{certificateHash}.

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

    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.

    Linear workflow with @nexart/agent-kit
    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.

    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

    LangChain example
    Create and verify CERs in LangChain chains and agent workflows.
    github.com/artnames/nexart-langchain
    n8n example
    Turn n8n workflow outcomes into Certified Execution Records.
    github.com/artnames/nexart-n8n

    Next Steps