Who this is for: Operations leaders, quality directors, compliance officers, C3PAO assessors, Notified Body auditors, life sciences QA managers, automotive homologation engineers, DevSecOps leads, and anyone who has been asked "prove the process was followed" and wished the answer were simpler.

1. The Problem Every Regulated Process Shares

Every car, every drug, every software release goes through sequential phases before it reaches the public. Design before prototype. Testing before production. Review before deployment. Each phase depends on the one before it.

The proof that Phase 1 was complete before Phase 2 began is, almost everywhere, a signature on a form. A timestamp in a spreadsheet. A PDF attached to an email. There is no tamper-evident record. No way for a regulator, an insurer, or a court to independently verify that the sequence was honored without months of forensic archaeology through filing cabinets and disconnected systems.

The gap is not the inspection. Inspectors are thorough. The gap is what happens to the evidence afterward. It sits in systems where it can be lost, altered, or presented out of sequence. When something goes wrong -- and in high-stakes processes, something eventually goes wrong -- the investigation is not about what happened. It is about what can be proven to have happened, and when.

This guide shows how the SWT3 witness protocol records phased process evidence in three very different domains. The protocol does not judge the evidence. It does not enforce the process. It records what happened, when it happened, and in what order. The record is cryptographic, tamper-evident, and independently verifiable.

The same protocol. The same proof structure. Whether the process takes ten minutes or twenty years.

2. The Architecture (Brief)

SWT3 phase gating uses a three-tier hierarchical Merkle tree. If you are already familiar with this structure from the Phased Process Witnessing guide, skip ahead to the scenarios. If not, here is the essential picture:

    Individual Evidence Results
    +---------+ +---------+ +---------+
    | result_1| | result_2| | result_3|     Inspection, test, review, approval
    +----+----+ +----+----+ +----+----+
         |           |           |
         +-----+-----+     +----+
               v            v
        +-----------+ +-----------+
        |Milestone A| |Milestone B|     Groups of related evidence
        |   Root    | |   Root    |
        +-----+-----+ +-----+-----+
              |              |
              +------+-------+
                     v
             +--------------+
             |  Phase Root  |              A stage of the process
             +--------------+
                     |
         +-----------+-----------+
         v           v           v
      Phase 1     Phase 2     Phase 3
         |           |           |
         +-----------+-----------+
                     v
             +--------------+
             | Structure    |              The entire project, trial,
             |    Root      |              vehicle, or pipeline
             +--------------+

Three-tier tree: evidence rolls up to milestones, milestones to phases, phases to a single structure root. Change one leaf and the root changes.

Each tier uses its own cryptographic prefix. A milestone hash can never collide with a phase hash. This is domain separation -- the same principle that prevents cross-protocol attacks in TLS.

The structure root is a single hash that represents the complete state of an entire process. Change one piece of evidence at the bottom and the structure root changes. The math is the audit trail.

The engine does not know what domain it is witnessing. It knows that evidence accumulates in milestones, milestones belong to phases, and phases belong to a structure. Everything else -- the names, the procedures, the regulations -- is configuration. That domain-agnosticism is the point of this guide.

For the full technical deep dive, including domain separation prefixes, gate attestation mechanics, scope amendments, and sensor integration, see the Phased Process Witnessing guide.

3. Software Release Pipeline

Timescale: Minutes to hours. Regulatory context: SOC 2, CMMC, FedRAMP, PCI DSS 4.0, SLSA.

Engineering teams already build and operate sophisticated CI/CD pipelines with gates between phases. The tooling is mature -- GitHub Actions, GitLab CI, Jenkins, ArgoCD, and dozens of others manage the pipeline execution. What these tools do not produce is a tamper-evident, independently verifiable record that each gate was evaluated and what evidence existed at each evaluation. The pipeline logs exist, but they are mutable, tool-specific, and often overwritten by subsequent runs.

