The $0.50 Bin and the Brain in the Corner: What AI-Native Replenishment Actually Looks Like

Most of what is written about LLMs in industry has no number attached. This essay is the opposite: one everyday operation — refilling a parts bin — instrumented end to end and costed to the cent. For scale, the most honest anchor available is what today’s option costs, from the vendor’s own published price list: a sensor-and-SaaS kanban system runs approximately $544 per bin over three years at its full-service tier. The AI-native cell on my desk lands at approximately $40.50 per bin. The gap is not the point by itself — the point is that both numbers are real, published or measured, and the difference between them is structural. That structure is what this essay is about.

The established model puts the cost of intelligence in every bin — a sensor, a reader, a SaaS seat, multiplied by bin count, forever. The AI-native model puts a $0.50 printed card in the bin and a shared local brain in the corner of the room. Sensing goes dumb and cheap. Intelligence goes commodity and local. That inversion is why the multiple against eTurns’ own full-service tier lands around 13×, and why it still holds at roughly 4× against eTurns’ own cheapest published tier. Both figures come from the same vendor’s own price list — used here as a market reference, with respect: published pricing is what makes an honest comparison possible at all.

I am not asserting this from a spreadsheet. It is running on a mini-PC on my desk, watching two printed-card bins through an overhead camera, reading each bin with an on-box vision-language model and deciding refills against a deterministic threshold — nothing leaves the box. This is the flagship argument behind The Factory That Pays for Itself, a five-part case study that works through the mechanism in detail — Part 1 lays out the factory topology, and Part 5 carries the full cost model this essay cites. Read this essay for the argument; read that series for the receipts behind every line item.

Where Today’s Cost Lives: One Sensor Per Bin#

Every mainstream automated-kanban approach — weight-sensor VMI, RFID kanban, per-seat SaaS — solves the sensing problem by putting a powered, priced component in every bin, then charges a recurring subscription to read it back. The economics are vendor-published, not estimated:

• eTurns SensorBins + “Manage” SaaS ($249/stockroom/month, full-service tier): approximately $544/bin over three years.
• eTurns SensorBins + “Replenish” SaaS ($40/stockroom/month, entry tier, same sensor hardware): approximately $168/bin.
• RIOT RFID Box ($150/location/month, subscription-inclusive; a directional, retail-grade proxy rather than an enterprise RFID benchmark): approximately $270/bin.
• Fully manual two-bin replenishment (labor only, BLS median wage with a standard burden factor; the replenishment cycle time itself is a modeling assumption, not a measured figure): illustratively $655/bin.

Two things about that list matter more than any single number. First, it is the same vendor’s own tiers bracketing the range — $168 to $544 for eTurns alone, depending on which SaaS tier you buy against the identical sensor hardware. Second, every one of these costs is per bin. Add a bin, add the cost. Add a hundred bins to cover a new product line, add a hundred sensor units and the per-stockroom SaaS seat that comes with them. This is why weight-sensor and RFID kanban systems, which work perfectly well as engineering, have never scaled down cleanly into the high-mix SME cell where a single assembly station carries twenty different fastener and connector bins that turn over unpredictably. The unit economics do not bend to fit the smaller, messier case — they are linear in bin count by construction.

The Inversion: Move the Cost Off the Bin#

The AI-native alternative does not out-engineer the sensor. It removes it. What sits in the bin is a printed color-coded card — no battery, no radio, no mechanical part — costing approximately $0.50 in bulk. Part 2 of the case study works through the mechanism: a Color-Blocked Ramp liner and a printed marker, read by an overhead camera that already covers the whole cell.

What replaces the per-bin sensor is a single shared decision node — the “brain in the corner” — running a local large language model that makes the replenishment call for every bin in every cell it serves. In the reconciled three-year model (400 bins, 20 cells, one fleet-shared node at a 1:20 ratio), that comes to approximately $40.50 per bin: a $4,000 decision node ($10/bin at 400 bins), $200-per-cell cameras and mounts ($10/bin), the $0.50 printed liner, and $8,000 of one-time engineering — harness build plus per-cell calibration — to stand the system up ($20/bin — the largest single line item, not the hardware). Part 5 is the full decomposition; the number here is quoted, not recomputed.

The structural claim is this: cost stops scaling with bin count and starts scaling with cell count and fleet size, and both of those amortize. A camera and mount cover twenty bins, not one. A single decision node — sized once for the largest model it needs to run — serves twenty cells, not one bin. Add a new SKU to a bin and you have added a printed label, not a sensor. This is why the advantage is not a flat discount: it is a curve that gets better as the fleet gets bigger, while the per-bin model’s curve stays flat by construction.

The Proof Is on My Desk, Not in a Deck#

Here is the part a spreadsheet cannot give you: the system runs.

It watches a real bin. Two bins sit under an overhead camera on my desk. Scoop material out of a bin by hand and the on-box vision-language model re-reads each bin’s rectified crop every cycle, printing a live fill fraction, zone, and confidence note in the terminal, while a stability filter refuses to fire on a single noisy frame. Only after a sustained, confirmed depletion crosses the reorder threshold does the system stage a replenishment command — a gated email preview, never sent automatically. No weight sensor, no RFID tag, just a camera that already had to be there for the vision check.

An on-box model reads the bin; a rule in code decides the refill. An on-box vision-language model — Qwen3-VL-8B, loopback-only, nothing leaves the box — looks at each bin’s rectified crop and returns a fill fraction plus a plain-language note, at roughly 7.7–11.4 seconds per frame on the mini-PC’s integrated GPU. The reorder decision itself is not a model call: it is a deterministic threshold check (fill below the reorder point) confirmed by the stability filter’s consensus window — a rule in code, not an LLM — and every crossing only ever stages a gated preview, never an auto-sent order. On the bench, a larger local model (Qwen3.6-35B-A3B) matched a cloud reference model’s decision call-for-call on the harder, higher-order batching judgment — evidence that the judgment layer can stay local too — though the deployed edge config may run the single 8B model for everything, given the GPU-RAM cost of holding a 35B-class model resident. The load-bearing claim is “the intelligence runs on-box, no cloud,” not “a 35B model is required.”

