Skip to main content

AI agents

AI Agent for Warehouse Operations: How We Built Ware

How we built Ware: a live 3D warehouse and press shop running the real orders of real days, with an AI agent on duty that handles incidents within set rules and asks the right manager before it spends.

11 min read
real days, every order at its recorded time, from open data
3
orders shipped on the peak day: nobody acting, then Ware on duty
34 → 52
real AI cost of that whole day, with Claude Haiku 5.5
$0.76
checks every action passes, from a person or the agent
7

"Every exception is someone on the phone." Orders arrive for stock nobody is making. A press breaks down. Material runs short. A die starts failing parts. In a warehouse or a factory, each of these lands on a person who has to find out what happened, work out what it affects and decide what to do, under a deadline. Ware is our answer: a live 3D warehouse and press shop working through the real orders of a real day, with an AI agent on duty that handles the incidents within the rules you set and asks the right manager before anything costs money.

Ware is our own product, not client work. We built it to show what a governed AI agent looks like when it is allowed to act: every request goes through one gate, reads pass, writes wait. It went to Production at ware.devs-core.com on 27 October 2026. The orders and machine failure rates are real open data; the plant, its people and its money are simulated; the AI usage is real.

At a glance

  • What it is: a live 3D warehouse and press shop running three real days, an AI agent on duty for the day, and Ask Ware, which answers questions from the operation's own records
  • Built by: Devs Core, as our own product
  • The agent's limits: releases and re-sequences work on its own; spending, stopping a press, large work orders and anything a person just decided go to the Production, Logistics, Maintenance or Quality Manager
  • The data: every order of three real days, and the failure rates of real machines, from two open datasets (credited below)
  • Result: on the peak day, 52 of 59 orders shipped with Ware on duty, against 34 with nobody acting
  • Cost: $0.76 of real AI for that whole day with Claude Haiku 5.5, capped at $0.50 per incident and $40 a day
  • Stack: Next.js 16, React 19, TypeScript, three.js with React Three Fiber, a deterministic engine in a Web Worker, the Vercel AI SDK through the Vercel AI Gateway, Neon Postgres, Vitest and Playwright
  • Try it: run a real day at ware.devs-core.com, or read the Ware product page

Why we built Ware: operations fail on the exceptions

Operations don't fail on the plan. They fail on the exceptions, and the information needed to fix them is spread across the ERP, the floor, spreadsheets and phone calls. By the time the picture is clear, the truck has gone. We hear the same sentences on discovery calls:

  • "The books and the floor disagree, and you find out at month end." Stock is right in one place and wrong in three.
  • "The plan never survives the morning." Orders arrive for products nobody planned to make, and the line is already full.
  • "Our AI pilot worked in the demo and stalled." AI can read the data, but nobody lets it write, because nothing shows the person who signs that it can't go wrong silently.

That last one is the real blocker. Gartner expects over 40% of agentic AI projects to be cancelled by the end of 2027, and in our experience the cause is rarely the model. It's that nobody can prove what the agent is allowed to do, so it never gets permission to do anything.

We built Ware to show the alternative: an AI agent that handles the exceptions inside the rules, a person who keeps every decision that matters, and every action accounted for.

Ware's pick and pack area in 3D: packers at their benches, parcels on the belts and the sorter beyond

The data: three real days

Ware plays real days from two open datasets, both under CC BY 4.0:

  • Orders: the UCI Online Retail dataset, the real orders of a UK giftware wholesaler from December 2010 to December 2011. Ware takes its tinplate signs, storage tins and zinc homeware, and replays every order of the day at its recorded time, with its order number, customer number and quantities.
  • Machine failures: the Bosch CNC Machining dataset, good and bad runs of three real milling machines. Their bad-run rates become the bad-batch rates of Press 1 (6.6%), Press 2 (4.2%) and inspection (1.7%).

Three days come from that data:

  • Peak day (Monday 5 December 2011): the busiest of the source's 305 selling days for these products: 59 orders, 1,925 units, 76 products.
  • Big order day (Tuesday 20 September 2011): an ordinary day until one customer places four large orders for 6,408 units, far beyond what the press line makes in a day.
  • Quality crisis: the peak day's orders, with the presses failing at the rates the real machines recorded in their worst month, February 2019: about one in four on Press 1 and nearly one in two on Press 2.

What the data doesn't hold (bills of materials, opening stock, the morning plan, layout, staffing, repair times, prices) we estimated, and the app lists every estimate in its Data panel next to each source and its licence.

Ware's Data panel: the real day, both sources with their licence, the machines' failure rates and everything estimated

How Ware works: one gate, reads pass, writes wait

The agent and the managers sit on one side; the operation's records sit on the other. Nothing reaches a record except through the operation's rules.

Every action passes the same seven checks

There is one write path, for people and the agent alike. A click in the interface, a tool call from the agent and a confirmed request in Ask Ware all arrive as the same command, and each one passes seven checks in a single database transaction:

  1. Validate: a known action with valid arguments
  2. Lock: one writer at a time on the session
  3. Once: a repeated request returns the first result instead of running twice
  4. Fresh: refused if the floor changed since the plan was made
  5. Policy: inside the agent's authority, scope and budget
  6. Approve: held for the right manager if it is beyond the agent's delegation
  7. Log: executed and written to the audit log