The phases

  Code Review       Security Scan      Test & Stage       Production
  +-----------+     +-----------+     +-----------+     +-----------+
  | PR signed |     | SAST pass |     | Tests pass|     | Canary OK |
  | 2 LGTMs   |     | SCA pass  |     | Stage OK  |     | Rollout   |
  +-----------+     +-----------+     +-----------+     +-----------+
       |     GATE_OPEN    |    GATE_OPEN    |    GATE_OPEN    |
       +-------->---------+------>----------+------>----------+

Four phases, three gates. Each gate records whether the required evidence was present before the next phase began.

Milestones and evidence

PhaseMilestoneRequired EvidenceWhat Is Recorded
Code ReviewPR ApprovalSigned commit, 2 reviewer approvalsCommit signature hash, review record hash
Security ScanSAST ClearStatic analysis pass, no critical findingsScan report hash
Security ScanDependency AuditSCA pass, SBOM generatedSBOM hash, SLSA provenance attestation hash
Test & StageTests PassUnit, integration, and e2e suites greenTest report hash
Test & StageStage VerifiedStaging smoke test passHealth check result hash
ProductionCanary PassCanary metrics within thresholdMetrics snapshot hash
ProductionRollout Complete100% traffic, error rate nominalDeployment manifest hash

When something goes wrong

Three months after deployment, a critical vulnerability is discovered in production. The CISO asks: "How did this get past our pipeline?"

Without a witness record, the answer requires pulling CI logs, correlating timestamps across multiple tools, interviewing the on-call engineer, and hoping the scan reports were not overwritten by subsequent runs. The investigation takes days. Sometimes the evidence no longer exists.

With milestone Merkle, the answer is a proof path through the tree:

  1. Start at the structure root for release v2.4.1.
  2. Walk to the Production phase root, then to the Canary Pass milestone. Which evidence fingerprints are in this milestone? Was the vulnerability present in the dependency list at that point?
  3. Walk to the Security Scan phase root, then to the Dependency Audit milestone. Was the vulnerable library in the SBOM that was recorded?
  4. If the vulnerable dependency was added after the SAST scan but before the production deploy, the tree shows exactly where the gap occurred -- which gate recorded a PASS despite the dependency being unscanned.

The tree does not prevent the vulnerability. It records whether each gate was evaluated and what evidence existed at each gate. The record is there for the CISO, the auditor, and the incident response team.

A real-world example, July 2024. A major endpoint security vendor deployed a content configuration update to millions of machines through a path that bypassed their standard validation pipeline. The update caused widespread outages. The postmortem revealed the content update followed a different path than code changes -- it was not subject to the same gates. Had the pipeline been witnessed with milestone Merkle, the record would show one of two things: a GATE_OPEN leaf proving validation occurred, or the absence of any gate leaf -- proving it did not. SWT3 does not prevent the deployment. It records whether the gate was checked. The absence of a record is itself evidence.

What SWT3 does and does not do here. SWT3 witnesses the pipeline's phase gate decisions. It does not replace your CI/CD platform (GitHub Actions, GitLab CI, Jenkins), your SAST scanner (Semgrep, SonarQube), or your SBOM generator. Those tools produce the evidence. SWT3 records that the evidence existed at a specific point in the pipeline and was not altered afterward. It is equally useful to the security team proving the pipeline was followed and to the incident investigator proving it was not.

Recording it

# Python
from swt3_ai.milestone_merkle import MilestoneAccumulator

acc = MilestoneAccumulator(structure_id="ST-release-v2.4.1")

# Define phases in sequence
acc.add_phase("PH-review", "Code Review", sequence=0)
acc.add_phase("PH-security", "Security Scan", sequence=1)
acc.add_phase("PH-test", "Test & Stage", sequence=2)
acc.add_phase("PH-prod", "Production", sequence=3)

# Define milestones within phases
acc.add_milestone("MS-pr-approve", "PH-review", "PR Approval",
    required_procedures=["PR-SIGN", "PR-2LGTM"])
acc.add_milestone("MS-sast", "PH-security", "SAST Clear",
    required_procedures=["SAST-PASS"])
