The Arbitrage Window
Agentic commerce is rebuilding itself from primitives up
Amazon's internal taxonomy for AI agents reveals what most brands are still rebuilding from scratch every quarter.
1
Internal taxonomy converged on after repeated primitive rebuilds
Source: AWS Machine Learning Blog
Amazon's engineering team just published something more useful than a product announcement. Building Amazon Quick, their internal AI agent system, the team kept watching the same thing happen: agents grew from answering questions to taking actions, and the same primitives kept getting rebuilt under different names. So they stopped and converged on a shared taxonomy. That is probably the most honest sentence any major platform has published about agentic AI this year.
The duplication problem most teams won't name
If you have more than two people building AI agents inside your commerce org right now, you almost certainly have this problem. One team builds a 'task router.' Another builds a 'decision dispatcher.' A third builds an 'intent classifier.' They are, in most cases, the same thing. The token cost of running them separately is real. The latency penalty compounds. The inference overhead accumulates. And when you try to audit which agent is responsible for a bad recommendation or a mispriced SKU, the lack of shared vocabulary makes root cause nearly impossible.
This is not a startup problem. Amazon encountered it at scale building Quick, an internal tool presumably staffed by engineers who know what they are doing. The lesson is structural: agentic systems, left ungoverned, generate architectural debt faster than they generate business value.
What a primitive taxonomy actually buys you
A primitive is the smallest reusable unit of agent behavior. Think of it roughly like a function in a codebase. Memory retrieval is a primitive. Tool invocation is a primitive. State handoff between agents is a primitive. When you name these consistently, you get three things your scattered agent projects probably lack: shared evals, predictable latency budgets, and vendor-portable components. That last one matters more than most brands calibrate for. If your agent logic is entangled with a single vendor's orchestration layer, you do not have an agent strategy. You have vendor lock-in wearing an AI costume.
The Amazon Quick post is not a blueprint you can copy directly. It describes an internal system built for specific constraints you do not share. But the structural insight transfers cleanly. Wherever your team is building agents, the question is whether they are naming components consistently enough that a new engineer, six months from now, can reason about the system without reading every commit log.
Where commerce teams are most exposed
Three areas show up repeatedly in commerce AI builds where primitive drift causes the most damage. First: personalization agents. These tend to get rebuilt every time a new model is available because the prior version's logic is undocumented. Second: inventory and pricing decision agents. These carry real financial risk if they hallucinate or inherit stale state from an upstream process. Third: customer service routing. This one is probably the most politically fragile because when it fails, the failure is visible to a human on the other end of a chat window.
In each of these cases, the fix is not more AI. It is a naming convention, an ownership map, and a decision about which primitives are shared infrastructure versus team-specific. That is unglamorous work. It will not appear in a vendor demo. But it is what separates brands running a sustainable agent program from brands running a series of expensive experiments that do not accumulate.
Three questions to pressure-test
Could any engineer on your team, without asking around, name every AI agent currently running in production and what primitive each one depends on? If a single vendor's orchestration layer went down tonight, which of your agent workflows would stop, and would you know within the hour? When your agents produce a bad output, do your evals tell you whether the failure came from memory retrieval, tool invocation, or state handoff, or do they just tell you the output was wrong? One uncertainty worth naming: a shared taxonomy only helps if you enforce it. The Amazon Quick team had the advantage of building one system end-to-end. If your agent work is distributed across five teams and three vendors, governance is harder than naming. What would change this view: evidence that open-weight models with stable tool-calling behavior make vendor-portable primitives easy enough to maintain without formal taxonomy. That evidence does not exist yet.
Get The Beacon. Free, every Friday.
You're on the list.
The next edition lands in your inbox on Friday.