Client Onboarding & Integration Guide

How your institution evaluates DISCINTEL during early access, prepares its own governance model, and checks the evidence without having to take our word for it.

Updated October 23, 2026 · Early access · For evaluation teams, risk and compliance leads, and the engineers who would connect AI agents

What changed on 23 October: the AI processing row, the subprocessor list and the runtime governor entry. Legal Intelligence is named as the only feature that sends content to an AI model provider, Anthropic is listed as its subprocessor, and production is stated to run the governor in shadow mode.

What changed on 21 October: rows for Legal Intelligence, handoffs, agent revalidation and language in What's available today, a matching Known limitations entry, and a link from the status row for guided tours to the Spanish and French tours.

What changed on 15 October: a row for the guided tours in What's available today.

What changed on 14 October: two rows added to What's available today: jurisdiction control (available now) and DORA and NIS2 regulatory context (available, limited).

1. Before you start

These four points shape everything else in the guide.

• Early access is an evaluation, not a production service. DISCINTEL is free during early access and features may change. The Terms of Service and Privacy Policy are drafts that are not yet in effect.
• You evaluate on a sample institution. Every Business workspace runs ACME Financial Services, a fictional institution with simulated approvers, a simulated sanctions list and a simulated payment rail. No real money moves and none of your systems are called.
• Each sign-in has its own workspace. Colleagues who sign up get separate workspaces; there is no shared team workspace yet. Plan the evaluation so each person runs the exercises on their own.
• Don't upload real customer or personal data. Use the sample, or de-identified files, until a data processing agreement is in place.

2. What's available today

Everything marked available can be tested in your workspace now. Everything marked not yet available is designed but not built or connected, and has no committed date.

3. Onboarding, step by step

Plan on about an hour for one evaluator to get from sign-up to a verified evidence package.

1. Create the account. Go to app.getdiscintel.com and choose Create free account. Use a passkey (Face ID, Touch ID or Windows Hello) if you can; there's nothing to phish. Verify your email, then choose Business.
2. Initialize the sample institution. On first visit choose Initialize sample institution. It loads the institution's records, records its own setup as the first evidence events, and starts the sample request with a 48-payment wire file. You act as Olivia Carter, Treasury Manager, a demo persona.
3. Confirm you're saving to the server. The status chip in the top bar should read Persisted · Netlify. If it doesn't, see Troubleshooting.
4. Record a baseline. In Reports & Assurance, generate the NAIC evidence package and run the verifier from section 7 on it. Its last lines read Record this head: <sequence>:<hash>. Keep that line, and the package, somewhere outside DISCINTEL, such as your evaluation file. It's how you'll show later that the log only grew.
5. Run the evaluation checklist. Work through section 4. Each exercise names what you should see.
6. Exercise administration. Follow at least one play in the Admin playbook, for example suspending and reinstating an agent, so your control owners see that changes to governance are themselves governed.
7. Export and verify again. Generate a new NAIC package and an action package, and run the verifier on them, checking the new NAIC package against your baseline as shown in Checking the log only grew.
8. Map your institution. Fill in the worksheet in section 5 with your risk and technology owners. It is the input for a pilot once your own records can be loaded.

4. Evaluation checklist

Each exercise tests one control. The expected result is what the sample produces. If you see something else, note the evidence sequence number from TrustDNA Evidence and tell us.

5. Mapping your institution

DISCINTEL models governance as 19 record types in five groups. Today a workspace holds only the sample institution, so this worksheet is preparation: it is what your own deployment would be built from once loading your records is available.

Consequence classes

Every agent and tool carries one, from A (low) to D (regulated or financial). Assign it from the worst thing the agent or tool could do, not the usual case.

Questions to settle before a pilot

• Which single, bounded workflow will the pilot govern, and which agent performs it?
• Who approves, and what thresholds trigger each approval?
• Which system executes, and what does its receipt contain?
• Which independent source confirms the outcome: a ledger, a statement, a downstream record?
• Which environments does the workflow run in, and must Test be physically separate from Production for you?
• Who reviews the evidence packages, and how often?

