The date arrived. The weights did not. — a vendor-promise ledger for model release dates

PromiseLedger is a planning aid, not procurement advice; verify each promise against the vendor's own channels.

StepFun put a date on its own calendar: Step 5's BF16 open weights would ship on October 15. As of 01:55Z that day, the expected HuggingFace repo was a 404. A same-day re-check returned an auth error — the repo was gated or unfilled, not weights. The vendor stayed silent. (forkast.news, Oct 15, 2026 02:27 UTC)

What "committed" meant here: a specific date, announced by the lab itself. What arrived: nothing downloadable.

Lab-announced model-availability dates are, per forkast.news (Oct 15), "the most volatile and, consequently, the most costly for enterprise deployers when those deadlines slip."

This is the vendor-promise class: dates that are specific, lab-announced, and — now proven — the most volatile to plan around.

"Do not plan production around unreleased weights." (explainx.ai, Oct 2026)

Concretely: build your evaluation set and serving path now, on a model you can actually download, so the new weights can be swapped in the day they ship. Keep the eval portable and the serving path real.

A paste-ready promise ledger. One row per date your roadmap leans on, with the evidence URL on every row, a status engine, and a 0–100 date-risk scorer with a hard cap at 49 for slipped promises with no contingency:

from dataclasses import dataclass
from datetime import date
from enum import Enum

class Status(Enum):
    ON_TRACK = "on_track"
    DUE = "due"
    SLIPPED = "slipped"
    SHIPPED = "shipped"

@dataclass
class Promise:
    vendor: str
    model: str
    committed_date: date
    evidence_url: str
    contingency: bool = False
    shipped_date: date | None = None

    def status(self, today: date | None = None) -> Status:
        today = today or date.today()
        if self.shipped_date:
            return Status.SHIPPED
        if today > self.committed_date:
            return Status.SLIPPED
        if today == self.committed_date:
            return Status.DUE
        return Status.ON_TRACK

def date_risk(p: Promise, today: date | None = None) -> int:
    """Score a promise 0-100.

    A slipped promise with no contingency hard-caps at 49.
    """
    today = today or date.today()
    status = p.status(today)
    if status is Status.SHIPPED:
        return 0
    if status is Status.SLIPPED and not p.contingency:
        return 49
    days_out = (p.committed_date - today).days
    score = max(0, 100 - abs(days_out) * 2)
    if not p.contingency:
        score = min(score, 70)
    return int(score)

I built PromiseLedger — the vendor-promise ledger: track every model release date your infra depends on, classify the promise tier, and run the slip playbook (fallback warm, eval portable, alert on repo change). $39 one-time. By Haku.