acc.add_milestone("MS-dep-audit", "PH-security", "Dependency Audit",
    required_procedures=["SCA-PASS", "SBOM-GEN"])

# As CI runs, record evidence
acc.add_leaf("MS-pr-approve", commit_sig_fingerprint,
    "PR-SIGN", verdict="PASS")
acc.add_leaf("MS-pr-approve", review_fingerprint,
    "PR-2LGTM", verdict="PASS")

# Check gate before advancing
gate = acc.check_gate("PH-review")
print(gate["passed"])  # True -- all evidence recorded
print(acc.structure_root)  # One hash -- the state of the entire release
// TypeScript
import { MilestoneAccumulator } from "@tenova/swt3-ai";

const acc = new MilestoneAccumulator("ST-release-v2.4.1");

acc.addPhase("PH-review", "Code Review", 0);
acc.addPhase("PH-security", "Security Scan", 1);
acc.addPhase("PH-test", "Test & Stage", 2);
acc.addPhase("PH-prod", "Production", 3);

acc.addMilestone("MS-pr-approve", "PH-review", "PR Approval",
    ["PR-SIGN", "PR-2LGTM"]);

// Record evidence as pipeline runs
acc.addLeaf("MS-pr-approve", commitSigFingerprint,
    "PR-SIGN", "PASS");

const gate = acc.checkGate("PH-review");
console.log(gate.passed); // true

Regulatory mapping

FrameworkControlWhat the Record Shows
SOC 2CC8.1Change management controls were evaluated in sequence
CMMCCM.L2-3.4.3Configuration change control with verifiable evidence chain
FedRAMPCM-3Configuration change control, audit trail of gate decisions
PCI DSS 4.06.5.1-6.5.6Secure change control process was recorded at each stage
ISO 27001A.8.32Change management in development lifecycle was witnessed
SLSALevel 3Build provenance and attestation chain recorded

4. Pharmaceutical Clinical Trial

Timescale: 5 to 15 years. Regulatory context: 21 CFR Part 11, ICH E6(R3) GCP, ALCOA+, EU GMP Annex 11.

Clinical trials are among the most heavily gated processes in any industry. A new drug moves through pre-clinical studies, phases of human trials, regulatory submission, and post-market surveillance. Each phase produces evidence that the next phase's gate requires. The people who run these trials -- investigators, sponsors, CROs, regulators -- have deep domain expertise in managing this evidence. What they often lack is a tamper-evident, independently verifiable record that the evidence existed in a specific state at each phase transition.

The stakes are not abstract. Real patients receive experimental treatments based on the evidence accumulated in prior phases. When that evidence chain is later disputed, the consequences are measured in lives and in years of litigation over temporal ordering questions that the existing systems were not designed to answer.

The phases

  Pre-Clinical    Phase I       Phase II      Phase III     NDA/BLA       Post-Market
  +-----------+ +-----------+ +-----------+ +-----------+ +-----------+ +-----------+
  | Tox study | | Safety    | | Efficacy  | | Large-    | | eCTD      | | FAERS     |
  | IND filed | | DSMB      | | Signal    | | scale     | | Modules   | | Signals   |
  +-----------+ +-----------+ +-----------+ +-----------+ +-----------+ +-----------+
       |   GATE_OPEN  |   GATE_OPEN  |   GATE_OPEN  |   GATE_OPEN  |  GATE_OPEN  |
       +------>-------+------>-------+------>-------+------>-------+----->-------+

Six phases, five gates. A decade of evidence, each phase locked before the next begins.

Milestones and evidence

PhaseMilestoneRequired EvidenceWhat Is Recorded
Pre-ClinicalToxicology CompleteToxicology study report finalizedStudy report hash
Pre-ClinicalIND FiledInvestigational New Drug submission acceptedFDA filing receipt hash
Phase IDSMB Safety ReviewData Safety Monitoring Board review completeMeeting minutes hash
Phase IDose EscalationDose-limiting toxicity assessedDLT assessment hash
Phase IIEfficacy SignalPrimary endpoint achievedStatistical analysis hash
Phase IIIRB RenewalIRB/Ethics Committee continuing reviewApproval letter hash
Phase IIIInterim AnalysisPre-specified stopping boundary evaluatedDSMB recommendation hash
Phase IIIDatabase LockAll queries resolved, database lockedLock certificate hash
NDA/BLASubmission CompleteAll eCTD modules filedSubmission receipt hash
Post-MarketSafety SignalFAERS/VAERS signal detectedSignal report hash

