Two agents fighting over the same pump: whose command counts?

Let's first look at a scenario—it happens on the shop floor, not in a PPT.

A vibration sensor is installed on a main feedwater pump. An asset performance management agent detected early micro-friction in the bearing from telemetry data and determined that the pump would not last until the next major overhaul. It therefore automatically issued a script to reduce the pump load by 30%, allowing it to run steadily until the weekend maintenance shift.

Almost at the same second, the supply chain fulfillment agent on the ERP side was reading the spot market. Demand had suddenly risen, and delaying this batch of orders on hand would incur heavy penalties. It updated the execution schedule and ordered the production line to max out capacity—the instruction was sent to exactly the same pump, requiring 105%.

One pushes it down by 30%, the other pushes it up to 105%. No one is causing trouble; both agents are faithfully executing their own set of KPIs.

On November 16, Colin Masson, ARC Advisory Group's director of industrial AI research, wrote about this scenario in a series of articles for Smart Industry and gave the phenomenon a name: the arbitration vacuum. The title of his article was blunt—"When Agents Collide: How to Stop the Algorithmic Civil War on the Shop Floor."

1. In software it is an infinite loop; on the shop floor it is water hammer

There is a detail in Masson's description worth pausing on: the two agents are waging an "invisible high-speed war" between the monitoring layers. The APM agent pushes the pump pressure back down, the ERP agent pushes it back up, and the control loop oscillates back and forth like this.

If this happens between two SaaS services, the worst outcome is CPU usage spiking, alarms ringing for a while, and someone restarting it. But when it happens in the physical world, oscillation means thermal cycling, cavitation, water hammer—it means equipment really will break.

He also took apart Silicon Valley's 'accountability after the fact' narrative along the way: in consumer software, when an algorithm goes wrong, lawyers negotiate compensation, PR issues apologies, and developers rush to patch overnight—the loop closes quickly. But on the factory floor, a payout cannot repair a ruptured distillation column, and a settlement agreement cannot undo a toxic leak. The physical world demands deterministic safeguards hard-coded in advance, not compensation in a courtroom.

This passage has a strange familiarity for people working in ERP. Every day we deal in systems with the problem of "two actions canceling each other out," only the consequences are much milder: inventory doesn't reconcile, aging is calculated incorrectly, costs are inflated. Mild, so it is tolerated; tolerated, so it is never fixed.

II. The most convenient wrong solution: invite an even larger model to serve as judge

When two agents are found fighting, most people's first reaction is, "Then add an overall orchestrator on top." Masson directly labels this approach an architectural anti-pattern: having a large model sit above the business agents and mediate disputes through conversation.

His judgment leaves no room for doubt—using probabilistic models to supervise other probabilistic models does not give you governance; it gives you compounded hallucinations, nondeterministic drift, and runaway token consumption. A referee who guesses, judging two players who guess, will not produce a more accurate result—only one that is harder to reproduce.

The alternative he proposes is a deterministic state machine: AWS Step Functions paired with Bedrock AgentCore, or IEC 61131-3 logic on an edge controller. It hard-codes several ironclad rules:

  • Safety and environmental interlocks always take precedence over commercial throughput.
  • The equipment reliability envelope has absolute veto power over the acceleration plan.
  • Once automated handling exceeds the preset financial or operational tolerances, the autonomous retraction protocol is triggered, freezing the equipment in the last known safe state and escalating to a human via a separate channel.

Note the weight of the third point. It acknowledges that automation will make mistakes, so it designs "how to retreat" in advance. This is harder to implement than the first two points, because the fallback often has to cross systems—freezing equipment is an OT matter, notifying people is an IT matter, and deciding who signs off is a business matter.

The article also did another calculation. Continuous-reasoning agents consume an order of magnitude more tokens than single-turn Q&A. If tied to cloud pay-as-you-go billing, software spending would change from a predictable subscription into a utility bill that fluctuates with production line activity. Add to that WAN round-trip latency of seconds to minutes, which is acceptable for quarterly demand forecasting but completely unworkable for millisecond-level control loops. His recommendation is to make inference a fixed asset: run open-source quantized models on local edge devices, with zero marginal token cost, sub-second response, and continued operation even when disconnected. The cloud is left for cross-site supply chain orchestration and periodic engineering design.

The word "autonomy" sounds liberating, but when it comes to engineering, it first means a priority list and a rollback path. Without these two, that is not autonomy—it is no one being accountable.

III. There are fights in Odoo too, just without bloodshed

Pull the lens back from the workshop to ERP. The same thing happens every day, only the consequence changes from "equipment breaking" to "numbers not adding up".

Take the most common example: a batch of goods has only 100 units, and two sales orders are confirmed at the same time, each requiring 80 units. Many customers think the system will block it, but in reality it won't. In Odoo, the reserved_quantity of stock.quant is gradually occupied during confirmation or shipping; at the moment the order is confirmed, the available quantity may not be validated; by the time picking occurs, it is discovered that there isn't enough stock, and by then the commitment to the customer has already been made.

Another one: two users, or one person plus one agent, simultaneously modify the same field of the same invoice. Odoo's write() directly issues an UPDATE, without version number comparison. Whoever submits later takes effect, and the interface will not prompt "this record was just modified by someone else." When a human operates, they can still rely on memory like "what I just saw was 100" to catch it, but agents don't even have that bit of memory between them.

