# Trust Model and Verification Boundaries

URL: https://docs.nexart.io/docs/trust-model

The NexArt trust model: what the attestation node attests, what verifiers can check on their own, and why NexArt infrastructure sits outside the verification.

## How Trust Works

NexArt establishes execution integrity through three mechanisms:

- Deterministic hashing. Every CER bundle produces a unique `certificateHash` (SHA-256). Any change to the record changes the hash.
- Node attestation. An attestation node signs the certificateHash using Ed25519, producing a receipt stored at `meta.attestation` in the CER bundle.
- Independent verification. Anyone can verify the record using the CER bundle and the node's published public keys. No API access is required.

## Operational Guarantees

NexArt nodes enforce strict operational guarantees when certifying execution records:

- Deterministic identity.- The same execution produces the same `certificateHash`.
- Hash computation is defined by the SDK and never modified by the node.
- Idempotent certification.- One `execution_id` maps to one `certificateHash` forever.
- Re-submission with identical content returns the original record.
- Mutated re-submissions are rejected with `EXECUTION_MUTATION_DETECTED`.
- Controlled attestation.- Only authorized API keys can request certification.
- Administrative operations (such as recertification) require elevated credentials.
- Independent verification.- Verification logic is delegated to the SDK.
- The node does not reinterpret or override verification outcomes.
- Immutable attestation.- Once certified, a record cannot be altered without invalidating its `certificateHash`.

## Certification Flow

Here is what happens when you call `POST /v1/cer/ai/certify`:

Certification Flow

```
1. Your application sends execution data to the NexArt API
2. NexArt creates a CER bundle (bundleType: "cer.ai.execution.v1")
   and computes the certificateHash (SHA-256)
3. The attestation node signs the certificateHash → produces a receipt
4. The API returns:
   - certificateHash
   - receipt (with timestamp, nodeId, kid)
   - signatureB64Url
   - verificationUrl
5. Anyone can verify the record at the verificationUrl or independently
```

In the CER bundle, the receipt and signature are stored at `meta.attestation`. The API response duplicates them at the top level for convenience.

## Node Attestation

The attestation node is an independent witness. It does not define truth or control verification. When it signs a CER, it produces a receipt that proves:

- The node witnessed the CER bundle at a specific time
- The certificateHash was computed from the bundle at that time
- The node's identity is bound to the receipt

Nodes sign using Ed25519. Their public keys are published at a well-known endpoint so anyone can verify independently:

Node Key Discovery

```
GET node.nexart.io/.well-known/nexart-node.json

{
  "nodeId": "nexart-node-primary",
  "activeKid": "key_01HXYZ...",
  "keys": [
    {
      "kid": "key_01HXYZ...",
      "algorithm": "Ed25519",
      "publicKey": "MCowBQYDK2VwAyEA..."
    }
  ]
}
```

The node does not store or own the execution data. It witnesses the record and produces a cryptographic proof.

## Independent Verification

Verification can be performed independently using:

- the CER bundle
- the node's published public keys

Two levels of verification exist:

- Full verification.- Requires access to the complete CER bundle.
- Allows recomputation of the `certificateHash` and validation of all signatures.
- Public verification.- Uses a redacted representation of the bundle.
- Confirms:- the node attested a specific `certificateHash`
- the receipt signature is valid
- Does not expose or allow recomputation of the original input/output data.

## What Attestation Proves (and Does Not Prove)

Attestation proves that:

- The CER existed at the attested timestamp
- The record has not been modified since attestation
- A specific node witnessed and signed the record

Attestation does not prove that:

- The execution itself was correct or accurate
- The inputs or outputs were truthful
- The application behaved as intended

NexArt certifies that a record is intact and was witnessed. It does not evaluate the content of the execution.

## Trust Boundaries

- NexArt does not store raw prompts or outputs. CERs contain hashes, not payloads.
- NexArt does not act as a certificate authority for user identity.
- The integrating application controls what metadata is included in the CER.
- Public verification uses a redacted representation. Sensitive data is not exposed.

Important
Verification proves that a record is intact and was witnessed. It does not prove that the execution itself was correct or truthful.