When something goes wrong

A drug causes liver damage two years after approval. 3,400 patients affected. Class action filed. Plaintiff's counsel asks one question: "When did you know?"

The sponsor says the safety signal was not apparent until post-market data accumulated. The plaintiff says the Phase II data already showed elevated liver enzymes, and Phase III should never have enrolled.

This is not a science question. It is a temporal ordering question. Did the Phase II efficacy data exist before Phase III enrollment began? Was the DSMB safety review conducted before dose escalation in Phase I? Was the database locked before the NDA statistical analysis was generated?

Today, answering these questions takes 6 to 18 months of forensic review across eTMF systems, email archives, and regulatory submissions. Expert witnesses are retained. Depositions are taken. The cost of the temporal ordering dispute alone can exceed $10 million before the underlying science is even addressed.

With milestone Merkle, the record is already there. The GATE_OPEN leaf for Phase III has a timestamp. The Phase II milestone root was locked before that timestamp. The DSMB review fingerprint is inside the Phase I milestone. SWT3 does not judge whether the DSMB made the right call. It records that the call was made, when it was made, and what data existed at that moment. The ordering is mathematical, not testimonial.

Vioxx (rofecoxib), 1999-2004. Merck's VIGOR study (2000) showed a fivefold increase in myocardial infarction versus naproxen. The APPROVe trial later confirmed a 3.7x increase in cardiovascular events versus placebo. The central dispute -- litigated for years at a cost exceeding $4.85 billion in settlements across 27,000 lawsuits -- was when the cardiovascular risk signal became statistically significant and whether it was adequately disclosed in the NDA. With milestone Merkle, the DSMB interim analysis hash would show exactly what data existed at each decision point. SWT3 does not decide whether Merck acted appropriately. It provides the verifiable record that both sides -- plaintiff and defense -- can examine.

What SWT3 does and does not do here. SWT3 witnesses the temporal ordering of clinical trial phase transitions. It does not replace eTMF systems (Veeva Vault), EDC platforms (Medidata Rave), CTMS, IWRS, or any clinical data management system. Those systems produce the evidence. SWT3 records that the evidence existed at a specific point in time and was not altered afterward. The clinical judgment -- whether to escalate doses, whether to enroll Phase III, whether to submit the NDA -- remains with the investigators, the DSMB, and the regulators. SWT3 is the court reporter, not the judge.

Recording it

# Python -- multi-site clinical trial
from swt3_ai.milestone_merkle import MilestoneAccumulator

acc = MilestoneAccumulator(structure_id="ST-trial-XYZ-789")

acc.add_phase("PH-preclinical", "Pre-Clinical", sequence=0,
    required_framework="21-CFR-11")
acc.add_phase("PH-phase1", "Phase I", sequence=1,
    min_clearing_level=2)   # Sensitive -- patient data
acc.add_phase("PH-phase2", "Phase II", sequence=2,
    min_clearing_level=2)
acc.add_phase("PH-phase3", "Phase III", sequence=3,
    min_clearing_level=2)
acc.add_phase("PH-nda", "NDA Submission", sequence=4)
acc.add_phase("PH-postmarket", "Post-Market", sequence=5)

acc.add_milestone("MS-dsmb-1", "PH-phase1", "DSMB Safety Review",
    required_procedures=["DSMB-SAFETY"])

# DSMB reviews aggregated data from all sites in one meeting.
# The site data submissions and the DSMB recommendation are
# separate leaves -- the protocol records both.
acc.add_leaf("MS-dsmb-1", site_data_submission_fingerprint,
    "SITE-DATA-SUBMITTED", verdict="PASS", clearing_level=2)
