docs/commercialization-strategy.md

# UncheckedIO — Commercialization Strategy
**Session date:** 2026-04-20
**Status:** Active planning

---

## Product Summary

Two components with different commercial treatment:

| Component | Language | License | Status |
|---|---|---|---|
| PostgreSQL → Arrow pipeline | Rust | Apache 2.0 (open source) | On PyPI, working |
| GPU zero-copy ingestion pipeline | Rust + CUDA | Commercial | Proof-of-concept, needs Phase 1 fixes |

The GPU pipeline is the commercial product. The Postgres piece is the credibility signal and open-source loss leader.

---

## The Problem Being Solved

GPU starvation — LLM providers run 30-50% actual GPU utilization on inference. The bottleneck is the data ingestion pipeline: CPU tokenizes, creates a Python tensor in pageable memory, `.to("cuda")` performs two OS-mediated copies (pageable → kernel buffer → GPU).

UncheckedIO replaces this with: Rust parallel tokenization → pinned memory (DMA-accessible) → single direct DMA → DLPack zero-copy handover to PyTorch.

**Current benchmark:** 4.7x faster than standard HuggingFace pipeline on RTX 3060.
**Pending:** H100 SXM benchmark (Wednesday, ~$2 on Lambda Labs). This number changes the pitch.

---

## Business Structure

**Entity:** New Mexico single-member LLC
- NM does not require member names in Articles of Organization
- No annual report requirement — less administrative overhead than most states
- LLC owns all IP and signs all contracts
- Registered agent handles public address
- Form this before any contract is signed
- Note: if the IP is eventually sold, the buyer's anonymity is their own concern — the LLC structure only needs to protect the original author

**Operating model:** Anonymous principal — LLC is the public face. The identity of the technical author is not disclosed to buyers or the public. Any investor or partner arrangement must include explicit confidentiality provisions.

---

## Go-to-Market Strategy

### Phase 1: Licensing (current goal)
License the GPU pipeline commercially. Annual per-cluster licenses. Open-source Postgres piece stays Apache 2.0 as a credibility and discovery channel.

**Why licensing before IP sale:**
A library generating $50K+/month in licenses is a business acquisition, not a proof-of-concept. The IP sale price increases significantly and the negotiating position improves. Licensing revenue demonstrates market validation.

### Phase 2: IP Sale (after traction)
Once licensing revenue establishes market proof, approach GPU cloud providers and LLM infrastructure companies for outright IP purchase. Source code + short-term handoff contract. Clean exit.

---

## Pricing

The ROI math for a GPU provider: 100 H100s at $175K/year each = $17.5M in GPU costs. A 10% utilization improvement = $1.75M saved. A $50K license is a 35x ROI.

**Do not anchor at $50K. That is the floor for small deployments.**

| Deployment size | Annual license | One-time source sale |
|---|---|---|
| Small (50–200 GPUs) | $25K–$75K | $100K–$200K |
| Medium (200–1,000 GPUs) | $75K–$200K | $300K–$600K |
| Large (1,000+ GPUs) | $200K–$500K | $750K–$1.5M |

**First client:** Accept below market rate in exchange for a private reference and permission to say "deployed at [company]" to the next prospect. That reference is worth more than the price difference.

---

## Target Buyers

**Primary (write the check):**
GPU cloud providers and LLM inference companies feel GPU starvation directly in their margins. They sell GPU utilization as a product. Any measurable improvement is direct revenue.

- CoreWeave, Lambda Labs — GPU cloud, sell utilization by the hour
- Together AI, Fireworks AI, Modal — LLM inference providers
- Anyscale — Ray-based ML infrastructure

**Secondary (may buy, slower process):**
- Hugging Face — owns the `tokenizers` Rust library this code uses, runs TGI serving stack. More plausible buyer than PyTorch/Meta.
- Databricks (MosaicML) — LLM training infrastructure

**Do not pitch:**
- PyTorch/Meta — open source project, they'd implement it themselves
- Hyperscalers (AWS, GCP, Azure) — too slow, too much process

**NVIDIA contact:**
Wait until H100 benchmark is complete. Send the Nsight trace + one paragraph. They may be interested as an ecosystem/marketing play ("runs X% faster on H100"). Do not approach before having the measurement.

---

## B2B Sales Process

### First contact (Zoom call)
The first call is discovery, not pitch. Goal: understand their specific infrastructure before presenting a solution.

**Ask first:**
- What GPU hardware? (H100, A100, MI300X — how many?)
- What serving stack? (vLLM, TGI, custom?)
- Current GPU utilization rate, if known?
- What caught their attention?