Every order traces to a frame. Every staged replenishment resolves back to a specific camera episode and a decision trace — observation, belief, decision, command, in that order, queryable after the fact. A model that makes a good call once is a demo. A system where every call is traceable to the frame that triggered it is what makes the demo trustworthy enough to run unattended.

Three properties follow directly from moving the cost off the bin, and none of them depend on a specific vendor comparison holding exactly.

The economics flip by roughly an order of magnitude — the honest range is 4× to 13× depending on which vendor tier you compare against, not a single bare “10×.” That range is itself the finding: it spans the vendor’s own cheapest tier to its full-service tier, which is a structural gap, not a cherry-picked one.

It scales without a per-site ML engineer. The reasoning layer is portable across sites without retraining — the same local model, the same harness, works at every cell. What changes per site is calibration: a short, gated, human-supervised pass to tune camera framing and zone thresholds for the local lighting and bin layout. That is a deliberate reframe from an earlier, sloppier claim that the system “self-calibrates.” It does not learn unsupervised, and it should not — adaptation lives in the harness, the per-site prompt, and configuration proposals that a human or a test suite must approve before they take effect, never in a model quietly rewriting its own rules.

It is sovereign by default, not by certification. Inference is loopback-only — no cloud egress for the decision itself, no per-cycle token bill, no dependency on an external API staying up. That is a narrower and more honest claim than “air-gapped” (the node still carries a plant network interface for provenance queries and fleet management) or “IEC 62443 compliant” (compliance is a certification outcome, not a property of running local inference). What loopback-only inference actually buys you is a smaller conduit-audit surface — fewer network paths a security review has to reason about — which is a real, defensible property short of a compliance claim.

Where does the audit trail go once a system like this scales past one desk to a fleet of factories? The episode-and-decision-trace store here runs on SQLite-graph — deliberately, because it is zero extra service and one less network path. At fleet scale, the natural home for that same lineage data, queried across sites and over time, is an open table format rather than a bespoke per-site database — Apache Iceberg on AWS S3 Tables is the pattern this brand has argued for elsewhere; the Apache Iceberg for Industrial OT series works through why that specific combination holds up for OT-adjacent telemetry. Nothing in the current desk build uses it yet — this is where the pattern goes next, not what is running today.

The Honest Edges: What Runs Today vs. What the Design Promises#

A “harness over model” architecture earns credibility by naming exactly where the running system and the target design diverge — not as a disclaimer buried in a footnote, but as the single block that makes every other claim in this essay checkable.

• Two hardware tiers, not one. An approximately 8 GB, CPU-bound vision box sits at each cell — frame capture and zone check, no model weights resident. Separately, one fleet-shared, approximately $4,000 decision node carries the on-box model(s), whose resident weights plus working memory call for a heavier unified-memory configuration than the vision box. Mixture-of-experts architecture saves inference compute, not memory footprint — do not let one spec or one price stand in for both roles.
• An on-box vision model reads each bin today. The read runs on a local vision-language model (Qwen3-VL-8B) that looks at each bin’s rectified crop and returns a fill fraction, loopback-only, no cloud. An earlier HSV color-threshold approach was dropped — it was not robust across changing shop-floor lighting. A lighter dedicated detector remains a possible optimization, not what runs today.
• SQLite-graph is the default, not a database cluster. The provenance store is pluggable; the default ships on SQLite-graph specifically because it adds zero extra network service. A clustered graph database is the scale option for larger fleets, not the baseline this cost model assumes.
• The 1:20 node-to-cell ratio is a target the fleet build tests, not a measured result. It is throughput-credible for independent bin arrivals at low utilization. The failure mode it has not yet been tested against is correlated bursts — every cell needing a decision at once, such as a shift change — and that is exactly what a multi-cell fleet build is for.

None of this changes the $40.50/bin figure — every one of these properties is already priced into the model in Part 5. It changes what you should expect to find if you open the bench today versus what the roadmap is promising for next quarter.

An Open Question — For Everyone in This Market#

AI-native replenishment is not a slide about the future. It is a mini-PC on a desk, watching two printed cards, making a call that a cloud model would also make, and writing down exactly why. The sensor-per-bin model was a reasonable answer when intelligence was expensive and had to live centrally, reading cheap dumb sensors at the edge. That premise inverted. Intelligence got cheap enough to sit at the edge, unattended, in a box that costs less than the SaaS bill it replaces.

The question worth asking is not whether an AI-native cell can make the same replenishment call — it already does, at cloud-model parity, on this bench. The more interesting question is one the whole market shares, vendors included: when a $0.50 printed card and a $4,000 shared brain can make the same replenishment call, where does the intelligence in a replenishment system best live — and what should it cost? The vendors whose published pricing anchored this comparison know their segment far better than a bench rig does; I would genuinely like to compare notes. If you build, buy, or operate these systems, this measurement is an opening position, not a verdict.

The .systems companion to this essay — the capital-decision lens on this same inversion — is The Ratio I Am Betting the Fleet On. That is a different companion from The $40 Bin Was a Capital Decision, which is Part-5-specific rather than tied to this manifesto.

The mechanism-by-mechanism detail behind every claim in this essay — the topology, the sensor, the duty cycle, the provenance harness, and the full cost model — is The Factory That Pays for Itself, starting at Part 1: One Camera, Twenty Bins.