acc.add_leaf("MS-dsmb-1", dsmb_recommendation_fingerprint,
    "DSMB-SAFETY", verdict="PASS", clearing_level=2)

# Gate check: can Phase II begin?
gate = acc.check_gate("PH-phase1")
# gate["passed"] reflects whether all Phase I evidence is recorded

Regulatory mapping

FrameworkRequirementWhat the Record Shows
21 CFR Part 1111.10(e)Audit trail with temporal ordering of electronic records
ICH E6(R3) GCP5.5Trial Master File completeness at each phase transition
ALCOA+All principlesEach leaf: Attributable, timestamped (Contemporaneous), immutable (Original, Accurate)
EU GMP Annex 117.1Data integrity for computerized systems across sites
FDA Data Integrity2018 GuidanceElectronic records temporal ordering across lifecycle

5. Vehicle Type Approval

Timescale: Decades (design through end-of-life). Regulatory context: UNECE R155/R156, ISO 26262, ISO/SAE 21434, EU 2018/858, IATF 16949.

Automotive manufacturers and their supply chains already operate within rigorous phase-gated frameworks -- APQP, PPAP, ISO 26262, and the UNECE type approval process. The domain expertise for managing these phases is deep and mature. What changes with software-defined vehicles is the evidence chain's duration: OTA updates change the software after type approval, and recalls require tracing a specific VIN back to the component lots, software versions, and test results that validated it years earlier.

The evidence chain spans multiple countries, hundreds of suppliers, and software that evolves after the vehicle leaves the factory. The lifecycle is measured in decades, and the evidence must survive the entire span. The existing systems (PLM, QMS, PPAP tools) manage the evidence within each phase. The gap is the same gap as every other domain: a tamper-evident record that Phase 1 evidence existed before Phase 2 began, verifiable by any party, decades later.

The phases

  Design &    Supplier       Prototype &    Type         Production     Field
  FMEA        Qualification  Validation     Approval                    Operations
  +--------+  +--------+     +--------+     +--------+   +--------+    +--------+
  | ASIL   |  | PPAP   |     | Crash  |     | WVTA   |   | COP    |    | OTA    |
  | TARA   |  | IMDS   |     | R155   |     | granted|   | VIN QC |    | Recall |
  +--------+  +--------+     +--------+     +--------+   +--------+    +--------+
       | GATE    | GATE          | GATE         | GATE        | GATE        |
       +--->-----+---->----------+---->---------+---->--------+---->--------+

Six phases across years. The tree grows with each OTA update and recall action, even decades after initial type approval.

Milestones and evidence

PhaseMilestoneRequired EvidenceWhat Is Recorded
DesignASIL ClassificationISO 26262 hazard analysis and risk assessmentHARA report hash
DesignCybersecurity PlanISO/SAE 21434 threat analysis (TARA)Threat model hash
SupplierPPAP Tier 1Supplier PPAP Level 3+ approvedPPAP package hash
SupplierIMDS CompleteMaterial declarations filedIMDS submission hash
PrototypeCrash Test BatchECE R94/R95 frontal and side impact passTest report hash
PrototypeR155 CybersecurityUNECE R155 CSMS audit completeCSMS certificate hash
PrototypeR156 SUMSUNECE R156 software update management approvedSUMS approval hash
Type ApprovalWVTA GrantedTechnical service report accepted by authorityType approval certificate hash
ProductionCOP AuditConformity of production verifiedCOP report hash
ProductionVIN Quality GateEnd-of-line quality check per VINQC result hash, software version hash
FieldOTA GateSoftware update validated before pushUpdate validation hash
FieldRecall EvidenceAffected VIN range identified, root cause documentedRecall package hash

When something goes wrong

A steering algorithm fails at 130 km/h on the autobahn. Two passengers are injured. The manufacturer faces three regulators -- KBA in Germany, NHTSA in the United States, MIIT in China -- and a product liability claim under the EU Product Liability Directive.