**Then:** "Based on what you're describing, here's specifically where this helps you..."

**On pricing:** Don't volunteer it first. If pressed: *"For a deployment your size I'd expect $50K–$150K annually. I want to understand your infrastructure better before giving you a specific number."*

**End of first call:** Set up follow-up with their infrastructure lead. Do not sign anything on the first call.

### NDA
Get an NDA signed before showing the GPU source code on any call. The open-source Postgres piece is fine to show. The GPU pipeline (`src/llm.rs`, `gpu-zero` branch) is not.

### Solo developer objection
Enterprise buyers will ask: *"What happens if you're unavailable?"*

**Answers:**
1. Source code sale model answers it directly — they own the code
2. Technical partner (friend's software business) provides continuity
3. Source code escrow clause: code held by third party, released if unavailable for 90 days — this is standard and removes most of the objection

---

## Maintenance and Support

**Reality for 1–2 enterprise clients:**

| Phase | Time commitment |
|---|---|
| Active development (first 3–6 months) | 20–40 hrs/week |
| Steady state | 5–10 hrs/week per client |
| Major CUDA/PyTorch version update | 2–4 days, happens 2–3x/year |
| Production incident | Drop everything, 1–3 days |

**Scope the support in the contract:** Cover current PyTorch LTS + one prior release. Anything newer is a paid upgrade. This prevents unbounded compatibility obligations.

One person can support 2–3 enterprise clients at steady state.

---

## Outsourcing

A friend with a software business can handle work that is not the core differentiator:
- Support ticket triage and first-response
- Documentation and integration guides
- Testing infrastructure (benchmark runs against new PyTorch/CUDA versions)
- Non-GPU features (Postgres pipeline, Python API polish)

**Do not outsource:** The GPU pipeline code, benchmarking methodology, CUDA/ROCm work — these are the differentiator.

**Rate:** Pass 60–70% of contract value for defined scope. On a $100K contract where the friend does 30% of the work: $18K–$21K to them. You take the larger share because you carry the business development risk and hold the client relationship.

**Critical:** Any work they do on the core library must be IP-assigned to the LLC in writing before the first engagement.

---

## Multi-Language Strategy (Rust + C++)

**Why both:**
- Rust is the development language — memory safety makes GPU pipeline bugs easier to catch
- C++ is the enterprise deliverable — the entire ML infrastructure ecosystem (cuDNN, TensorRT, vLLM C++ backend) is C++
- Having both is a differentiator from vibe-coded projects; it signals deep systems understanding

**How:**
- WhetstoneAI (separate project) can transpile language primitives automatically
- Library dependencies require manual substitution (see below)
- Rust is source of truth; C++ is a generated + manually doctored artifact per release

**Library substitutions for C++ version:**

| Rust dependency | C++ equivalent | Complexity |
|---|---|---|
| `cudarc` | Direct CUDA C++ calls (actually simpler) | Low |
| `rayon` | OpenMP `#pragma omp parallel for` | Low |
| `tokenizers` | SentencePiece (LLaMA) + tiktoken (GPT) | Medium — different API |
| `pyo3` | pybind11 | Medium — parallel structure |
| `tokio` | Not needed for GPU-only C++ version | N/A |

`parser.rs` (Postgres pipeline) is not worth transpiling — stays Rust only.

**Estimated work for C++ `llm.rs`:** 2–3 days after Whetstone handles primitives.

---

## NM State Funding Assessment

**Worth pursuing:**
- **NM Small Business Assistance Program (NMSBA)** — pairs small businesses with Sandia/LANL. The value is free access to HPC hardware (H100/A100 clusters), not the money. Solves the enterprise benchmark problem. Apply for this.

**Not worth pursuing (for now):**
- NMEDD money grants, angel tax credits — require registered business, matching funds, 3–6 month timelines. Time cost doesn't pencil out against a direct licensing deal.

**Key point:** Most state grant programs want an ongoing business, not a one-time IP sale. If the goal shifts toward a licensing business, revisit.

---

## Immediate Priorities

1. Fix Phase 1 correctness issues (see ROADMAP.md) — nothing else matters until these are done
2. Wednesday: H100 benchmark on Lambda Labs (~$2), run under `nsys profile`
3. Thursday/Friday: Incorporate H100 numbers into talk slides
4. Talk: 10-minute presentation to IT/Cybersecurity group (see docs/talk-10min.md)
5. Form Wyoming LLC before any serious sales conversation
6. After first client: evaluate C++ version via Whetstone transpilation