AI made it cheap to generate something new: a function, an answer, another agent. It did not make it cheap to own what you just created.
That gap showed up in three talks this week. A Maersk engineer, an IBM explainer, and a talk on agents that cannot work together all point to the same pattern. Whether you run a bank, an insurer, a hotel, a telecom network, or an aerospace program, someone still has to be accountable for the code, for what an agent says, and for how those agents pass work to each other.
| What got cheap | What did not | Where we start |
|---|---|---|
| Generating code | Owning and checking it over time | A Retainer |
| Producing an answer | Seeing why it was given | The CAIO program |
| Standing up another agent | Making agents work together | A diagnostic |
Cheap code is not cheap ownership
At AI Engineer on November 11, 2026, Dmitry Buykin of Maersk put it plainly. Coding agents made code cheap. They made entropy even cheaper: more change than anyone can check. The talk title went further. Agents made code free. Maintaining it did not get cheaper.
His warning is practical. A rewrite is easy. The hard part is knowing what has to survive it. Tests can look fine while two sources of truth disagree and nothing throws an error. A dashboard can stay green while one person can no longer read every change the agents made. Left alone, he said, an agent keeps adding conditions until today’s tasks pass.
For a bank, an insurer, a telecom operator, or an aerospace program, that is not a tooling inconvenience. Those systems have to live for years. Every generated line still needs a design it fits, tests that prove it, and someone accountable for it. That is architecture work. It is the case for a Retainer after a Baseline engagement: an ongoing owner for the system, not a one-time burst of generated code.
Agents Made Code Free. Maintaining It Didn’t Get Cheaper.
If you cannot see the answer, you cannot stand behind it
On November 12, 2026, IBM’s Matt Aiken opened with a simple gap. An AI agent can read every runbook, support ticket, and architectural diagram, and still be unable to answer one critical question: what is the system doing right now?
An agent needs two kinds of context. Retrieval grounds it in documented knowledge: how the system is supposed to work, which procedures apply, and whether a similar symptom has been seen before. Observability supplies live evidence: metrics, logs, traces, and recent changes. In his example, a slower balance inquiry on a mobile banking app looks like one action to the customer and a chain of systems to the operator. Documentation alone produces a generic checklist. Documentation plus live evidence produces something an operator can use: what changed, what may be affected, and where to look next.
He was careful about the limit. The result is not a magical diagnosis. The operator remains in control. The agent retrieves, summarizes, and connects. The human validates the evidence and decides what to do.
That is the same ownership question our CAIO program is built to answer, and not only in operations. If you cannot see what your AI agent looked at and why it answered the way it did, you cannot stand behind the answer. For a hotel, a bank, an insurer, a hospital, or a law firm, a wrong answer about a rate, a fee, a claim, or a record is not a small error. Grounding and observability are not extras. They are how a regulated business keeps ownership of what its agents say, and when those agents should hand the work to a person.
Why AI Agents Need RAG + Observability
Most companies are not short on agents
Justin Schroeder, speaking at AI Engineer, observed that everybody is building agents. Teams are not waiting for a single shared layer. They are standing up their own.
His warning was sharp: if an agent can do anything, it might do anything. Businesses want control, reliable execution, and a scope they can trust. The problem is what happens next. One team builds a custom system, another team builds a different one, and those agents cannot be shared or combined in any simple way. Tools and skill files have started to standardize. The agents themselves are still one-offs. As he put it, the idea that one business will create hundreds of its own agents and have them work together is a little bit silly.
You do not need a new standard to see the business problem. A telecom group, a hotel brand, or a bank often has agents in customer service, in operations, and in risk, none of which share rules for data or handoffs. Most companies are not short on AI agents. They are short on agents that work together. A diagnostic maps what you already have before you build more.
Every Company Is Building Agents That Can’t Work Together
Start with ownership, not with another agent
The three talks point to one move. Before you generate the next batch of code, the next customer-facing agent, or the next departmental tool, get an honest picture of what you already own.
A diagnostic is built to do that work: what was generated, what still has an owner, what you can see an agent do, and where handoffs break. From there, a Baseline engagement and a Retainer put ongoing design, tests, and accountability around the code. The CAIO program is built to put ownership in place for what agents say, what data they use, and when they hand off to a person.