Every regulator asks the same four questions:

  1. Which software version was running on that VIN?
  2. Which crash test validated that software version?
  3. Which supplier certified the steering sensor?
  4. Did the OTA update that changed the steering logic go through the required software update management approval?

Today, answering these questions requires cross-referencing PLM records, supplier PPAP packages, type approval certificates, and OTA deployment logs across multiple systems and jurisdictions. The investigation takes months. Regulators in different countries may receive inconsistent answers because they are querying different systems with different retention policies.

With milestone Merkle, each answer is a proof path through the same tree:

VIN Quality Gate milestone contains the software version fingerprint. The same fingerprint should appear in the Prototype phase, inside the Crash Test Batch milestone. If the fingerprints match, the record shows that the deployed software was crash-tested. If they do not match, the record shows that an OTA update introduced software that was never validated against the original crash test. The tree records the match or the divergence. It does not decide whether the divergence was intentional.

Volkswagen Dieselgate, 2015. VW installed software that detected test conditions and changed emissions behavior accordingly. The emissions calibration in the type approval test was different from the calibration in production driving. Had the pipeline been witnessed with milestone Merkle, the software hash in the Type Approval milestone and the software hash in the Production VIN Quality Gate milestone would be independently verifiable. If they match, the record shows consistency. If they differ, the record shows divergence. SWT3 does not decide whether the divergence is fraudulent -- it provides the verifiable record.

Bookout v. Toyota, 2013. Expert analysis of Toyota's source code revealed 11,000 global variables and no defensive coding practices in the throttle control software. The jury could not determine which software version was running on the plaintiff's Camry when the unintended acceleration occurred. With milestone Merkle, the VIN-level software fingerprint would trace directly to the validated build -- a factual record, available to both plaintiff and defense.

Takata airbag recall, 2013-present. The largest recall in automotive history -- over 67 million inflators in the US alone. Takata could not identify with certainty which vehicles received specific inflator lots. The traceability gap between supplier lot numbers and VINs turned a component defect into a decade-long investigation. The PPAP Tier 1 milestone in a witnessed tree would link each supplier lot hash to the VINs that received it -- making the affected population identifiable from the record, not from forensic reconstruction.

What SWT3 does and does not do here. SWT3 witnesses phase gate decisions and evidence integrity across the vehicle lifecycle. It does not replace PLM systems (Teamcenter, Windchill), IATF 16949 quality management systems, PPAP documentation tools, or type approval submission platforms. Those systems produce the evidence. SWT3 records the temporal ordering and integrity of that evidence. It is equally useful to the manufacturer proving compliance and to the regulator investigating a failure. The tree serves both sides because it serves neither -- it is a neutral record.

Recording it

// TypeScript -- vehicle lifecycle with OTA gating
import { MilestoneAccumulator } from "@tenova/swt3-ai";

const acc = new MilestoneAccumulator("ST-model-x-2027");

acc.addPhase("PH-design", "Design & FMEA", 0);
acc.addPhase("PH-supplier", "Supplier Qualification", 1);
acc.addPhase("PH-prototype", "Prototype & Validation", 2);
acc.addPhase("PH-approval", "Type Approval", 3);
acc.addPhase("PH-production", "Production", 4);
acc.addPhase("PH-field", "Field Operations", 5);

// OTA updates must pass gate before push to fleet
acc.addMilestone("MS-ota-gate", "PH-field", "OTA Validation",
    ["R156-SUMS", "REGRESSION-TEST", "CANARY-FLEET"]);

// Record OTA validation evidence
acc.addLeaf("MS-ota-gate", sumsApprovalFingerprint,
    "R156-SUMS", "PASS");
acc.addLeaf("MS-ota-gate", regressionFingerprint,
    "REGRESSION-TEST", "PASS");
acc.addLeaf("MS-ota-gate", canaryFingerprint,
    "CANARY-FLEET", "PASS");

// Check gate before pushing OTA to fleet
const gate = acc.checkGate("PH-field");
if (!gate.passed) {
    // Gate not satisfied -- record shows what is missing
    console.log("Missing:", gate.missingProcedures);
    console.log("Unresolved:", gate.unresolvedFails);
}

