Helix: $1B Thesis (Software-Only) + Roadmap

Canonical one-liner

Helix is the system of record for in silico genome-editing design decisions: deterministic runs, policy-gated claims, and offline-verifiable evidence bundles that explain drift instead of hiding it.

Why this can be a $1B company (the wedge → expansion path)

Most orgs already have a “record of work” (ELN/LIMS + notebooks). What they don’t have is a verifiable record of decisions:

• What policy was applied? (pinned, hashed, reviewable)
• What semantics/scoring version was used? (semantic hash)
• What environment executed it? (backend fingerprint, determinism class)
• Can a third party replay and detect drift offline? (trust check + verifier)

Helix turns that missing layer into an artifact contract + verification toolchain:

• Scientific Contract + Trust Kit: determinism classes, taint/trust labels, pinned policies, and a verifier that fails closed.
  • See: docs/scientific_contract_v1.md, docs/trust_kit.md, docs/switching_proof.md
• Receipts-as-products: signed, canonical validation verdicts + reference validation bundles (release-level trust anchors).
  • See: docs/reference_validation_bundle.md, docs/validation/README.md
• Divergence as a feature: run graphs + minimal causal subgraphs for “why did this change?”.
  • See: docs/run_graph.md
• Studio as a “decision IDE”: the GUI is not the moat; the artifact trail + replay is.
  • See: docs/positioning.md, docs/competitive_landscape.md, docs/rail_control_plane.md

If you win “decision trust” for genome-editing simulation outputs, you can expand horizontally to any deterministic scientific computation that needs offline-verifiable evidence.

The moat

This repo already contains multiple reinforcing loops that are hard to replicate together:

1. Contract + verifier that binds policy + semantics + environment + outputs
2. Governance gating (export only when constraints are satisfied; side-channel output controlled)
3. Signed receipt bundles that let orgs adopt “acceptance gates” as code
4. Divergence tooling that makes drift diagnosable and auditable
5. Formal-ish DAG correctness checks via VeriBiota (Lean pipeline)

Each one is useful alone; together they form a trust moat.

3 highest-leverage gaps to close next

Gap 1 — Make “decision record” the default everywhere

Hardline rule: there must be no artifact without a verifiable contract identity, even internally. Close the loop so every emitted unit of value carries the contract (or emits a cryptographically linked sidecar that fails verification if separated).

Target outcome:

• Any bundle, report, or snapshot can be verified offline and traced to policy/semantics/backend determinism metadata without special cases.

Suggested anchor work:

• Delete “temporary exemptions”: every artifact writer stamps a contract identity (embedded header when possible; linked sidecar when not).
• Make verification fail closed on missing/decoupled identity (no “best effort” inference paths).
• Ensure Studio exports and headless lanes always set current_contract_identity() before writing artifacts (no env fallbacks).

Gap 2 — Productize drift diagnosis (CLI + Studio)

Divergence is a killer differentiator if it becomes the first thing teams do after any change.

Target outcome:

• A reviewer can answer the first question (“what changed / why / does policy consider it material?”) without reading raw logs.
• Outputs fit in: (a) one terminal screen, (b) one Studio pane, and (c) a shareable proof bundle (offline-verifiable).

Suggested anchor work:

• Wire docs/run_graph.md + docs/rail_control_plane.md into a single “why changed?” UX in Studio.
• Standardize “divergence proof bundle” structure, plus a one-screen summary derived from it (logs become optional deep links).
• Make verification a first-class part of the workflow (helix verify on the proof output).

Gap 3 — Teams is the programmable acceptance boundary

Teams/Registry is already positioned as the acceptance gate for deployments. Internally, say it plainly: Teams is not collaboration software — it’s a programmable acceptance boundary.

Target outcome:

• “Helix Teams” is the deployable trust layer that enterprises buy, because it enforces the same public reference bundle gates in their environment.

Suggested anchor work:

• Harden the artifact store/registry contract and make “reference bundle as platform contract tests” non-negotiable.
• Add the smallest useful RBAC UI + proof link UX + retention controls, without becoming an ELN/LIMS.

Roadmap (decisive, milestone-shaped)

0–3 months: make trust unavoidable

• Make helix trust check --backend cpu-reference the default acceptance gate in CI lanes (first-class docs + examples).
• Expand signed validation packs as “contract tests” for all critical subsystems (plugin trust chain, schema registry, verifier, divergence).
• Enforce consistent contract identity stamping across CLI + Studio exports.

3–9 months: ship decision IDE + drift UX

• Studio: ship a first-class “Compare / Explain Drift” flow that produces a verifiable proof bundle.
• Bake the rail control plane into core navigation: selection → recompute → evidence/claims invalidation becomes visible and auditable.

9–18 months: Teams/Registry becomes the revenue engine

• Release “Teams v1” with deployable acceptance gates and proof links.
• Add minimal enterprise hooks (SSO boundary optional, auditing, retention knobs) while preserving offline-first verification.

18+ months: horizontal expansion

• Generalize the contract/verifier to additional deterministic computation domains (still software-only) using the same policy + evidence + receipt pattern.

Validation strategy (how to prove this is real)

Treat these as non-negotiable contract tests for every major change:

• Determinism: helix trust check --backend cpu-reference
• Receipt authenticity: helix verify bundle <reference_validation_bundle> --json-out verify_bundle.json
• Drift explainability: helix trust divergence --a <bundleA> --b <bundleB> --bundle out/divergence_proof then helix verify out/divergence_proof/manifest.json
• Formal DAG checks (badge honesty): VeriBiota pipeline described in docs/veribiota.md

Define success metrics (track in CI artifacts):

• Median “time to explain drift” (two bundles → causal frontier) under 2 minutes on a cold machine.
• % of bundles that are “pinned policy compliant” with complete backend fingerprint for the declared determinism class.
• Zero “silent drift” regressions: any change that affects declared distribution checks must fail a gate or produce an explicit, reviewable diff bundle.