On 17 November an engineer from APIbase asked, under our article about selling eSIMs to AI agents, what the kit does when an offer goes stale between the quote and the payment. An agent can ask for "3 GB in Japan", think for a while and pay a minute later. If the wholesale price moved in that minute, someone loses.

We added quoted prices that hold for ten minutes. A day later he asked where ten minutes came from. The honest answer was: nowhere. We picked it. This post is what we found when we went looking for the data.

A price an agent can come back to

Every offer the kit's seller node quotes carries a quote_token and a price_valid_until. Our reference node at modelmarket.dev runs in demo mode (it quotes but sells nothing), so you can see one:

curl -s -X POST https://modelmarket.dev/providers/esim/quote \ -H 'content-type: application/json' -d '{"country":"JP","limit":1}' 

Shortened answer, 18 November 2026, 17:05 UTC:

{ "offer_id": "JP_0.1_7", "name": "Japan 100MB 7Days", "price": { "usd": "1.30", "currency": "USDC" }, "quote_token": "q1.1795022124.130.ewIamkxcbMnwfA1CNu4w-0Ajw_W5FfGgJUIPqrGDyK0", "price_valid_until": "2026-11-18T17:15:24.000Z" } 

The token reads q1.<valid until>.<price in cents>.<HMAC>. The node signs the offer, the price and the expiry with a key derived from its own secret, so it keeps no table of quotes, and a buyer cannot change the price, move it to another plan or stretch the time. What an order with that token pays is one small function in rails/src/quote.js (excerpt, esim-rails 0.5.1):

export function priceForQuote(offer, quote, nowMs) { const current = centsOf(offer.price.usd); if (!quote || quote.cents >= current) return { kind: "current", cents: current }; if (nowMs > quote.untilMs) return { kind: "expired", cents: current }; const cost = Number(offer._cost_usd); if (!(cost > 0) || quote.cents < costCents(cost)) return { kind: "below_cost", cents: current }; return { kind: "honoured", cents: quote.cents }; } 

If the price fell, the buyer pays the lower one. If it rose, the quoted price holds for the ten minutes, unless it is now below the seller's wholesale cost. Everything else ends in a 409 that carries current_offer: the offer as it is now, with a fresh token, so the agent can order it without asking for quotes again.

Flow of an order that brings a quote token. Price now at or below the quoted price: pays today's price. Price rose and the window passed: 409 quote_expired with current_offer. Price rose inside the window: if the quoted price is still at or above the wholesale cost, it pays the quoted price, otherwise 409 quote_below_cost with current_offer. Then 402 Payment Required, the agent signs, and the node orders from the wholesaler with the cost it expects: the wholesaler accepts, the eSIM is delivered and the payment settles; or it refuses because its cost moved after the node's last read, nothing is charged, the catalogue is read again and the answer is 409 with current_offer.

None of that says whether ten minutes is long or short. For that you need to know how wholesale prices actually move.

Thirty days of a catalogue nobody kept

The reference node reads the live eSIM Access catalogue and keeps only its latest copy, catalog-snapshot.json. We had never stored the history. But the host is backed up every night, and /opt is in the backup, so every nightly archive holds that day's copy. Eighteen archives had it: 19 October to 18 November, a few days apart until 5 November, daily after that, with 1,725 to 1,823 plans each.

We compared each copy with the one before, plan by plan: the wholesale cost, the data and the days.

Bar chart of plans whose wholesale price changed since the previous catalogue copy, 19 October to 18 November 2026. No changes from 19 October to 5 November. Then cuts on 6 November (59 plans), 8 November (16), 9 November (84), 14 November (17), 15 November (111), 16 November (45 cuts and 46 rises) and 18 November (24). All rises are on 16 November.

What the copies show:

  • 402 price changes on 377 of about 1,800 plans in 30 days. Nothing else moved: no plan changed its data or days, 102 plans appeared and 7 disappeared.
  • Nothing for 17 days, then batches. No price changed between the copies of 19 October and 5 November. Of the 13 daily intervals after that, 7 brought a batch of 16 to 111 plans, and the other 6 brought nothing.
  • Mostly cuts. 356 of the 402 changes were cuts, median −14.3%.
  • All 46 rises in one update, between the copies of 15 November 03:17 UTC and 16 November 02:54 UTC: median +25.2%, largest +88.2%, in 16 countries and territories and two regional plans (North and South America). Japan was one of them: seven plans, +14% to +59%, the 20 GB, 30-day plan +40%.

Histogram of the size of each price change. Cuts, 356 of them, from about −69% to about −1%, most between −35% and −5%, median −14.3%. Rises, 46, from about +10% to +88%, median +25.2%.

