Wedges, moats and proof

The idea in one line: A primitive gets copied in four weeks, but a verifier only you can run does not, so own one narrow decision whose answer a program can check, prove it beats both the best specialist and a frontier model, and ship it where developers already are.

In October 2026 OpenAI, Microsoft, Cloudflare, AWS and Perplexity all shipped Jev-style decision models or endpoints within about four weeks of Jev’s launch (the market map). If your pitch is “a model that returns typed decisions”, you were commoditized before you started. The 10x move is to sell something they cannot copy from a blog post: a verifiable reward in one vertical, meaning a score a program computes without a human (the build passed, the ruling matched, the measured weather crossed the line). This lesson is how to find that reward, protect it and prove it.

A wedge is the narrowest product you can own end to end: one typed question, one data source, one verifier and one buyer who pays per decision.

Worked example. In a sample of recent runs in Universal Blue’s kernel-module repository, 40 of 47 re-attempted CI runs (85%) passed on retry, and seven of nine sampled failures were mirror download errors, not compile errors (where the time goes). So the question “will a retry pass?” is a yes/no decision (a Noul, Jev’s yes/no type) with a free, automatic label: rerun it and see. Inference is not the cost. At $0.042 per million input tokens, triaging every failed Fedora build task for a year on 2,000-token log snippets costs about $24. The scarce things are the label miner, the plumbing and the eval. That is a wedge: tiny, checkable, and useless to a frontier lab that does not run your build farm. The decision map lists 15-25 more like it.

The evidence that one person or a small team can compete on the model itself is now strong.

LoRA, a reminder: a small add-on matrix trained on top of a frozen model, so you train millions of numbers instead of billions (three ways to teach a model). decider-2b’s own card carries the caveat every founder should copy: its default yes/no temperature is uncalibrated, with an expected calibration error (ECE, the average gap between stated confidence and actual accuracy) of 0.341 against 0.095 once tuned. The model was cheap; the honesty about probabilities is the work.

TabPFN’s path is the cleanest lab-to-exit story in the field:

TabPFN: from a lab paper to an acquisition

2022-07  arXiv paper, Freiburg lab: up to 1,000 rows, trained
         only on synthetic tables; 230x CPU speedup over AutoML
2025-01  Nature paper: beats a 4-hour tuned ensemble in 2.8 s
         on up to 10,000 rows
2025-02  Prior Labs raises a EUR 9M pre-seed
2025-11  TabPFN-2.5: weights non-commercial, paid for production
2026-05  SAP agrees to buy Prior Labs; pledges EUR 1B+ over 4 years
2026-09  TabPFN-3.5: up to 1M training rows

Sources: arXiv 2207.01848 (2022-07-05), the Nature paper record (2025-01-08), SAP News (2026-05-04), Prior Labs docs.

Read across the cases and one playbook repeats:

1. Pick an output type that is closed-set and checkable.
2. Train on data you may legally use: synthetic (TabPFN), public (Chronos), or frontier-labelled public splits (decider-2b).
3. Release open weights to get distribution.
4. Win a named public leaderboard: TabArena, GIFT-Eval, JevBench, Matbench.
5. Sell hosting, enterprise licences or commercial rights.

The leaderboard is the marketing. The data-rights story is the diligence.

• Hugging Face. decider-2b’s 95k monthly downloads, Synthefy’s 600k downloads in weeks, TabPFN’s 3M+.
• AI gateways. Vercel said Jev reached about 13% of paid AI Gateway teams within 24 hours, about twice the GPT-5.6 family’s share (InfoQ, 2026-10-01); that comes from one source.
• Framework integrations. A LangChain integration and five independent Elixir clients appeared within days. Browserbase put Jev inside Stagehand with a 0.7 acceptance threshold and an LLM fallback, cutting median action latency from 1.97 s to 0.46 s (Browserbase, 2026-09-21).
• Interface compatibility. Cloudflare’s Clef copied Jev’s API so developers could switch without rewriting. Do the same: be a drop-in for the Jev, OpenAI and Clef schemas, and gateways and frameworks pick you up on day one.

The catch: gateways charge no markup (Vercel) or sort providers by price (OpenRouter’s :floor), so they put you in a list next to every rival.

Non-dilutive money costs no equity. All of it favours open, publishable work, which fits an open-weights launch. As of October 2026:

A moat is whatever stops a well-funded rival from copying you next month. The test is simple: how long would OpenAI or Microsoft need? For the primitive it was about four weeks. Here is how each candidate held up in October 2026:

Here is where the durable moats sit in a bootstrapped vertical product. How to read the diagrams explains the boxes.

C4 · L1 System context · Vertical decision service

                     +---------------------+
                     | [Person]            |
                     | Customer engineer   |
                     | owns the workflow   |
                     +---------------------+
                                |
                                | asks typed questions
                                v
                   +-------------------------+
                   | [Software system]       |
                   | Vertical decision API   |
                   | answers with odds       |
                   +-------------------------+
                                |
          +---------------------+---------------------+
          | scores against      | escalates           | sells through
          | real outcomes       | low-odds cases      |
          v                     v                     v
+-------------------+ +-------------------+ +-------------------+
| [External system] | | [External system] | | [External system] |
| Verifier          | | Frontier LLM API  | | AI gateway        |
| build, ruling, QC | | slow fallback     | | lists and bills   |
+-------------------+ +-------------------+ +-------------------+

The customer asks typed questions; your service answers with a probability, sends low-confidence cases to a frontier model, and scores itself against a verifier. The left box (your verifier and the outcome data it produces) is the moat. The middle box is a cost you shrink over time. The right box is distribution you rent.

