Landauer's principle in supply chains

The objection that should win

Here is the strongest case against this page before it is made. A supply planner does not care about zeptojoules. She cares that a customs filing landed in a queue nobody watches, that the tariff schedule changed on a Tuesday, and that the shipment already left Yantian on the assumption it hadn't. The physics of erasure is not her problem. Her problem is organisational: too many feeds, too few eyes, no single place where "this fact is now false" gets written down before someone acts on it. Landauer's principle describes a lower bound so far beneath the cost of a bad enterprise resource planning integration that citing it feels like blaming a shipping delay on the curvature of the Earth. Every real inefficiency in a supply chain sits many orders of magnitude above kT ln 2. Invoking a physical floor to explain a software and process failure is a category error dressed up as rigour.

That objection is basically right about scale, and it is worth sitting with before disagreeing with its conclusion.

Where the objection lands

A supplier filing sits in a portal at maybe a few kilobytes. A modern server writes and discards data at energies a billion or more times the Landauer bound, dominated by DRAM refresh, network interconnect and the fans keeping the rack cool. Nobody at a freight forwarder is metering joules per erased manifest line. If the thesis of this page were "supply chains fail because deleting data costs energy," the objection would end the discussion. It does not need to be defended at that resolution, because that is not the claim.

The claim is about an asymmetry, not a number. Writing a record — a new port telemetry ping, an amended tariff notice, an updated supplier filing — can be made arbitrarily cheap. Copying it further, cheaper still. But retiring a record, in the sense that matters to a planner — marking it superseded, propagating that fact through every downstream plan that depended on it, and doing so with enough audit trail that someone can later ask why the old assumption survived as long as it did — is categorically harder than writing. That asymmetry is not a hardware accident of 2024. Landauer located its source in 1961: logically irreversible operations, the ones that collapse two or more prior states into one, must dissipate energy; operations that merely add information need not. Erasure is a logically irreversible operation. Superseding a shipment plan is an act of erasure on the belief that produced it, even if the paperwork is kept forever.

So the objection is right that the joule count is irrelevant and wrong that the asymmetry is. The asymmetry is what shows up, at every scale actually engineered, as the observed fact that deleting a belief reliably — with the trail intact, with every plan built on it revised in step — is always more expensive than forming it in the first place. That is not a claim about physics being the bottleneck. It is a claim about why the bottleneck has the shape it has.

The characteristic failure, examined

The recurring failure mode in freight planning is a plan that survives on an assumption invalidated by a filing nobody read. A routing decision assumes a tariff schedule; the schedule changes in a notice filed three weeks earlier; the plan proceeds because nothing forced a re-check. Read as an intake problem, this looks like a monitoring gap — add more alerts, watch more feeds. Read through Landauer, it looks different. The planning system did the cheap thing: it wrote the plan once, off a snapshot of belief, and then held still. That is exactly the strategy a Large Language Model uses on its training corpus — compress a bounded set of facts into weights, pay the cost of forgetting once, at compression time, and never again. A shipping plan built off a quarterly tariff table and left to run is a small Large Language Model: cheap, stable, and wrong the moment the world underneath it moves and nobody pays to re-forget.

The alternative, watching every stream continuously and never freezing a snapshot, is not free either. It just moves the cost from "cheap and eventually wrong" to "correct and continuously expensive," because now every incoming filing has to be checked against every live plan for whether it overturns an assumption that plan depends on. That check is the erasure operation. Somebody, or something, has to decide: does this new tariff notice retire the belief that underwrote yesterday's routing? If yes, the retirement has to propagate — to the manifest, to the customs broker's paperwork, to the carrier booking — and each of those propagations is itself a small act of forgetting an old, now-false state. None of this is optional once the intake is genuinely continuous. Ports run telemetry feeds, customs regimes file amendments on their own clocks, suppliers submit conformance filings that supersede prior ones without warning. There is no snapshot boundary anywhere in that system unless someone imposes one, and imposing one is exactly the Large Language Model move: bounded, stable, stale on a schedule nobody chose deliberately.

Why append-only doesn't dodge it

A natural answer from systems design: never erase anything. Keep every version of every manifest, every superseded tariff filing, every prior plan, and let revision happen by writing a new record that points back at what it replaces. Event-sourced logistics platforms already work this way, and it is a real improvement over silent overwrite — provenance survives, and an auditor can reconstruct exactly which filing should have triggered which replan.

But deferral is not the same as avoidance. An append-only ledger of shipping manifests grows without bound while the warehouse of disks holding it does not. Every such system eventually compacts, archives to colder tiers, or expires records past a retention window, and every one of those operations is the erasure the design was supposed to sidestep — now batched, delayed, and often done with less care than a real-time decision would have received, because by the time compaction runs, nobody remembers why a given filing mattered. What append-only architecture actually buys a supply chain is control over when the cost is paid and what exactly gets destroyed, not exemption from paying it. That is worth having. It is not the same as the problem going away, and it concedes the point this page is making: the trade between keeping and discarding has to be managed as a first-class design decision, because it does not resolve itself.

Reversible planning has the same limit

A second answer, borrowed from computing rather than logistics: run the planning process reversibly. Never overwrite a routing decision; instead, keep enough state to unwind it exactly, the way Bennett's reversible logic gates uncompute their own garbage instead of discarding it. In principle this makes revision arbitrarily cheap, because nothing is thrown away — the "old" plan is not erased, only inactive, reconstructible on demand.

This works cleanly for a planning run with a defined start and end: a single shipment's routing, computed once, revisable by rewinding. It works far less cleanly for the planner's actual job, which is not one closed computation but an unbounded stream of manifests, telemetry, filings and tariff notices arriving with no scheduled end. Reversibility trades dissipation for retained history, and that trade is only affordable when the history has a bound. A supply chain's live intake has no such bound; the further back a reversible planning system has to reach to unwind a decision, the more state it must have kept, and that state grows in step with time under observation, not in step with problem size. Reversible computing dissolves the constraint for problems that terminate. Continuous intake, by construction, does not terminate.

The narrower claim

None of this says a fourth category of intake exists beyond watching everything, continuously, forever. It says that the position which watches everything cannot get there by either of the cheap strategies available to its predecessors. It cannot forget once and hold still, the way a frozen corpus permits. It cannot forget almost everything by default and let the scene end, the way a bounded scene permits. It must forget selectively, defensibly, and continuously, retaining provenance for what it keeps long enough to know why it was kept, and paying real cost — computational, organisational, procedural — every time an incoming filing forces the retirement of a belief a live plan still depends on.

The terminal position on the intake axis, then, is not the one with infinite memory. It is the one where the decision about what to stop believing, and when, becomes the central engineering problem rather than a background assumption inherited from whichever snapshot the plan happened to start from.