Five Vendors, One Architecture: The Agent Control Plane Just Became a Product Category

Between May 13 and May 17, 2026, five vendors with no shared roadmap published the same architectural claim. Anthropic’s Claude Code engineering team wrote that “the harness matters as much as the model.” Intercom (now rebranded Fin) launched Fin Operator, an AI whose only job is supervising another AI, with a hard proposal gate before any change touches production. Docker shipped Custom MCP Catalogs and Profiles, distributing curated tool bundles via OCI artifacts. Nader Dabit published a six-hook lifecycle spec for deterministic agent control. Altimeter’s Jamin Ball put it on the spreadsheet: “If your product can’t be invoked as a skill from inside that agent surface, you’re functionally invisible.”

Five different categories. One architectural insight. The layer outside the model, hooks, skills, catalogs, proposal gates, marketplace governance, is where agent governance actually happens. We have argued this for months. This week it stopped being our thesis and became a product category being shipped.

The procurement spreadsheet just gained a row called “control plane.” Vendors are competing to own it.

Five Vendors, Five Layers, One Building

The pattern only reads clean when you stack the moves side by side. Each vendor is claiming a different floor of the same building.

Anthropic owns the harness layer. The Claude Code engineering team’s post on large codebases lays out the architecture under the model: pre-tool hooks, post-tool hooks, file system as memory, sub-agent dispatch, skill discovery. Their framing, the harness matters as much as the model, is an admission that performance comes from the scaffolding, not the weights. The model is a commodity once the harness is right.

Fin owns the supervisor layer. Brian Donohue, VP Product at Fin, is direct about it: “Right now, we’re taking zero risk on this. Fin cannot make any changes to the system without human approval. Nothing goes live until a human clicks apply.” Fin Operator runs Anthropic’s Claude rather than Fin’s own Apex models, because its job, supervising another agent, looks more like software engineering than customer support. Fin already resolves more than 2 million customer issues per week across 8,000 customers. The Operator beta started with roughly 200 of them. The proposal gate is the product.

Docker owns the distribution layer. Bobby House’s post is the most quietly important of the week: “As MCP adoption grows, the challenge isn’t access to tools, it’s coordination. Teams need a way to standardize what’s trusted and supported without constraining how individuals actually work.” Custom MCP Catalogs ship via OCI artifacts, the same supply chain that already moves container images. Profiles support unlimited named groupings, tool filtering, and cross-team sharing. Docker is putting MCP servers on the same trust rails enterprises already audit.

Nader Dabit owns the determinism layer. His Agent Hooks post is the cleanest engineering statement of the week: “Use prompts for guidance. Use hooks for behavior that should run every time.” He names six lifecycle events, SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd, and shows why each one is where deterministic policy lives. Prompts are best-effort. Hooks are guaranteed. The hook layer is where compliance becomes code.

Altimeter owns the marketplace layer. Jamin Ball’s framing is investor-grade clarity. The “agent surface” is becoming the new app store, and skills are the new apps. If a SaaS product cannot be invoked as a skill from inside that surface, it loses its place. The control plane is not just an engineering primitive. It is a distribution channel with category dynamics, network effects, and trust signals attached.

Five floors. One building. Each vendor is competing to be the landlord of one floor while everyone agrees the building exists.

What the Building Looks Like When You Step Back

Stack the layers and the architecture is legible:

Distribution. How trusted tool bundles reach a workspace. Docker is the early frontrunner; OCI is the existing rail.
Marketplace. How discovery, ranking, and invocation happen inside the agent surface. Altimeter sees the category forming; vendors are not there yet.
Harness. How the model is wrapped, what it can see, what context it carries, what sub-agents it can spawn. Anthropic is leading.
Determinism. How non-negotiable policy is enforced regardless of prompt drift. Nader Dabit articulated the spec; everyone is implementing variants.
Supervisor. How autonomous agents are reviewed by another agent before action lands in the real system. Fin is the first production proof at scale.

These are not five products. They are five surfaces of one runtime, and they need to interoperate. A skill distributed by Docker, invoked from a marketplace, executed inside Anthropic’s harness, gated by a determinism hook, and approved by a Fin-style supervisor is one workflow. Today it is five vendors and zero standards.

That is the part nobody shipped this week.

What Is Still Missing

The control plane is real. The integration story is not. Three deficits stand out, and they are where the next year of work happens.

Cross-vendor policy interop. A hook spec from Nader Dabit is not a portable artifact. A Docker Profile is not readable by Anthropic’s skill loader without translation. A Fin proposal gate does not speak the same audit format as a Vercel sandbox reproduction. Each vendor is building a credible floor. None of them publish how the floor connects to the floor above. Enterprises end up rebuilding the glue, again, for every new tool.

Audit log standard. Every layer emits its own evidence. Hooks fire and log somewhere. Skills execute and log somewhere else. Supervisor approvals land in a third place. Marketplace invocations vanish into vendor analytics. A regulator asking “show me every action this agent fleet took last quarter, who approved it, and what policy caught what” cannot get a coherent answer today. The control plane needs an OpenTelemetry-shaped spec for agent governance. Nobody owns that yet.

Marketplace trust signal. Altimeter is right that skills are the new apps. App stores are mature precisely because they have trust signals: signed binaries, reviewer queues, takedown processes, version manifests. The skill marketplace has none of that yet. Docker Catalogs are closer than anyone else because OCI artifacts already carry signatures. But a workspace administrator cannot today ask “is this skill from a vendor I have a contract with, and what is its review status?” and get a structured answer.

We covered the early signal of this category in governance as product, three vendors, May 2026 and traced the architectural roots in the symphony control plane spec and agent hooks as a persistence surface. The shape was visible. This week named it.

Why Procurement Should Care This Quarter

When a category goes from emerging to legible inside a week, procurement timelines move. The buyer who was going to write an RFP next year now has comparable line items today. A workspace administrator can ask each vendor in a finalist list five concrete questions:

Which lifecycle hooks do you expose, and which are mandatory versus opt-in?
How are skills distributed into our workspace, and what is the chain of custody?
What is the supervisor mechanism for autonomous changes, and what is its approval audit format?
How do your control plane events surface into our existing SIEM and identity layer?
What is your interop story with the other four floors when we mix vendors?

Those questions are not theoretical anymore. Each vendor in the field above has answered at least one of them publicly this week. The buyer who lets that knowledge slide is buying a model and getting a runtime they did not specify.

We have argued before that the cage pattern for agent fleet governance describes how production teams are already living inside this architecture. The vendor moves this week confirm it. The cage is no longer a metaphor. It is a stack of named layers shipping under named brands.

Do This Now

Pick one agent workflow your organization runs in production. Trace it through the five layers. Where does the trusted tool bundle come from? How is the model wrapped? Which hooks enforce policy? Who or what supervises the autonomous action before it lands? Where does the invocation evidence live for audit?

Write the answer down. If three or more layers resolve to “the prompt handles it” or “the developer knows,” you are running on best-effort, not on a control plane. The vendors who shipped this week are betting that best-effort is the part the category is replacing. The faster you map your stack, the faster you can choose which vendor owns which floor, and where you build the glue yourself.

The control plane is not a thesis anymore. It is a line item. Procurement noticed.

This analysis synthesizes Intercom Now Called Fin (VentureBeat, May 2026), How Claude Code Works in Large Codebases (Anthropic, May 2026), Custom MCP Catalogs (Docker, May 2026), Agent Hooks (Nader Dabit, May 2026), and Clouded Judgement (Altimeter, May 2026).

Victorino Group helps enterprises design and operate the agent control plane that vendor SDKs assume you already have. Let’s talk.