There are also several that are more easily overlooked:

Conflict typePerformance in OdooDefault behaviorThe constraints that should be added
Two orders compete for the same batch of inventorystock.quant's reserved_quantity and free_qty are inconsistentNo error is reported upon confirmation, but there is a material shortage during picking.Reservation strategy + availability check
Concurrent modification of the same fieldsale.order / account.move same lineLater writes overwrite earlier writes, with no promptAdd pre-write validation for key fields, and record changes in chatter
Two automation rules conflict with each otherbase_automation triggers sequentiallyThe last one executed takes effectMerge into a single rule, or add a mutual exclusion check
Scheduled task overlapir.cron starts on timeIf the previous run didn't finish, another one will be started as wellLock or check the last run time first
External agent permission bypasssudo() or high-privilege API KeyRecord rules directly become invalidLow-privilege account + allowlisted server action

The most dangerous thing in this table is not the first row — it is the last row. The earlier kinds of conflict at least leave behind traces of writes with two different timestamps, which can be traced after the fact. But with an agent running under sudo(), once it has made its changes you cannot even find out "who made this change, and according to which rule."

IV. Boundaries should be written in code, not in policies

On November 16, Oracle released the notes for NetSuite 2026.2, and there is a detail in them that I think is more worth writing on the wall than most AI news.

NetSuite's bank statement import processes a maximum of 100 files per format configuration per single run. This limit applies to all file lists submitted by the plug-in in one run. Entries exceeding the limit are ignored, and no error is logged. Tracking submissions, carrying excess files over to subsequent runs, and preventing duplicate submissions are entirely the plug-in's responsibility.

Think about it from an accounting perspective: a single import run processed 130 files, the interface showed completion, and there was nothing unusual on the books. In reality, 30 statements were missing, and the month-end close proceeded as usual. This is not an AI problem, but once AI is brought in, this kind of batch operation will become much more frequent, and people won't watch logs the way they watch a screen.

A rule that can be added directly to the acceptance checklist: After any batch operation finishes, it must report four numbers—submitted count, successful count, failed count, and ignored count. If the four numbers don't add up, it doesn't count as finished. Silent truncation is far more dangerous than an error, because someone will handle an error, while silence only lets the records slowly drift off.

Following this line of thinking, in projects I usually require three tables, and keep them whether or not AI is integrated:

  • Priority table.When the rules of two departments collide, who has the final say. Safety and quality come before delivery, and delivery comes before cost—this order must be embedded in automation rules, not just left in meeting minutes. A priority that cannot be written into the system is as good as no priority.
  • Tolerance table. Which actions can be executed automatically, and what are the upper limits for amounts, quantities, and date offsets—beyond which human sign-off is required. Without tolerances, you either dare not let go of anything, or once you let go, you can't pull it back.
  • Withdrawal form. Which status an incorrect change is rolled back to, how long it can be withdrawn within, and who gets notified after withdrawal. The third column is the most frequently skipped, and also the one most likely to be asked about on the day something goes wrong.

None of the three tables is long; they can all fit on one page. The hard part isn't writing them—it's admitting that "our current system actually has no priorities; it's just whoever gets there first counts."

V. Set the rules first, then talk about letting go

Back to that pump. In Masson's proposal there is a term I haven't seen elsewhere—autonomous retraction protocol. It assumes automation will make mistakes, so it specifies in advance how to retreat after a mistake, where to retreat to, and who takes over.

This approach can be directly transplanted to ERP. When an agent changes the price on a purchase order, undo is not "delete and start over" but returning to the last approved version; when a batch of goods has been allocated to customer A, undo must also release the reservation relationship; when a delivery date is moved up by three days, undo needs to know who has already used up the production schedule during those three days.

Only if it can be rolled back can you dare to let go. And whether it can be rolled back depends on whether records were kept at the outset, whether there was a state machine, and whether you thought through "whom this action involves."

One-sentence summary: Before letting the agent take action, first write these three things into code: "who yields when there's a collision, how to roll back when it makes a mistake, and who signs off when limits are exceeded." Only after that is done should you put it on duty; then the mistakes it makes are bearable.

Those factories running out in front ultimately compete not on whose model is smarter, but on whose rules were written into a deterministic piece of logic earlier.

References: Smart Industry 《When agents clash: Stopping algorithmic civil war on the plant floor》 (Colin Masson, ARC Advisory Group, 2026-11-16); ERP News 《NetSuite Expands Bank Statement Imports and SuitePeople Workflows in November Update》 (2026-11-16). In this article, Odoo fields and behavior are based on Odoo 19/20; concurrency behavior is affected by deployment method and module configuration. Please verify in your own environment before implementation.

Zhongdi Information · Enterprise Management Digitalization Observation · Third-party disclosed figures have not been independently verified; please refer to the original text when citing.

关于我们

​我们致力于帮助中小企业实现数字化转型,我们的团队由一群充满激情和创新思维的专业人士组成,他们具备丰富的行业经验和技术专长。

扫一扫获取顾问以及手册

Sign in to leave a comment
Thirty-five thousand systems without door locks