• Frontier labs add a “decision mode”. It already happened: OpenAI in about 21 days, Microsoft in under 28. Microsoft says it will rebase Decision-1 on its own and OpenAI models (InfoWorld, 2026-10-13). A primitive gets copied; a vertical reward does not.
• Commoditization. 208 models on the Decision Index by 2026-10-21, a shared three-type API, prices at $0.01-$0.04 per million tokens.
• The bitter lesson. Rich Sutton’s 2019 essay argues that general methods which use more computation win in the long run, by a large margin, while built-in human knowledge plateaus (The Bitter Lesson; the page failed to load over TLS, so this paraphrases the well-known text). The strongest form against you: Medprompt, GPT-4 with general prompting, beat the specialist Med-PaLM 2 on all nine MultiMedQA benchmarks (arXiv 2311.16452). The counters: Rodney Brooks says count the whole cost, including energy, and “a human brain only requires 20 Watts” (A Better Lesson); Sutton himself doubts LLMs are bitter-lesson cases (Dwarkesh Podcast, 2025-09-26); and the best specialists are compute-scaled methods. Specializing here means spending compute once in training so each call is cheap, not hand-coding rules. The economic counter is the 65-318x cost gap at equal accuracy.
• Routing pressure. Routing sends each request to the cheapest model likely to succeed. RouteLLM cut costs by over 2x without losing quality (arXiv 2406.18665). With copied APIs and price-sorted gateways, buyers will route to the cheapest model that clears their accuracy bar, which caps your margin unless you own a reward nobody else has.
• Cost moats decay on a clock. The “densing law” says the parameters needed for a fixed quality halve about every three months (Xiao et al.). “We are cheaper” erodes on that schedule.
• Licence traps. TimesFM-3 and TabPFN-2.5 to 3.5 bar commercial use, including derivatives and outputs used for business decisions; build on Apache bases (Toto 2.0, Chronos, Clef, Decider, decider-2b). Teachers matter too: Anthropic, Google and OpenAI restrict training competing models on their outputs, while DeepSeek explicitly permits distillation.

YC’s bar has two parts: “rights to the data and a clear win in accuracy and compute over existing specialist models” (YC RFS). October 2026 showed what falls short.

What fell short. Jev’s launch claimed “193.6x faster, 444.6x cheaper” (TypeSafe’s own figures). The SmartScope critique found the multipliers averaged four in-house workflows, the reference labels were the averaged answers of two chosen models rather than human ground truth, the runs came from laptops in one region, and there was no reproducibility package (SmartScope, 2026-09-19). A scan of 12,759 launch tweets found a median user-reported speedup of 7x (InfoQ); that comes from one source. Both numbers are “true”: one is a hand-picked best case, the other a broad population of real uses.

Worked example: cost per completed workflow. Investors should ask what a whole job costs, including the fallback. Say your small model costs 1 unit per item and the frontier model 100 units. Every item goes through yours; the unsure ones also go to the frontier model.

cost per item = 1 + (1 - coverage) x 100      (all-frontier = 100)

coverage 80%   1 + 20 = 21 units   100 / 21  = 4.8x cheaper
coverage 95%   1 +  5 =  6 units   100 /  6  = 16.7x cheaper
coverage 99%   1 +  1 =  2 units   100 /  2  = 50x cheaper

Coverage is the share of items you answer without escalating. The 10x lives in the last few points of coverage you can trust, and only calibration can certify those (from probability to automation). Proving it takes labels: ±5 points on a 50% rate needs 385 labelled items, ±1 point on a 2% error rate inside the automated slice needs about 753 automated items, and error bars 10x tighter cost 100x the labels.

Be exact about “orders of magnitude” too. One estimate puts a self-hosted 150M encoder at 350-16,000x cheaper per decision than Sonnet-class LLMs, but only 10-800x cheaper than the cheapest frontier tier, which, batched or cached, sits within about 1-3x of Jev’s list price. Against that tier, pitch accuracy, calibration, latency, privacy and edge deployment, not price alone.

The evidence pack, made concrete:

The best openings for a bootstrapper share four traits: a program can compute the reward; the data is public or self-generated; incumbents are generative or absent; and the buyer pays per decision. Each row below is a decision layer, a choice or probability rather than generated text. The list is deliberately sceptical.

Rows 1 and 4 are the course’s distro co-pilot.

Rejected on purpose:

• Generic LLM-judge or hallucination detection. Jev, Clef and d1 already score about 85% for $0.03-0.22 per 1,000 judgments.
• CVE exploit probability. FIRST’s EPSS is free, daily and open (FIRST).
• A new general time-series or weather model. Google, Datadog, Amazon and IBM give these away.
• Anything that needs pretraining at Evo 2 or ESM3 scale, billions of core-hours of DFT labels, or a wet-lab loop. Not bootstrappable.

• Whether a vertical decision API counts as “Model as a Service” under Qwen3.8’s licence is unclear without guidance from Qwen.
• Whether a typed-decision model trained on others’ data is fair use is untested. The closest US appellate ruling, Thomson Reuters v. Ross (2026-09-29), rejected fair use for a non-generative competitor (data rights).
• US SBIR’s authorization status in late 2026 was unstated; check before applying.
• Whether buyers will pay a premium for a flat per-decision price with a calibration guarantee has not been tried.

• YC Requests for Startups — the bar in YC’s words: data rights and a clear win in accuracy and compute.
• Mapika/decider-2b model card — a one-person decision model, with its recipe and calibration caveat.
• Hollmann et al., Nature (TabPFN) — the paper that took a lab model to an acquisition.
• SmartScope on Jev’s launch numbers — a model critique of vendor benchmarks.
• Browserbase: What is Jev? — a threshold-plus-fallback deployment with measured gains.
• EIC Accelerator — the largest grant-plus-equity route for an EU founder.