The simulation finds the incidents; the agent works them

The model never decides what counts as a problem. The deterministic simulation finds four kinds of incident, and Ware works each one as a short mission:

Incident (found by the engine) Ware may do alone Needs a manager
Orders waiting for stock that nobody is making Release a work order of up to 120 units, run it next Production Manager: a larger work order
A work order stuck for material Hold it so the next one runs, re-sequence Logistics Manager: an express delivery
A press, inspection or pack station broken down (A technician is sent automatically) Maintenance Manager: a contractor call-out
A press failing at least 25% of its last 20 parts Hold work, re-sequence Quality Manager: a 40-minute die change

Ware never undoes a person: changing anything a person acted on in the last simulated hour needs that action's manager. The model only proposes tool calls; a governed command service on the server decides what is allowed, sends the rest to the right manager, executes it on the engine and writes the audit log.

The engine, not the model, decides whether an incident is handled. A model may claim "handled". Ware accepts it only when the simulation shows it: work released or set to run next for every short product, a contractor on the breakdown, express material on its way, a die change under way, or the right manager asked. A claim the engine does not support is refused.

You stay in charge

Every control stays with the visitor while Ware works: release, hold or run a work order next, move a worker, cause a fault. "I've got this" takes one incident from Ware; Pause holds it while the day runs; Stop takes it off duty and voids its pending requests. The visitor decides each request as the manager it is routed to.

Deterministic by design

Same seed, same commands, same day, every time. The engine advances in fixed 0.25-second steps of simulated time, its randomness comes from a seeded generator stored in the state, and even sine and cosine are our own implementations, because browsers and Node differ in the last bit and that drifted copies apart. That's what lets the visitor's browser play the day while the server follows it to the same tick and compares state hashes, and lets any run be replayed and audited.

Where it sits on the Autonomy Ladder

Ware runs two rungs of the Autonomy Ladder at once. Work the managers delegate (releasing work up to 120 units, running it next, holding it) the agent does on its own within its limits, and every action is logged. Anything that spends, stops a press or goes beyond the delegation stays at L2 Approve: the right manager approves that exact action, at that cost, before it runs.

What Ware is: a complete operation, live in 3D

Receiving, high-bay storage with stacker cranes, a robot field, the press line, pick and pack, a sorter and outbound docks, all driven by one deterministic simulation. Click any press, pallet, person or order to see what it is doing and why.

The press line in Ware: Press 1 selected, with its status, output and the actions a person can take

  • One source of truth. Every figure on screen comes from the model. Nothing is invented for display.
  • Stock that reconciles. On hand = available + reserved + on hold + not yet usable, in units.
  • Live, not recorded. Run a day in a private sandbox, or as a live day on the server: a refresh carries on where you were, and every action runs on the server at the moment you took it.
  • Break it, safely. Cause a press fault, a crane fault or a quality failure, and watch the automatic rules and the agent respond.

The robot field in Ware: robots carry pods to the pick stations while the high bay and outbound docks run alongside

Ask Ware: answers from the records, and an honest "not available"

Ask what is happening and Ware looks it up in the live operation, then answers with the simulated time it describes and the records it relied on. Every number in an answer is checked against the data it read; a figure it can't trace is sent back once, then shown as unverified. Asked what the stock is worth, it says valuation isn't configured instead of inventing a number. "Do it" becomes a proposal, and nothing happens until you confirm it.

Ware on duty, in one logged run

From a whole-day run of the peak day with Claude Haiku 5.5, a stand-in manager approving each request:

  • 09:08: inspection breaks down with a vision camera fault: a 20-minute repair.
  • 09:10: Ware asks the Maintenance Manager for a contractor call-out (250, simulated). Spending is the manager's decision.
  • 09:10: approved; the repair is cut to about 10 minutes.
  • 10:02: Press 2 breaks down with a light curtain fault; by 10:05 a contractor call-out is approved again.
  • Through the day: orders go short of products nobody is making, and Ware releases work for them and runs it next. Work over 120 units goes to the Production Manager.

The day's score: against the same day, untouched

At any point the visitor can see the day's score: orders shipped, on time and still short, units made and scrapped, against the same real day run by the engine with nobody acting, at the same simulated minute. It also counts Ware's incidents by outcome, the managers' decisions, the people's actions, the simulated spend and the real AI cost.

The day's score in Ware at 17:02 on the peak day: two more orders shipped than with nobody acting, after a visitor released work for waiting orders

