# NexArt Evidence Bridge

> NexArt Evidence Bridge is a standalone integration service that converts the JSON an application already produces into structured, cryptographically verifiable NexArt execution evidence. A developer publishes a deterministic mapping profile once, then continues sending the application's existing JSON format instead of constructing NexArt evidence schemas manually. Evidence is created and verified locally; NexArt Node attestation is an optional, separate step.

Primary category: AI Evidence Layer / Verifiable Execution Infrastructure

## What it does

The Evidence Bridge connects an existing application or system to NexArt without requiring that application to adopt a NexArt evidence schema directly.

For each ingestion, the Bridge:

- authenticates the customer;
- validates the source request;
- applies an immutable, published mapping profile deterministically;
- records field-level provenance, source-integrity hashes, and profile identity;
- checks whether the mapped event is eligible for a configured evidence target;
- creates the applicable NexArt evidence record;
- locally verifies the evidence; and
- persists the result and its certificate identity.

The original raw ingestion JSON is hashed, parsed, mapped, and discarded rather than retained as a raw customer payload.

## Core concepts

- **Mapping Profile:** An explicit, versioned set of rules translating a customer's existing event shape into the Bridge's internal evidence shape. Published revisions are immutable.
- **Deterministic transformation:** The same published profile, supported engine version, and source input produce the same mapped meaning and integrity identities.
- **Provenance:** A record of where each mapped field originated and which declared transformation produced it.
- **Certificate hash:** The cryptographic identity of the created Certified Execution Record (CER). It is not simply a hash of the original JSON.
- **Local verification:** Integrity checks performed by the Bridge when evidence is created and again before attestation.
- **Node attestation:** An optional, additive request that submits the exact persisted CER to NexArt Node without reconstructing or resealing it.
- **Independent verification:** Validation of evidence integrity and, when present, the authenticity of a trusted Node receipt.

Auto-map is an authoring convenience that proposes mappings in the browser. A developer must review those suggestions. Auto-map is not part of the trusted evidence runtime and does not publish profiles or create certification by itself.

## Supported evidence

- **Confidential AI Execution V2:** AI execution evidence in which protected fields can be represented using confidential commitments while preserving verifiability. Private openings are stored separately in tenant-scoped private storage.
- **Consequential Execution V1:** Execution-stage evidence representing consequential actions, changes, outcomes, and related execution information.

These records can establish integrity of the recorded evidence artifact. They do not establish factual correctness, fairness, legal compliance, provider execution truth, policy approval, or completeness of every event in a customer's system.

## Integration model

Customer application
→ Bridge ingestion
→ deterministic mapping
→ locally verified NexArt evidence
→ optional NexArt Node attestation
→ independent verification

### Stage 1: Ingest

`POST /api/v1/ingest/{profileId}/{revision}`

The customer authenticates with its NexArt `nx_live_...` machine credential and sends its existing JSON plus an `Idempotency-Key`. The Bridge performs deterministic mapping, evidence creation, local verification, and persistence. This request does not contact NexArt Node.

The customer's application supplies the Idempotency-Key. NexArt does not issue it. A stable event, transaction, job, or workflow-run identifier is appropriate. If none exists, the application should generate a UUID once for the logical event and retain it for retries.

### Stage 2: Attest

`POST /api/v1/results/{resultId}/attest`

The Bridge loads and re-verifies the existing persisted CER, preserves its certificate hash, and sends that unchanged evidence to NexArt Node using the customer's machine credential. The Bridge verifies the Node identity and Ed25519-signed receipt, records independent RFC 3161 timestamp status when available, and stores the attestation result. Retries reuse the original evidence rather than resealing it.

The ingestion response returns a result ID and the available integrity and evidence state. Customers can inspect the persisted result through the authenticated Bridge application. After successful attestation, the result includes the unchanged certificate hash, Node receipt identity, signature-verification status, attestation time, Node runtime hash, and timestamp-verification status where applicable.

## Important boundaries

The Evidence Bridge is not:

- an AI model, AI agent, or AI execution runtime;
- a policy engine or compliance decision system;
- a correctness, fairness, or legal-compliance verifier;
- an observability platform, generic log collector, or monitoring replacement;
- an arbitrary customer-code or scripting runtime; or
- proof that every relevant event was submitted.

The Bridge does not run the customer's AI, determine whether an AI decision is correct, generate policy verdicts, execute arbitrary customer code, or silently change customer events. It transforms declared execution data into tamper-evident evidence according to an explicit published mapping profile.

Tenant ownership is enforced through authentication and tenant-scoped storage rather than being embedded into evidence hashes. Node attestation is additive: NexArt Node does not create or transform the Bridge evidence.

## Relevant public resources

- Evidence Bridge: https://bridge.nexart.io/
- NexArt: https://nexart.io/
- NexArt documentation: https://docs.nexart.io/
- NexArt verifier: https://verify.nexart.io/
- Full machine-readable Bridge reference: https://bridge.nexart.io/llms-full.txt