When teams talk about deploying AI agents in production, the conversation tends to gravitate toward models — which one, how big, how much it costs. What the Maersk shipping experience suggests is that the model is almost beside the point. The hard work lives elsewhere: in the organizational knowledge that has to be translated before any agent can act on it, and in the feedback infrastructure that has to be built before improvement becomes possible at all.
The Problem Is the Knowledge, Not the Code
Global shipping runs on standard operating procedures — SOPs — that describe what to do when a container is late, a customs clearance fails, or a vessel misses a connection. The happy path is already automated. What remains is the long tail of exceptions: thousands of edge cases, each with its own set of rules that vary by country, carrier, and port.
The trouble is that existing SOPs were written for humans. They read like step-by-step guides for navigating a screen: “click here, then here, then call this number.” An experienced operator reads an SOP and fills in enormous amounts of unstated context — what counts as a valid result, what to do when a system is down, how to confirm the action actually worked. A language model has none of that context unless it is explicitly provided.
This is what the Maersk team calls “tribal dungeons”: the gap between what an expert knows when they read an instruction and what a model needs to be told. Closing that gap requires rewriting SOPs from scratch in a form that includes preconditions, decision points, backend calls, validation steps, recovery paths, and evidence of successful execution. The SOP corpus at Maersk ended up roughly twenty times larger than the execution layer itself — a 20-to-1 ratio that gives a concrete sense of how much translation work the model-readable representation requires.
The Loop That Actually Builds Quality
The system runs over 200 concurrent agent instances in production, handling exceptions across the globe with latencies that stretch to ten minutes — not because the agent is slow, but because the legacy backend systems it calls are. That part scales. What does not scale automatically is quality.
Quality at Maersk is not built by switching to a more capable model or by tuning prompts until something feels better. It is built by replaying real failure examples — with writes disabled so production stays safe — and checking whether behavior actually improved. Failures are clustered rather than surfaced as a raw log, so the team sees patterns instead of noise. Those clusters are turned into priority matrices: heatmaps where each red cell represents a category of failure. Moving one red cell to green typically takes one to two months of team effort. Over nine months, the team accumulated more than 100,000 corrections.
The correction only counts, though, when it becomes an executable change in the system. The distinction matters: a team can accumulate observations forever without improving anything. What turns observation into improvement is the discipline to close the loop — from trace, to cluster, to priority, to fix, to replay, to verify.
Safety as Constraint, Not Afterthought
The harness around the agent is designed to make certain mistakes structurally impossible, not merely unlikely. A wrong workflow selection triggers a classifier evaluation before any action is taken. A write to a wrong destination hits a gate. A step that requires human judgment routes to manual review. The engineering emphasis is on auditable handoffs and bounded execution, not on giving the agent more autonomy.
This framing — guardrails as constraint rather than safety net — is worth dwelling on. In practice it means the agent cannot accidentally execute on a wrong assumption because the path to doing so is closed off. The agent operates within a cage; the cage is not a limitation, it is the design.
What Compounds Over Time
The end state of this kind of system is not a capable agent. It is an adaptive architecture that learns from what works and folds successful patterns back into code. Action sequences that prove reliable get aggregated into composite tools, which become reusable by other agents and rollable out across hundreds of countries at once. The knowledge that was once locked in tribal dungeons gradually becomes codified, portable, and composable.
The five-move blueprint that emerges from the Maersk experience is not specific to shipping: make work representable, make execution bounded, make behavior observable, make correction cheap, make improvement compound. None of those steps involves picking a better model. All of them involve building better infrastructure around whatever model is running.
That shift in emphasis — from model capability to surrounding methodology — is likely where the practice of deploying agents at scale will continue to develop over the next few years. The organizations that figure out the translation and feedback problems will pull ahead not because they have access to different models, but because they have built the machinery to learn faster from what goes wrong.
Text summarized and optimized using Anthropic’s models and reviewed by a human.