How we tested it

  • 266 unit and integration tests pass, on real Postgres (PGlite) rather than mocks of the database, plus 76 of 76 recorded browser checks with the AI switched off. Tests that call live models run separately.
  • Whole real days with real models. Each of the three days, 07:00 to 20:00, with Ware on duty and a stand-in manager approving every request, with Claude Sonnet 5.5 and Claude Haiku 5.5.
  • Whole days with a scripted stand-in, at no cost. A scripted operator in place of the model runs the same days in about a minute each. It found why half of the incidents in the paid runs ended without a result (below), before we spent anything more.
  • Concurrency on the real database, from the first release and still in the suite: five identical requests at once were applied once; three concurrent spends against one budget reserved once; another session's approval was not found; a stale approval was refused; Stop racing six actions at once let none run after it.
  • Prompt injection, live, in the first release: instructions planted in a customer record and a hostile message claiming director authority changed nothing, and the agent couldn't approve its own request.
  • Failure modes: with the AI switched off, the budget used up or every provider down, the day runs on, visitors get a plain message, and nothing is charged.

The results

Measured on whole real days with real models, a stand-in manager approving every request:

Day (orders shipped / still short) Nobody acting Ware on duty, Haiku 5.5 Ware on duty, Sonnet 5.5
Peak day 34 / 25 52 / 7 ($0.76) 49 / 9 ($4.03)
Quality crisis 33 / 25 46 / 12 ($0.94) 48 / 8 ($3.07)
Big order day 18 / 18 16 / 20 ($1.54) 16 / 19 ($4.69)
  • On the peak day and the quality crisis, Ware ships far more orders. It works the shortages the morning plan didn't cover and gets the breakdowns repaired sooner.
  • On the big order day, it doesn't help. One customer's 6,408 units need days of press time; no order of Ware's changes that, and its priorities trade one ordinary order for another. The score shows it plainly.
  • Haiku did about as well as Sonnet, for a fifth to a third of the cost.

In those runs Ware took 533 to 724 model steps a day, and about half of the incidents ended without a result. The scripted stand-in showed why: work Ware set to run next queued behind its own earlier work, out of reach, so the engine could never accept "handled", and Ware kept releasing more. Fixing that rule, and closing an incident as soon as the engine shows it handled, cut the peak day from 386 steps to 64 on the scripted run, with every incident ending within its limit. We haven't re-measured the cost with a real model since.

What it doesn't do yet

  • Real-model cost after the fix isn't measured yet. The step count fell about six-fold on the scripted runs; a paid run will confirm what that does to the bill.
  • Frame rates on real devices aren't measured yet. Our build machine renders 3D on the CPU, so the target of 55 frames a second on an M-series MacBook still has to be checked on the device.
  • It's a simulation of the plant. The orders and failure rates are real; the plant, its stock and its people are not. In your operation, the same pattern sits on your ERP, WMS and production systems through an access layer.

What we'd do again

  • Put every write through one service. People, the agent and Ask Ware share one path and seven checks, so there is one place to prove the rules hold.
  • Let the engine find the problems and judge the outcome. The model never decides what counts as an incident, and its claim that it fixed one is not evidence; the simulation's state is.
  • Use real data. Real days showed at once the problem a planned demonstration would hide: a line that can't make everything, and an agent that has to choose.
  • Tune with a free stand-in before paying for a model. The scripted operator found in a minute what transcripts of paid runs blamed on the model.
  • Make the simulation deterministic from day one. Replaying a run, following the browser on the server and auditing it all depend on it, and it is very hard to add later.

Frequently asked questions

What is Ware?

Ware is a live 3D warehouse and press shop, built by Devs Core, that works through the real orders of a real day with an AI agent on duty. The agent handles the incidents it has been delegated and asks the right manager before anything costs money, stops a press or goes beyond its limits. It runs at ware.devs-core.com.

Is the data real?

Real order and failure data, simulated plant. Every order arrives at its recorded time, and the presses fail at the rates real machines recorded, both from open datasets credited above. The plant, its stock, its people and its money are simulated, and every estimate is listed in the app.

How can an AI agent handle factory exceptions safely?

Give it one governed write path, and let the engine, not the model, decide what counts as a problem and when it is solved. In Ware, every action passes seven checks (validate, lock, once, fresh, policy, approve, log) in one transaction, delegated work runs within a budget and scope, anything beyond it goes to the right manager, and every decision is written to an audit log.

What does it cost to run an AI agent on duty for a day?

The peak day cost $0.76 of real AI with Claude Haiku 5.5 and $4.03 with Claude Sonnet 5.5, measured before a fix that cut the steps about six-fold. Every call is reserved before it runs, capped at $0.50 per incident and $40 a day, and reconciled against the AI Gateway's bill.

Can prompt injection make the agent break the rules?

You can make the model say things; you can't make it do things the rules forbid. Ware's defence is structural: tool calls become commands that pass the same policy checks as a person's, the agent can't approve its own request, and held stock can never be released by the agent.

Could this work with our own ERP or WMS?

Yes, with the same pattern: read access to your systems, write operations behind a governed command service with approvals and an audit log, and autonomy extended one rung at a time. Ware shows that pattern on real orders in a simulated plant; in your business it connects to the systems you already run.


Want an agent like Ware working on your own floor? Book a call, read how we build human-in-the-loop agents, or see how we approach AI agent development for manufacturing and distribution and logistics.

One email when we publish something worth your time

No cadence, no drip sequence. We write when we have learned something running agents in production, which is not weekly.