Helix $1B Thesis — Repo Audit (software-only)

Generated: 2026-01-25T22:50:42Z
Repo git SHA: 43e9a847365ac6fe9b1743377b1b73065a2aec80
Repo describe: v1.1.6rc3-dirty
Helix version: 1.1.5
Python: 3.12.3

This audit answers one question: how much of the $1B thesis is already true in the codebase (contracts, verifiers, receipts, drift, acceptance boundary), vs still narrative / roadmap.

It does not assess market size, pricing, sales motion, or enterprise procurement dynamics.

Executive summary (where you are “real” today)

• The wedge (“decision trust for in silico genome editing simulation outputs”) is technically credible right now: you have an offline verifier that fails closed, reason codes, hostile fixtures, signed validation verdicts, deterministic session contract hashing, and a divergence proof bundle format with verification.
• The repo already contains the hard-to-fake primitives that support “system of record” positioning: contract identity, offline verification, signed receipts, drift artifacts, policy gates, and an early Teams/Registry spine.
• What’s missing for the thesis to feel inevitable is less “write more code” and more “make the trust workflow unavoidable and product-shaped”: wire divergence proof bundles (including policy-material drift verdicts) into Studio UX, and harden Teams into a deployable acceptance boundary (pinned policy sets + reference bundle gates) that enterprises can operate.

Evidence: thesis primitives already implemented

Contract identity + deterministic artifacts

• Scientific contract header builder (policy/semantic hash, determinism class, backend fingerprint completeness): src/helix/scientific_contract.py
• Session-level contract stamping (policy/semantic/determinism + CLI session contract id/hash; env fallback is explicit): src/helix/studio/session_io.py
• Export + evidence writers stamp the full contract header by default (including explicit downgrades and env fallback provenance keys): src/helix/studio/export_run.py, src/helix/studio/export_evidence.py, src/helix/artifacts/build.py
• Cross-platform deterministic contract hashing (v3) pinned as a constant: src/helix/studio/cli_session_contract_stamp.py, tests/e2e/test_cli_session_contract_v3.py

Fail-closed offline verification with reason codes

• General verifier entrypoint routes to helixspec / export / bundle verifiers: src/helix/cli.py
• HelixSpec bundle verification is strict, bounded, and reason-coded: src/helixspec/cli.py
• Golden “must fail” fixtures + reason-code contract tests: tests/test_golden_failing_bundle_v1.py, tests/test_verify_reason_code_contract_v1.py, tests/test_hostile_bypass_pack_v1.py

Receipts as products (signed, offline verifiable)

• Signed validation verdicts and “reference validation bundles” as release artifacts: docs/reference_validation_bundle.md, docs/validation/README.md
• Artifact bundle signing with offline license + attestation verification: src/helix/artifacts/build.py, src/helix/artifacts/verify.py
• Governance ledger with schema-hash pinning + approvals: src/helix/governance/ledger.py

Drift explainability artifacts (graph + divergence proof bundle)

• Run graph spec and divergence report/bundle v1: docs/run_graph.md, src/helixspec/run_graph.py, src/helixspec/divergence.py
• CLI tooling to emit and bundle divergence reports (with best-effort header stitching): src/helix/cli.py
• Divergence proof bundles now include drift_verdict.json (policy-material verdict) and verification enforces anchoring to embedded run bundle digests: src/helixspec/divergence.py

“Acceptance boundary” spine (Teams/Registry v0)

• Content-addressed blob store + token RBAC + run registry + program/version graph + publish gate that verifies signed bundles: src/helix/teams/server.py, src/helix/teams/db.py
• Registry publish path verifies artifact bundle + requires governance Approved: src/helix/teams/server.py
• Tests exist for Teams/Registry behaviors (not just docs): tests/test_teams_v0_smoke.py, tests/test_registry_v1_smoke.py

Formal-ish correctness checks (VeriBiota)

• Lean/Lake pipeline + CI wiring for “Verified by VeriBiota”: docs/veribiota.md, .github/workflows/veribiota.yml

Reality scorecard (thesis → code)

Scale: 0 (absent) to 5 (shipped + test/CI gated + release posture).

The 3 thesis-critical gaps (highest leverage)

1. Productize drift in Studio (consume proof bundles)

   • Today: Studio can compare runs, but not in the “offline verifiable drift proof bundle” format.
   • Needed: a single “Compare / Explain Drift” pane that:
     • loads two bundles (or receipts),
     • renders the same one-screen summary as CLI,
     • shows the causal frontier graph,
     • exports a divergence proof bundle and offers a copy/paste helix verify command.

2. Teams as programmable acceptance boundary

   • Today: Teams verifies bundles and enforces governance state, but it does not yet enforce “pinned policy sets + reference bundle gates” as a first-class acceptance surface.
   • Needed: config-first policy set allowlists + required reference validation bundle gates, enforced at publish time with explicit reason codes.

3. Unify “receipt + reviewer summary” across surfaces

   • Today: CLI can produce and verify bundles, but the “one-screen reviewer summary” is not yet standardized across CLI, Studio, and Teams.
   • Needed: one canonical summary schema + renderer shared across surfaces, with deterministic reason codes and deep links into proof bundles.

Doc ↔ code mismatches (trust risk to fix early)

• docs/scientific_contract_v1.md describes an escape hatch HELIX_ALLOW_UNPINNED_POLICY=1 and a “pinned policy location” requirement for D2 runs. This is now enforced in code and recorded as an explicit (auditable) downgrade marker when the escape hatch is used: src/helix/scientific_contract.py

Concrete next steps (aligned to the thesis roadmap)

0–3 months: make trust unavoidable (repo-level)

• Extend identity stamping to all shareable artifacts (reports, screenshots/exports, lane renders) via embedded headers or cryptographically linked sidecars.
• Keep fail-closed verification harsh: missing identity is a hard error with stable reason codes (no inference paths).
• Add hostile fixtures that prove “identity stripped” artifacts fail verification in the same way across CLI, Studio, and Teams ingestion.

3–9 months: drift UX (reviewer-first)

• Standardize the one-screen reviewer summary and reuse it across CLI, Studio, and Teams (same sections + ordering + reason codes).
• Build Studio “Compare and Explain Drift” MVP that consumes and exports the divergence proof bundle (GUI as a lens, not a parallel logic stack).

9–18 months: Teams becomes revenue engine

• Turn Teams into an explicit “acceptance boundary” product:
  • enforce verification on ingest,
  • enforce pinned policy sets,
  • enforce published reference validation bundle checks,
  • make promotion/audit immutable and exportable.

Validation strategy (non-negotiable, software-only)

These are the contract tests that should gate the work above:

• Determinism smoke: helix trust check --backend cpu-reference
• Fail-closed verification: helix verify fixtures/golden_failing_bundle_v1/run_blocked must FAIL with stable reason codes
• Divergence proof: helix trust divergence --a <bundleA> --b <bundleB> --bundle <out> then helix verify <out>/manifest.json
• Cross-platform session contract: .github/workflows/cli-session-contract.yml
• Teams/Registry acceptance: .github/workflows/helix-verify-gate.yml + tests/test_registry_v1_smoke.py