Regulatory mapping

FrameworkRequirementWhat the Record Shows
UNECE R1557.2Cybersecurity management lifecycle evidence recorded
UNECE R1567.1 (RXSWIN)Software update management process witnessed, RXSWIN traceability
ISO 26262Part 2-12Functional safety lifecycle phase completion recorded
ISO/SAE 21434Clauses 5-15Cybersecurity engineering phase gate evidence
EU 2018/858Art. 6-12Type approval evidence chain and COP recorded
IATF 169498.3 / APQPProduct development quality gates witnessed across all five APQP phases
NHTSA FMVSS49 CFR 571Self-certification evidence chain (US market)

6. The Unifying Insight

Look at what just happened.

Three completely different industries. Three different regulatory regimes. Three different timescales -- the software pipeline runs in minutes, the clinical trial runs for a decade, the vehicle lives for twenty years. And in every case:

The protocol does not know it is witnessing a CI/CD pipeline. It does not know it is witnessing a clinical trial. It does not know it is witnessing a car. It knows that evidence accumulates in phases, each phase has a gate, and the gate's decision is cryptographically committed before the next phase begins. Everything else is a label.

DimensionCI/CD PipelineClinical TrialVehicle
TimescaleMinutes to hours5 to 15 yearsDecades
Phases466
Milestones71012
Regulatory regimeSOC 2, SLSA, PCI DSS21 CFR Part 11, ICH E6UNECE R155/R156, ISO 26262
Failure scenarioProduction vulnerabilityPost-market drug harmHighway crash, recall
The question"How did this get past our pipeline?""When did you know?""Which software was on that VIN?"
Time to answer todayDays to weeks6 to 18 monthsMonths
Time to answer with SWT3One API callOne API callOne API call

That last row is the insight.

Not that the data structure is elegant -- it is. Not that the cryptography is sound -- it is. The insight is that the question every regulator, every litigator, every insurer, and every auditor asks -- "show me the record" -- has had no universal format until now. Every industry built its own evidence silos, its own filing systems, its own forensic archaeology tools. And when the question comes, the answer always depends on how well those disconnected systems were maintained.

SWT3 provides one format. The same one. For every domain. And it does so without judging the evidence, without enforcing the process, and without replacing the systems that produce the evidence. It is a witness. It records what happened, when it happened, and in what order. That record is available to everyone: the manufacturer, the regulator, the plaintiff, the insurer. The same tree, the same proof, the same math.

Neutral by design. Universal by architecture.

7. Quick Start

Install the SDK in your language of choice:

# Python
pip install swt3-ai

# TypeScript / Node.js
npm install @tenova/swt3-ai

The minimal pattern is always the same, regardless of domain:

from swt3_ai.milestone_merkle import MilestoneAccumulator

# 1. Define the structure
acc = MilestoneAccumulator(structure_id="ST-your-process")

# 2. Add phases in sequence
acc.add_phase("PH-first", "First Phase", sequence=0)
acc.add_phase("PH-second", "Second Phase", sequence=1)

# 3. Add milestones with required procedures
acc.add_milestone("MS-review", "PH-first", "Review",
    required_procedures=["REVIEW-COMPLETE"])

# 4. Record evidence as it occurs
acc.add_leaf("MS-review", evidence_fingerprint,
    "REVIEW-COMPLETE", verdict="PASS")

# 5. Check the gate before advancing
gate = acc.check_gate("PH-first")
print(gate["passed"])       # True or False
print(acc.structure_root)   # Single hash -- the state of everything

The phase names, milestone names, and procedure IDs are yours. The protocol does not prescribe them. It witnesses whatever process you define.

API endpoint: POST /api/v1/merkle/milestone for server-side recording. GET /api/v1/merkle/proof?fingerprint=xxx for proof retrieval.

More detail:

8. References

CI/CD and Software Supply Chain

Pharmaceutical and Life Sciences

Automotive and Vehicle

Related Guides