6. How integration works

This flow runs end to end in the sample today, with the payment rail and the observer simulated. Connecting it to your own agents and systems is designed but not yet available: no client credentials or connectors are issued.

Integration points

The admission contract

The server enforces these rules today. They are what a connected system would rely on.

• A decision is bound to the file hashes, agent, tool, environment and tool status it was made on. A change to any of them retires it.
• Admission re-checks everything: the decision is still effective, approvals are complete, files are unchanged, the agent and environment are unchanged, and the tool is active and permitted for that agent.
• An admission works once, expires after five minutes and is bound to a hash of the exact request. A replay, or any change to the request, is refused and recorded.
• Withdrawal is possible up to execution and invalidates the decision, approvals and admission together.
• Closure is evaluated by the server. An action closes only when the observed outcome matches the request and the evidence trail is complete.
• A receipt is a claim; an outcome is evidence. Only an observed outcome confirms that what was approved is what happened.

7. Verifying evidence yourself

You shouldn't have to trust DISCINTEL's own screen. Every evidence package can be checked on any machine with Node.js 18 or later, using only built-in cryptography and no network access.

What a package contains

How the hashes are computed

Canonical JSON means object keys sorted, keys beginning with an underscore left out, and no whitespace. Then:

event_hash   = SHA-256( prev_hash + canonical(event without event_hash) )
prev_hash    = event_hash of the previous event (64 zeros for the first event)
package_hash = SHA-256( canonical(package without package_hash) )
file hash    = SHA-256( the file's exact bytes )

Run the verifier

Download the script, or copy it below and save it as verify-discintel-package.mjs, then run it on a package, optionally followed by original files you uploaded and still hold:

node verify-discintel-package.mjs discintel_naic_v5_<time>.json payments.csv

It checks the seal, recomputes every event hash, checks each link, requires an institution package to run unbroken from the first event, and matches your files to the fingerprints recorded when you provided them. For an institution package it ends by printing the head to record. It exits with 0 when everything passes and 1 when anything fails.

#!/usr/bin/env node
// Independently verify a DISCINTEL evidence package (NAIC or action package).
// Usage:
//   node verify-discintel-package.mjs <package.json> [file-you-provided ...]
//   node verify-discintel-package.mjs <package.json> --since <earlier-package.json>
//   node verify-discintel-package.mjs <package.json> --expect-head <sequence>:<event_hash>
// Needs Node 18 or later. Uses only Node's built-in crypto; sends nothing anywhere.
import { readFileSync } from "node:fs";
import { createHash } from "node:crypto";
import { basename } from "node:path";

// Canonical JSON, identical to DISCINTEL's: keys sorted, keys starting with "_" dropped, undefined as null.
const canon = (v) => Array.isArray(v) ? "[" + v.map(canon).join(",") + "]"
  : v && typeof v === "object" ? "{" + Object.keys(v).filter((k) => !k.startsWith("_")).sort()
      .map((k) => JSON.stringify(k) + ":" + canon(v[k])).join(",") + "}"
  : JSON.stringify(v === undefined ? null : v);
const sha256 = (data) => createHash("sha256").update(data).digest("hex");
const ZERO = "0".repeat(64);
const usage = () => { console.error("usage: node verify-discintel-package.mjs <package.json> [file ...] [--since <earlier-package.json>] [--expect-head <sequence>:<event_hash>]"); process.exit(2); };

// Arguments: the package, then any mix of files and options.
const args = process.argv.slice(2), files = [], expect = [];
let pkgPath = null;
for (let i = 0; i < args.length; i++) {
  const a = args[i];
  if (a === "--expect-head") {
    const m = /^(\d+):([0-9a-f]{64})$/i.exec(args[++i] || "");
    if (!m) { console.error("--expect-head needs <sequence>:<64-character event_hash>, as printed under 'Record this head'"); process.exit(2); }
    expect.push({ sequence: Number(m[1]), event_hash: m[2].toLowerCase(), from: "--expect-head" });
  } else if (a === "--since") {
    const p = args[++i]; if (!p) usage();
    const old = JSON.parse(readFileSync(p, "utf8"));
    if (!old.chain_head) { console.error(`${basename(p)} has no chain_head to compare against`); process.exit(2); }
    expect.push({ sequence: old.chain_head.sequence, event_hash: old.chain_head.event_hash, from: basename(p) });
  } else if (a.startsWith("--")) usage();
  else if (!pkgPath) pkgPath = a; else files.push(a);
}
if (!pkgPath) usage();
const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
let failed = 0;
const report = (ok, msg) => { console.log((ok ? "PASS  " : "FAIL  ") + msg); if (!ok) failed++; };

// 1. Package seal: SHA-256 of the canonical package without its own package_hash.
const { package_hash, ...body } = pkg;
report(sha256(canon(body)) === package_hash, `package seal ${String(package_hash).slice(0, 16)}… (${pkg.package_type}, generated ${pkg.generated_at})`);

// 2. Every evidence event: its hash recomputes from its own content and the previous event's hash.
const evs = [...(pkg.evidence_events || [])].sort((a, b) => a.sequence - b.sequence);
let bad = 0;
for (const e of evs) { const { event_hash, ...rest } = e; if (sha256(String(e.prev_hash) + canon(rest)) !== event_hash) bad++; }
report(bad === 0, `event hashes: ${evs.length - bad} of ${evs.length} recompute`);

// 3. Links: where consecutive sequences are both present, each prev_hash equals the event before it.
let links = 0, broken = 0;
for (let i = 1; i < evs.length; i++) if (evs[i].sequence === evs[i - 1].sequence + 1) { links++; if (evs[i].prev_hash !== evs[i - 1].event_hash) broken++; }
const full = evs.length > 0 && evs[0].sequence === 1 && evs[0].prev_hash === ZERO && links === evs.length - 1;
report(broken === 0, `chain links: ${links - broken} of ${links} consecutive links match` + (full ? " (complete chain from genesis)" : pkg.package_type === "ACTION_EVIDENCE" ? " (an action package carries only that action's events)" : ""));

// 4. An institution (NAIC) package carries the whole log: it must run unbroken from genesis to the head it names.
if (pkg.package_type === "NAIC_AIRES_V5_MAPPING") report(full, `complete log: ${evs.length} events from sequence 1 with no gaps`);
if (full && pkg.chain_head) {
  const last = evs.at(-1);
  report(pkg.chain_head.sequence === last.sequence && pkg.chain_head.event_hash === last.event_hash, `chain head sequence ${pkg.chain_head.sequence} matches the last event`);
}

// 5. Optional: an earlier head must still be in this log, unchanged, at the same sequence. An honest log only grows.
for (const x of expect) {
  const label = `earlier head ${x.sequence}:${x.event_hash.slice(0, 16)}… (from ${x.from})`;
  if (!full) { report(false, `${label}: not checked. Compare against an institution (NAIC) package, which carries the whole log`); continue; }
  const e = evs.find((v) => v.sequence === x.sequence);
  if (!e) report(false, `${label}: this log has only ${evs.length} events, so it is shorter than the log that head came from`);
  else if (e.event_hash !== x.event_hash) report(false, `${label}: sequence ${x.sequence} here is ${e.event_hash.slice(0, 16)}…, so this is not the same log. If DISCINTEL told you your workspace moved, check its continuity statement; otherwise, contact DISCINTEL`);
  else report(true, `${label} is still in this log, unchanged, ${evs.length - x.sequence} events later`);
}

// 6. Optional: files you still hold match the fingerprints recorded when they were provided.
const objs = (pkg.records && pkg.records.GovernedObject) || [];
for (const f of files) {
  const h = sha256(readFileSync(f));
  const hit = objs.find((o) => o.content_hash === h);
  report(!!hit, `${basename(f)} sha256 ${h.slice(0, 16)}… ` + (hit ? `matches ${hit.record_id} (${hit.filename})` : "matches no file in this package"));
}

if (full && pkg.chain_head) console.log(`\nRecord this head: ${pkg.chain_head.sequence}:${pkg.chain_head.event_hash}\nCheck later packages with:  --expect-head ${pkg.chain_head.sequence}:${pkg.chain_head.event_hash}`);
if (!expect.length) console.log("\nNOTE  These checks prove the package is internally consistent. To show the log wasn't rebuilt wholesale, check it\n      against a head you recorded earlier, with --since <earlier package> or --expect-head <sequence>:<hash>.");
console.log(failed ? `\n${failed} check(s) FAILED. See the FAIL lines above.` : "\nAll checks passed.");
process.exit(failed ? 1 : 0);

Checking the log only grew

On its own, a package can only prove it is internally consistent: nothing in it was edited, reordered or removed after it was sealed. It can't rule out a log rebuilt from scratch. An honest log only grows, so the head you recorded earlier must still be in every later package, unchanged, at the same sequence number. Check that with either option:

node verify-discintel-package.mjs <new NAIC package>.json --since <baseline package>.json
node verify-discintel-package.mjs <new NAIC package>.json --expect-head 284:dc377a80…

The second form takes the full line you recorded (the example hash is shortened here). Both work only with institution (NAIC) packages, because an action package carries only that action's events.

If your workspace moves

If DISCINTEL ever has to move your workspace to new storage, the new log starts again at sequence 1, and the check above will report this is not the same log. Before that happens we'll send you a continuity statement: the old log's final head, the new log's first event, the date and the reason. Keep it with your baseline. A different log with no statement is a question to raise with us.

We tested the verifier on packages from the sample workspace, including ones with edited, removed and re-sealed events, and on packages from a live workspace.

8. Security and data handling

For full detail, read the Privacy Policy draft, and see the questions security teams ask first in section 9.

9. Security questions, answered

The questions security teams ask first, with today's answers. Where the answer is no, it says so.

Send full questionnaires to privacy@getdiscintel.com.

10. Known limitations

Better you read these here than find them yourself.

• The sample institution, its approvers, its sanctions list and its payment rail are fictional or simulated.
• In the sample, execution receipts and observed outcomes are written by the app in your browser, because the rail and the observer are simulated there, so they are only as trustworthy as that session. Decisions, approvals, admissions, tool-gate verdicts and closure are server-issued.
• Test and Production share one workspace, evidence log and sign-in. Test separates trial actions by label only.
• The runtime governor is optional. Where it is enabled, it runs in one of two modes: shadow, which records its verdict without changing the outcome, or enforce, where its stricter verdict applies. Production runs in shadow mode.
• Legal Intelligence drafts are for attorney review. The quote check proves a quote is in the cited source; it does not check the proposition's wording, the memo's analysis or whether a provision is fully covered. Drafts depend on a language model and can take minutes.
• Spanish and French cover the app screens, chat and guided tours; the guides, the terms and the privacy policy are English only, and the translations await native-speaker review.
• Research fetches public text, HTML, JSON and XML only; PDFs and pages that need a sign-in can't be retrieved. Paste the relevant text instead.
• A private-source label on pasted text records what an approved person said the text is; DISCINTEL can't verify where pasted text came from.
• Research access requests and approvals are decided by simulated personas in the sample, like every other approval.
• The NAIC mapping is decision support. It shows what your records evidence; it isn't a filing or a certification.
• Packages mark a file INCOMPLETE where its bytes weren't retained. Its fingerprint still is, so a copy you hold can still be matched.

11. Troubleshooting

12. Getting help

Questions, feedback, evaluation results and pilot discussions: legal@getdiscintel.com. Privacy requests, security questionnaires and security reports: privacy@getdiscintel.com. When you report a result, include the evidence sequence number from TrustDNA Evidence.

DISCINTEL, LLC · Early access. The sample institution and its people, approvers, sanctions list and payment rail are fictional or simulated.