So the catalogue does not drift. It sits still, and then a batch changes dozens of plans at once.

One batch, at 15-minute resolution

A daily copy cannot tell you at what hour a batch lands, and that is the part that matters for a ten-minute window. On 18 November at 14:29 UTC we started a recorder on the same host. Every five minutes it asks the node for one quote, the node reads the catalogue again whenever its copy is 15 minutes old, and the recorder logs every plan whose cost changed since the previous read.

The first batch came two hours later.

The first day of 15-minute reads, 18 November 2026: reads at 14:29, 14:44, 14:59, 15:14, 15:29, 15:44, 15:59 and 16:14 changed nothing; the read at 16:30 found 17 plans cut at once; the read at 16:45 changed nothing.

Between the 16:14 and 16:30 reads, 17 plans were cut together: Anguilla, Barbados, Bermuda, Guadeloupe, Jamaica, Saint Kitts and Nevis, Saint Lucia, Mexico, New Caledonia, Nauru, French Polynesia, Tonga, Trinidad and Tobago, from −1.3% to −18.6%. One batch in one quarter of an hour, nothing before or after.

What that means for a ten-minute window

A shorter window would not have caught a slow drift, because there is none. The risk is a batch landing inside someone's window. A rough way to size it, until the recorder has weeks instead of hours: if a batch lands once on an update day at a random minute, a ten-minute window overlaps it with a chance of about 10 in 1,440, roughly 0.7%. Seven of the 13 daily intervals had a batch, so that is about 0.4% of windows, and a batch touched 1% to 6% of the plans. For any single quote that is rare. For the plans in a batch, it is everyone who quoted them in those ten minutes at once.

What decides how that ends is not the window but the margin. A quote is honoured only while the quoted price is still at or above the new wholesale cost, which means the rise has to stay within the seller's margin:

  • with the kit's default pricing (MARGIN_PCT=100, at least $1 above cost), all 46 rises of 16 November would have been honoured, the largest being +88.2%;
  • a seller with a 20% margin would have seen 36 of those 46 rises push the quoted price under cost, and each of those orders would have ended in 409 quote_below_cost with a fresh offer.

The node's own view can also be older than the window: it reads the catalogue when its copy is 15 minutes old. That gap does not cost money. The node sends the wholesaler the cost it expects, the wholesaler refuses a plan whose price changed, and the node settles a payment only after the eSIM exists. A stale view ends in a 409 and an immediate catalogue read, not in a sale below cost.

What the buyer does with the 409

Since esim-rails 0.5.1 the kit's example buyer treats a refusal that charged nothing as news. It replaces that seller's offer with current_offer and orders the cheapest offer it now knows within --max-usd: the same seller at the new price, or another seller whose quote is still valid. Our own agent, ARGUS, does not switch by itself: when the new price is above a comparable offer from another seller, it buys nothing and names that offer (cheaper_elsewhere), because the owner approved one seller at one price.

The tests run two kit nodes behind a stub hub and move the wholesale price between the quote and the order. With Node 22:

git clone --depth 1 https://github.com/alexar76/esim-operator-kit cd esim-operator-kit/rails && npm ci && node --test test/agent-buy.test.js 
ok 1 - agent-buy sends the quote's token, takes the fresh offer a refused order brings, and pays the kept price ok 2 - agent-buy goes to another seller whose quote still holds when the refused seller's price rose above it ok 3 - agent-buy stays with the refused seller when the price it keeps is still the cheapest ok 4 - agent-buy signs nothing for a seller that asks more than its quote, and buys the cheapest offer left ok 5 - agent-buy pays a seller's new price when no other offer is cheaper, and never above --max-usd # pass 5 

What we don't know yet

  • One supplier. These are eSIM Access's wholesale costs as one node read them. Other suppliers may update one plan at a time, or every hour.
  • Costs, not orders. The node is in demo mode. The numbers are catalogue prices, not prices anyone paid.
  • The hour. Thirty days of daily copies and one afternoon of 15-minute reads cannot say whether batches cluster at a time of day a seller could plan around, or how a batch spreads over an hour. The recorder keeps running, and in a few weeks we can answer whether ten minutes is about right.

If you sell on top of a wholesaler: do your supplier's prices move in batches like this? The conversation that started this is under the first eSIM article.

We build the eSIM operator kit and run the modelmarket.dev hub. AI assistance was used for the analysis, the figures and this article. The numbers come from the reference node's catalogue copies and the recorder of 18 November 2026; the commands above were run as printed that day.