Logistics AI readiness for vendors: evaluating, buying and governing the AI you don't build

Stage 1 is not gullibility — it is asymmetry. The vendor has run its demonstration hundreds of times against data curated to flatter the product; the operator is seeing it once, without a baseline of its own to compare against. Under that asymmetry, selection quality is capped no matter how experienced the buying team is, because every input to the decision was produced by the seller.

The tell is what happens after signature. Integration effort was a line in the vendor's proposal rather than a tested fact, so the first months of the contract are spent discovering the real shape of the work: the WMS export the product assumed doesn't exist, the EDI 214 feed carries half the events the model needs, the master data has three codings for the same carrier. None of this was hidden — it was simply never tested, because the evaluation never touched the operator's own systems.

The stage is self-perpetuating in a specific way: each disappointing purchase is blamed on the vendor, and the next vendor is selected by exactly the same process. Operators can cycle through three routing or slotting products in five years without once changing the method that chose them — which is the actual defect. The exit from stage 1 is not a better vendor; it is the first internal baseline that makes vendor claims testable.

Stage 2 looks like rigour and often defeats its own purpose. The RFP process is real: requirements are gathered, criteria are weighted, demos are scored by a panel, references are called. But every artefact in the process is still a claim rather than a behaviour. A 400-line requirements matrix scores what the vendor asserts about the product; it cannot score what the product does when it meets the operator's EDI reality, because nothing in the process ever connects the two.

The structural bias of checklist buying is toward feature count, and feature count favours suites and punishes depth. A vendor with forty features that each work at demo quality outscores a vendor with four features that survive production — the matrix cannot see the difference, and the reference calls can't either, because references are curated by the same seller. Meanwhile the two chapters that decide the contract's fate — integration effort and data terms — sit at the back of the RFP as compliance questions ('Do you provide APIs? Yes.') that every vendor passes.

The costly part is timing. At stage 2 the operator discovers integration reality and negotiates data terms after selection, when leverage is gone: the internal announcement has been made, the project has a name, and the vendor knows it. Terms that would have cost nothing to obtain in a competitive process are now priced as change requests. Most of what operators later describe as lock-in was conceded here, in the weeks after the winner was chosen.

Stage 3 inverts the asymmetry of stages 1 and 2: the operator now controls the experiment. Candidate vendors run against the same six months of TMS and WMS history, on lanes the operator chose, scored against the operator's own baseline in operational units — ETA error in minutes, OTIF points, dwell minutes — with a set of holdout lanes no vendor sees until scoring day. The demo still happens, but it has been demoted from evidence to theatre, which is what it always was.

Two disciplines make the stage real rather than nominal. First, the trial is paid: a fair fee for a bounded PoV filters for vendors confident enough to be measured, and removes the pretext that a free pilot's failure was under-investment. Free pilots are sales activity, and both sides price them accordingly. Second, at least two vendors run to the end. The moment a single vendor knows it is the only candidate, the operator's negotiating position on data terms, exit assistance and SLA metrics collapses — most of stage 3's commercial value comes from keeping the competition alive until signature.

What stage 3 has not yet solved is the portfolio. Each selection is disciplined, but selections accumulate: three years of good individual decisions produce a visibility platform, two point solutions and a suite module with overlapping capabilities, each renewed on its own cycle by whoever signed it. Nothing in the operation can say what the vendor estate costs per decision, which contracts overlap, or which renewal dates are approaching. The selections are governed; the stack is not.

Stage 4 extends the trial discipline into the life of the contract. The scoring harness built for the PoV — baseline, operational metric, holdout re-checks — keeps running after go-live, so the operator always knows what each vendor's model is doing on its own lanes this quarter, not what the vendor's QBR deck says it is doing. This sounds like bookkeeping and behaves like leverage: renewal conversations change character entirely when the buyer opens with the vendor's own acceptance-rate trend.

The register is the artefact that makes the stage visible. One list: every AI vendor, the decision it serves, the named owner accountable for its outcome, the contracted metric, the renewal date, the annual cost, the last telemetry reading. Most operators assembling it for the first time find things nobody chose: two products computing ETAs for different teams, a suite module licensed but unused since a champion left, a point solution whose owner departed eighteen months ago while the subscription auto-renewed twice. The register does not fix any of this; it makes it undeniable.

What stage 4 cannot yet do is recompose. Each vendor is well-governed in place, but the integrations are point-to-point — the visibility platform wired directly into the TMS, the slotting engine directly into the WMS — so replacing any of them is a project measured in quarters. The operator can measure, negotiate and even decide to switch; it cannot yet switch cheaply. Renewal gates have teeth only when walking away is priced, and at stage 4 it is still priced too high.

Stage 5 is not vendor independence — it is vendor optionality. The operator still buys most of its AI, and should: no logistics operator will out-build a visibility network's data advantage or a suite vendor's integration surface across its own product. What changes is the architecture of the relationship. Every vendor consumes and returns data through an integration layer the operator owns — canonical shipment and warehouse events, GS1-style identifiers, documented schemas — so a vendor is a replaceable module in a stack the operator composes, rather than a load-bearing wall the stack was built around.

The discipline that keeps the stage honest is the rehearsed exit. Once a year, one vendor-served decision is deliberately failed over to its documented fallback — the previous rule set, an alternative product, a manual procedure — on a quiet lane set, and the elapsed time and pain are recorded. The first rehearsal is always humbling: the export that had never been re-loaded, the fallback rule set nobody had updated since go-live. But an operator that has rehearsed an exit negotiates differently, buys differently and — as Convoy's customers discovered — absorbs a vendor shutdown as a migration rather than an incident.

Build-versus-buy becomes a live, per-domain decision rather than an identity. Commodity decision domains — visibility, freight audit, standard forecasting — stay bought and are re-competed at renewal. Domains where the operator's data or network shape is genuinely distinctive become candidates to build, because the integration layer that made vendors replaceable is the same substrate an internal model plugs into. Stage 5 operators move specific decisions in-house not on principle but on arithmetic, and sometimes move them back.